vector (STL/CLR)
A classe de modelo descreve um objeto que controla uma sequência de tamanho variável de elementos que têm acesso aleatório. Você usa o contêiner vector para gerenciar uma sequência de elementos como um bloco contíguo de armazenamento. O bloco é implementado como uma matriz que cresce sob demanda.
Na descrição abaixo, GValue é o mesmo que Value, a menos que o último seja do tipo ref, caso em que seria Value^.
Sintaxe
template<typename Value>
ref class vector
: public
System::ICloneable,
System::Collections::IEnumerable,
System::Collections::ICollection,
System::Collections::Generic::IEnumerable<GValue>,
System::Collections::Generic::ICollection<GValue>,
System::Collections::Generic::IList<GValue>,
Microsoft::VisualC::StlClr::IVector<GValue>
{ ..... };
Parâmetros
Valor
O tipo de um elemento na sequência controlada.
Requisitos
Cabeçalho:<cliext/vector>
Namespace: cliext
Declarações
| Definição de tipo | Descrição |
|---|---|
| vector::const_iterator (STL/CLR) | O tipo de um iterador de constante para a sequência controlada. |
| vector::const_reference (STL/CLR) | O tipo de uma referência de constante para um elemento. |
| vector::const_reverse_iterator (STL/CLR) | O tipo de um iterador reverso de constante para a sequência controlada. |
| vector::difference_type (STL/CLR) | O tipo de uma distância com sinal entre dois elementos. |
| vector::generic_container (STL/CLR) | O tipo da interface genérica para o contêiner. |
| vector::generic_iterator (STL/CLR) | O tipo de um iterador da interface genérica para o contêiner. |
| vector::generic_reverse_iterator (STL/CLR) | O tipo de um iterador reverso da interface genérica para o contêiner. |
| vector::generic_value (STL/CLR) | O tipo de um elemento da interface genérica para o contêiner. |
| vector::iterator (STL/CLR) | O tipo de um iterador para a sequência controlada. |
| vector::reference (STL/CLR) | O tipo de uma referência para um elemento. |
| vector::reverse_iterator (STL/CLR) | O tipo de um iterador inverso para a sequência controlada. |
| vector::size_type (STL/CLR) | O tipo de uma distância com sinal entre dois elementos. |
| vector::value_type (STL/CLR) | O tipo de um elemento. |
| Função membro | Descrição |
|---|---|
| vector::assign (STL/CLR) | Substitui todos os elementos. |
| vector::at (STL/CLR) | Acessa um elemento em uma posição especificada. |
| vector::back (STL/CLR) | Acessa o último elemento. |
| vector::begin (STL/CLR) | Designa o início da sequência controlada. |
| vector::capacity (STL/CLR) | Relata o tamanho do armazenamento alocado para o contêiner. |
| vector::clear (STL/CLR) | Remove todos os elementos. |
| vector::empty (STL/CLR) | Testa se nenhum elemento está presente. |
| vector::end (STL/CLR) | Designa o fim da sequência controlada. |
| vector::erase (STL/CLR) | Remove os elementos em posições especificadas. |
| vector::front (STL/CLR) | Acessa o primeiro elemento. |
| vector::insert (STL/CLR) | Adiciona elementos a uma posição especificada. |
| vector::pop_back (STL/CLR) | Remove o último elemento. |
| vector::push_back (STL/CLR) | Adiciona um novo último elemento. |
| vector::rbegin (STL/CLR) | Designa o início da sequência controlada invertida. |
| vector::rend (STL/CLR) | Designa o fim da sequência controlada invertida. |
| vector::reserve (STL/CLR) | Garante uma capacidade de crescimento mínima para o contêiner. |
| vector::resize (STL/CLR) | Altera o número de elementos. |
| vector::size (STL/CLR) | Conta o número de elementos. |
| vector::swap (STL/CLR) | Alterna o conteúdo de dois contêineres. |
| vector::to_array (STL/CLR) | Copia a sequência controlada para uma nova matriz. |
| vector::vector (STL/CLR) | Constrói um objeto contêiner. |
| Propriedade | Descrição |
|---|---|
| vector::back_item (STL/CLR) | Acessa o último elemento. |
| vector::front_item (STL/CLR) | Acessa o primeiro elemento. |
| Operador | Descrição |
|---|---|
| vector::operator= (STL/CLR) | Substitui a sequência controlada. |
| vector::operator(STL/CLR) | Acessa um elemento em uma posição especificada. |
| operator!= (vector) (STL/CLR) | Determina se um objeto vector é diferente de outro objeto vector. |
| operator< (vector) (STL/CLR) | Determina se um objeto vector é menor que outro objeto vector. |
| operator<= (vector) (STL/CLR) | Determina se um objeto vector é menor ou igual a outro objeto vector. |
| operator== (vector) (STL/CLR) | Determina se um objeto vector é igual a outro objeto vector. |
| operator> (vector) (STL/CLR) | Determina se um objeto vector é maior que outro objeto vector. |
| operator>= (vector) (STL/CLR) | Determina se um objeto vector é maior ou igual a outro objeto vector. |
Interfaces
| Interface | Descrição |
|---|---|
| ICloneable | Duplica um objeto. |
| IEnumerable | Sequencie por meio de elementos. |
| ICollection | Mantenha grupo de elementos. |
| IEnumerable<T> | Sequencie por meio de elementos de tipo. |
| ICollection<T> | Manter grupo de elementos tipados. |
| IList<T> | Mantenha o grupo ordenado de elementos tipados. |
| IVector<Value> | Manter contêiner genérico. |
Comentários
O objeto aloca e libera armazenamento para a sequência que controla por meio de uma matriz armazenada de elementos Value, que cresce sob demanda. O crescimento ocorre de tal forma que o tempo da constante será amortizado do custo de acrescentar um novo elemento. Em outras palavras, o custo de adicionar elementos no final não aumenta, em média, à medida que o comprimento da sequência controlada aumenta. Portanto, um vetor é um bom candidato para ser o contêiner subjacente para a pilha de classes de modelo (STL/CLR).
Um vector dá suporte a iteradores de acesso aleatório, o que significa que você pode se referir a um elemento diretamente dada a posição numérica dele, contando de zero para o primeiro elemento (front), até size() - 1 para o último elemento (back). Isso também significa que um vetor é um bom candidato para ser o contêiner subjacente para a classe de modelo priority_queue (STL/CLR).
Um iterador de vetor armazena um identificador no respectivo objeto vector associado, juntamente com o desvio do elemento que ele designa. Você somente pode usar iteradores com seus objetos de contêiner associados. O viés de um elemento vetor é o mesmo que a posição dele.
Inserir ou apagar elementos pode alterar o valor do elemento armazenado em uma determinada posição, de modo que o valor designado por um iterador também pode ser alterado. (O contêiner pode ter que copiar elementos para cima ou para baixo para criar um buraco antes de uma inserção ou para preencher um buraco após uma apagamento.) No entanto, um iterador de vetor permanece válido desde que o desvio dele esteja no intervalo [0, size()]. Além disso, um iterador válido permanece desreferenciável, você pode usá-lo para acessar ou alterar o valor do elemento que ele designa, desde que o desvio dele não seja igual a size().
Apagar ou remover um elemento chama o destruidor para o valor armazenado. Destruir o contêiner apaga todos os elementos. Portanto, um contêiner cujo tipo de elemento é uma classe ref garante que nenhum elemento sobreviva ao contêiner. Observe, no entanto, que um contêiner de identificadores não destrói os próprios elementos.
Membros
vector::assign (STL/CLR)
Substitui todos os elementos.
Sintaxe
void assign(size_type count, value_type val);
template<typename InIt>
void assign(InIt first, InIt last);
void assign(System::Collections::Generic::IEnumerable<Value>^ right);
Parâmetros
count
Número de elementos a inserir.
first
Início do intervalo a ser inserido.
last
Fim do intervalo a ser inserido.
direita
Enumeração a ser inserida.
val
Valor do elemento a ser inserido.
Comentários
A primeira função membro substitui a sequência controlada por uma repetição de elementos count de valor val. Você a usa para preencher o contêiner com elementos todos com o mesmo valor.
Se InIt for um tipo inteiro, a segunda função membro se comporta da mesma forma que assign((size_type)first, (value_type)last). Caso contrário, ela substituirá a sequência controlada pela sequência [first, last). Use-a para tornar a sequência controlada de uma cópia de outra sequência.
A terceira função membro substitui a sequência controlada pela sequência designada pelo enumerador direito. Use-a para tornar a sequência controlada uma cópia de uma sequência descrita por um enumerador.
Exemplo
// cliext_vector_assign.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// assign a repetition of values
cliext::vector<wchar_t> c2;
c2.assign(6, L'x');
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign an iterator range
c2.assign(c1.begin(), c1.end() - 1);
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign an enumeration
c2.assign( // NOTE: cast is not needed
(System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
x x x x x x
a b
a b c
vector::at (STL/CLR)
Acessa um elemento em uma posição especificada.
Sintaxe
reference at(size_type pos);
Parâmetros
pos
Posição do elemento a acessar.
Comentários
A função membro retorna uma referência ao elemento da sequência controlada na posição pos. Use-a para ler ou gravar um elemento cuja posição você conhece.
Exemplo
// cliext_vector_at.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c" using at
for (int i = 0; i < c1.size(); ++i)
System::Console::Write("{0} ", c1.at(i));
System::Console::WriteLine();
// change an entry and redisplay
c1.at(1) = L'x';
for (int i = 0; i < c1.size(); ++i)
System::Console::Write("{0} ", c1[i]);
System::Console::WriteLine();
return (0);
}
a b c
a x c
vector::back (STL/CLR)
Acessa o último elemento.
Sintaxe
reference back();
Comentários
A função membro retorna uma referência ao último elemento da sequência controlada, que deve ser não vazia. Use-a para acessar o último elemento, quando souber que existe.
Exemplo
// cliext_vector_back.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect last item
System::Console::WriteLine("back() = {0}", c1.back());
// alter last item and reinspect
c1.back() = L'x';
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
back() = c
a b x
vector::back_item (STL/CLR)
Acessa o último elemento.
Sintaxe
property value_type back_item;
Comentários
A propriedade acessa o último elemento da sequência controlada, que deve ser não vazia. Use-a para ler ou gravar o último elemento, quando souber que existe.
Exemplo
// cliext_vector_back_item.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect last item
System::Console::WriteLine("back_item = {0}", c1.back_item);
// alter last item and reinspect
c1.back_item = L'x';
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
back_item = c
a b x
vector::begin (STL/CLR)
Designa o início da sequência controlada.
Sintaxe
iterator begin();
Comentários
A função membro retorna um iterador de acesso aleatório que designa o primeiro elemento da sequência controlada ou logo após o final de uma sequência vazia. Use-o para obter um iterador que designa o início current da sequência controlada, mas seu status poderá mudar se o tamanho da sequência controlada for alterado.
Exemplo
// cliext_vector_begin.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect first two items
cliext::vector<wchar_t>::iterator it = c1.begin();
System::Console::WriteLine("*begin() = {0}", *it);
System::Console::WriteLine("*++begin() = {0}", *++it);
// alter first two items and reinspect
*--it = L'x';
*++it = L'y';
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
*begin() = a
*++begin() = b
x y c
vector::capacity (STL/CLR)
Relata o tamanho do armazenamento alocado para o contêiner.
Sintaxe
size_type capacity();
Comentários
A função membro retorna o armazenamento alocado no momento para manter a sequência controlada, um valor pelo menos do tamanho de vector::size (STL/CLR)(). Use-a para determinar quanto o contêiner pode crescer antes que ele precise realocar o armazenamento para a sequência controlada.
Exemplo
// cliext_vector_capacity.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for (int i = 0; i < c1.size(); ++i)
System::Console::Write("{0} ", c1.at(i));
System::Console::WriteLine();
// increase capacity
cliext::vector<wchar_t>::size_type cap = c1.capacity();
System::Console::WriteLine("capacity() = {0}, ok = {1}",
cap, c1.size() <= cap);
c1.reserve(cap + 5);
System::Console::WriteLine("capacity() = {0}, ok = {1}",
c1.capacity(), cap + 5 <= c1.capacity());
return (0);
}
a b c
capacity() = 4, ok = True
capacity() = 9, ok = True
vector::clear (STL/CLR)
Remove todos os elementos.
Sintaxe
void clear();
Comentários
A função membro chama efetivamente vector::erase (STL/CLR)(vector::begin (STL/CLR)(),vector::end (STL/CLR)()). Use para garantir que a sequência controlada esteja vazia.
Exemplo
// cliext_vector_clear.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// clear the container and reinspect
c1.clear();
System::Console::WriteLine("size() = {0}", c1.size());
// add elements and clear again
c1.push_back(L'a');
c1.push_back(L'b');
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
c1.clear();
System::Console::WriteLine("size() = {0}", c1.size());
return (0);
}
a b c
size() = 0
a b
size() = 0
vector::const_iterator (STL/CLR)
O tipo de um iterador de constante para a sequência controlada.
Sintaxe
typedef T2 const_iterator;
Comentários
O tipo descreve um objeto de tipo não especificado T2 que pode servir como um iterador de acesso aleatório de constante para a sequência controlada.
Exemplo
// cliext_vector_const_iterator.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
cliext::vector<wchar_t>::const_iterator cit = c1.begin();
for (; cit != c1.end(); ++cit)
System::Console::Write("{0} ", *cit);
System::Console::WriteLine();
return (0);
}
a b c
vector::const_reference (STL/CLR)
O tipo de uma referência de constante para um elemento.
Sintaxe
typedef value_type% const_reference;
Comentários
O tipo descreve uma referência de constante para um elemento.
Exemplo
// cliext_vector_const_reference.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
cliext::vector<wchar_t>::const_iterator cit = c1.begin();
for (; cit != c1.end(); ++cit)
{ // get a const reference to an element
cliext::vector<wchar_t>::const_reference cref = *cit;
System::Console::Write("{0} ", cref);
}
System::Console::WriteLine();
return (0);
}
a b c
vector::const_reverse_iterator (STL/CLR)
O tipo de um iterador reverso de constante para a sequência controlada.
Sintaxe
typedef T4 const_reverse_iterator;
Comentários
O tipo descreve um objeto de tipo não especificado T4 que pode servir como um iterador reverso de constante para a sequência controlada.
Exemplo
// cliext_vector_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c" reversed
cliext::vector<wchar_t>::const_reverse_iterator crit = c1.rbegin();
cliext::vector<wchar_t>::const_reverse_iterator crend = c1.rend();
for (; crit != crend; ++crit)
System::Console::Write("{0} ", *crit);
System::Console::WriteLine();
return (0);
}
c b a
vector::difference_type (STL/CLR)
Os tipos de uma distância com sinal entre dois elementos.
Sintaxe
typedef int difference_type;
Comentários
O tipo descreve uma contagem de elementos com sinal.
Exemplo
// cliext_vector_difference_type.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// compute positive difference
cliext::vector<wchar_t>::difference_type diff = 0;
for (cliext::vector<wchar_t>::iterator it = c1.begin();
it != c1.end(); ++it) ++diff;
System::Console::WriteLine("end()-begin() = {0}", diff);
// compute negative difference
diff = 0;
for (cliext::vector<wchar_t>::iterator it = c1.end();
it != c1.begin(); --it) --diff;
System::Console::WriteLine("begin()-end() = {0}", diff);
return (0);
}
a b c
end()-begin() = 3
begin()-end() = -3
vector::empty (STL/CLR)
Testa se nenhum elemento está presente.
Sintaxe
bool empty();
Comentários
A função membro retorna verdadeiro para uma sequência controlada vazia. É equivalente a vector::size (STL/CLR)() == 0. Você pode usá-lo para testar se o vetor está vazio.
Exemplo
// cliext_vector_empty.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("size() = {0}", c1.size());
System::Console::WriteLine("empty() = {0}", c1.empty());
// clear the container and reinspect
c1.clear();
System::Console::WriteLine("size() = {0}", c1.size());
System::Console::WriteLine("empty() = {0}", c1.empty());
return (0);
}
a b c
size() = 3
empty() = False
size() = 0
empty() = True
vector::end (STL/CLR)
Designa o fim da sequência controlada.
Sintaxe
iterator end();
Comentários
A função membro retorna um iterador de acesso aleatório que aponta para logo após o fim da sequência controlada. Use-o para obter um iterador que designa o fim current da sequência controlada, mas seu status poderá mudar se o tamanho da sequência controlada for alterado.
Exemplo
// cliext_vector_end.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect last two items
cliext::vector<wchar_t>::iterator it = c1.end();
--it;
System::Console::WriteLine("*-- --end() = {0}", *--it);
System::Console::WriteLine("*--end() = {0}", *++it);
// alter first two items and reinspect
*--it = L'x';
*++it = L'y';
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
*-- --end() = b
*--end() = c
a x y
vector::erase (STL/CLR)
Remove os elementos em posições especificadas.
Sintaxe
iterator erase(iterator where);
iterator erase(iterator first, iterator last);
Parâmetros
first
Início do intervalo a ser apagado.
last
Fim do intervalo a ser apagado.
where
Elemento a ser apagado.
Comentários
A primeira função membro remove o elemento da sequência controlada apontada por onde. Use para remover apenas um elemento.
A segunda função de membro remove os elementos da sequência controlada no intervalo [first, last). Use para remover zero ou mais elementos contíguos.
As primeiras funções membro retornarão um iterador que designa o primeiro elemento restante além de todos os elementos removidos ou vector::end (STL/CLR)() se esse elemento não existir.
Ao apagar elementos, o número de cópias de elemento é linear no número de elementos entre o final da eliminação e o final mais próximo da sequência. (Ao apagar um ou mais elementos em qualquer extremidade da sequência, nenhuma cópia de elemento ocorre).
Exemplo
// cliext_vector_erase.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// erase an element and reinspect
System::Console::WriteLine("erase(begin()) = {0}",
*c1.erase(c1.begin()));
// add elements and display " b c d e"
c1.push_back(L'd');
c1.push_back(L'e');
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// erase all but end
cliext::vector<wchar_t>::iterator it = c1.end();
System::Console::WriteLine("erase(begin(), end()-1) = {0}",
*c1.erase(c1.begin(), --it));
System::Console::WriteLine("size() = {0}", c1.size());
return (0);
}
a b c
erase(begin()) = b
b c d e
erase(begin(), end()-1) = e
size() = 1
vector::front (STL/CLR)
Acessa o primeiro elemento.
Sintaxe
reference front();
Comentários
A função membro retorna uma referência para o primeiro elemento da sequência controlada, que não pode ser vazio. Use-a para acessar o primeiro elemento, quando souber que existe.
Exemplo
// cliext_vector_front.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect first item
System::Console::WriteLine("front() = {0}", c1.front());
// alter first item and reinspect
c1.front() = L'x';
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
front() = a
x b c
vector::front_item (STL/CLR)
Acessa o primeiro elemento.
Sintaxe
property value_type front_item;
Comentários
A propriedade acessa o primeiro elemento da sequência controlada, que deve ser não vazia. Use-a para acessar o primeiro elemento, quando souber que existe.
Exemplo
// cliext_vector_front_item.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect first item
System::Console::WriteLine("front_item = {0}", c1.front_item);
// alter first item and reinspect
c1.front_item = L'x';
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
front_item = a
x b c
vector::generic_container (STL/CLR)
O tipo da interface genérica para o contêiner.
Sintaxe
typedef Microsoft::VisualC::StlClr::
IVector<generic_value>
generic_container;
Comentários
O tipo descreve a interface genérica para essa classe de contêiner de modelo.
Exemplo
// cliext_vector_generic_container.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct a generic container
cliext::vector<wchar_t>::generic_container^ gc1 = %c1;
for each (wchar_t elem in gc1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// modify generic and display original
gc1->insert(gc1->end(), L'd');
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// modify original and display generic
c1.push_back(L'e');
System::Collections::IEnumerator^ enum1 =
gc1->GetEnumerator();
while (enum1->MoveNext())
System::Console::Write("{0} ", enum1->Current);
System::Console::WriteLine();
return (0);
}
a b c
a b c
a b c d
a b c d e
vector::generic_iterator (STL/CLR)
O tipo de um iterador a ser usado com a interface genérica do contêiner.
Sintaxe
typedef Microsoft::VisualC::StlClr::Generic::
ContainerRandomAccessIterator<generic_value>
generic_iterator;
Comentários
O tipo descreve um iterador genérico que pode ser usado com a interface genérica para essa classe de contêiner de modelo.
Exemplo
// cliext_vector_generic_iterator.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct a generic container
cliext::vector<wchar_t>::generic_container^ gc1 = %c1;
for each (wchar_t elem in gc1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// modify generic and display original
cliext::vector<wchar_t>::generic_iterator gcit = gc1->begin();
cliext::vector<wchar_t>::generic_value gcval = *gcit;
*++gcit = gcval;
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
a b c
a a c
vector::generic_reverse_iterator (STL/CLR)
O tipo de um iterador reverso a ser usado com a interface genérica para o contêiner.
Sintaxe
typedef Microsoft::VisualC::StlClr::Generic::
ReverseRandomAccessIterator<generic_value> generic_reverse_iterator;
Comentários
O tipo descreve um iterador reverso genérico que pode ser usado com a interface genérica para essa classe de contêiner de modelo.
Exemplo
// cliext_vector_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct a generic container
cliext::vector<wchar_t>::generic_container^ gc1 = %c1;
for each (wchar_t elem in gc1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// modify generic and display original
cliext::vector<wchar_t>::generic_reverse_iterator gcit = gc1->rbegin();
cliext::vector<wchar_t>::generic_value gcval = *gcit;
*++gcit = gcval;
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
a b c
a c c
vector::generic_value (STL/CLR)
O tipo de um elemento para uso com a interface genérica do contêiner.
Sintaxe
typedef GValue generic_value;
Comentários
O tipo descreve um objeto de tipo GValue que mostra o valor do elemento armazenado a ser usado com a interface genérica para essa classe de contêiner de modelo.
Exemplo
// cliext_vector_generic_value.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct a generic container
cliext::vector<wchar_t>::generic_container^ gc1 = %c1;
for each (wchar_t elem in gc1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// modify generic and display original
cliext::vector<wchar_t>::generic_iterator gcit = gc1->begin();
cliext::vector<wchar_t>::generic_value gcval = *gcit;
*++gcit = gcval;
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
a b c
a a c
vector::insert (STL/CLR)
Adiciona elementos a uma posição especificada.
Sintaxe
iterator insert(iterator where, value_type val);
void insert(iterator where, size_type count, value_type val);
template<typename InIt>
void insert(iterator where, InIt first, InIt last);
void insert(iterator where,
System::Collections::Generic::IEnumerable<Value>^ right);
Parâmetros
count
Número de elementos a inserir.
first
Início do intervalo a ser inserido.
last
Fim do intervalo a ser inserido.
direita
Enumeração a ser inserida.
val
Valor do elemento a ser inserido.
where
Onde inserir no contêiner antes.
Comentários
Cada uma das funções membro insere, antes do elemento apontado por onde na sequência controlada, uma sequência especificada pelos operandos restantes.
A primeira função membro insere um elemento com o valor val e retorna um iterador que designa o elemento recém-inserido. Use-a para inserir apenas um elemento antes de um local designado por um iterador.
A segunda função membro insere uma repetição de elementos de contagem de valor val. Use-a para inserir zero ou mais elementos contíguos que são todos cópias do mesmo valor.
Se InIt for um tipo inteiro, a terceira função membro se comportará da mesma forma que insert(where, (size_type)first, (value_type)last). Caso contrário, ela inserirá a sequência [first, last). Use-a para inserir zero ou mais elementos contíguos copiados de outra sequência.
A quarta função membro insere a sequência designada por direita. Use-a para inserir uma sequência descrita por um enumerador.
Ao inserir apenas um elemento, o número de cópias de elemento é linear no número de elementos entre o ponto de inserção e o final mais próximo da sequência. (Ao inserir um ou mais elementos em qualquer extremidade da sequência, nenhuma cópia de elemento ocorre). Se InIt for um iterador de entrada, a terceira função membro executará efetivamente apenas uma inserção para cada elemento na sequência. Caso contrário, ao inserir elementos N, o número de cópias de elemento é linear em N mais o número de elementos entre o ponto de inserção e o final mais próximo da sequência.
Exemplo
// cliext_vector_insert.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// insert a single value using iterator
cliext::vector<wchar_t>::iterator it = c1.begin();
System::Console::WriteLine("insert(begin()+1, L'x') = {0}",
*c1.insert(++it, L'x'));
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// insert a repetition of values
cliext::vector<wchar_t> c2;
c2.insert(c2.begin(), 2, L'y');
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// insert an iterator range
it = c1.end();
c2.insert(c2.end(), c1.begin(), --it);
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// insert an enumeration
c2.insert(c2.begin(), // NOTE: cast is not needed
(System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
insert(begin()+1, L'x') = x
a x b c
y y
y y a x b
a x b c y y a x b
vector::iterator (STL/CLR)
O tipo de um iterador para a sequência controlada.
Sintaxe
typedef T1 iterator;
Comentários
O tipo descreve um objeto de tipo não especificado T1 que pode servir como um iterador de acesso aleatório para a sequência controlada.
Exemplo
// cliext_vector_iterator.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
cliext::vector<wchar_t>::iterator it = c1.begin();
for (; it != c1.end(); ++it)
System::Console::Write("{0} ", *it);
System::Console::WriteLine();
// alter first element and redisplay
it = c1.begin();
*it = L'x';
for (; it != c1.end(); ++it)
System::Console::Write("{0} ", *it);
System::Console::WriteLine();
return (0);
}
a b c
x b c
vector::operator= (STL/CLR)
Substitui a sequência controlada.
Sintaxe
vector<Value>% operator=(vector<Value>% right);
Parâmetros
direita
O contêiner a ser copiado.
Comentários
O operador membro copia a direita para o objeto e retorna *this. Use-o para substituir a sequência controlada por uma cópia da sequência controlada na direita.
Exemplo
// cliext_vector_operator_as.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign to a new container
cliext::vector<wchar_t> c2;
c2 = c1;
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
a b c
vector::operator(STL/CLR)
Acessa um elemento em uma posição especificada.
Sintaxe
reference operator[](size_type pos);
Parâmetros
pos
Posição do elemento a acessar.
Comentários
O operador membro retorna uma referência ao elemento na posição pos. Você o usa para acessar um elemento cuja posição conhecida.
Exemplo
// cliext_vector_operator_sub.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c" using subscripting
for (int i = 0; i < c1.size(); ++i)
System::Console::Write("{0} ", c1[i]);
System::Console::WriteLine();
// change an entry and redisplay
c1[1] = L'x';
for (int i = 0; i < c1.size(); ++i)
System::Console::Write("{0} ", c1[i]);
System::Console::WriteLine();
return (0);
}
a b c
a x c
vector::pop_back (STL/CLR)
Remove o último elemento.
Sintaxe
void pop_back();
Comentários
A função de membro remove o último elemento da sequência controlada, que não deve estar vazia. Use-a para reduzir o vetor em um elemento na parte de trás.
Exemplo
// cliext_vector_pop_back.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// pop an element and redisplay
c1.pop_back();
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
a b
vector::push_back (STL/CLR)
Adiciona um novo último elemento.
Sintaxe
void push_back(value_type val);
Comentários
A função membro insere um elemento com o valor val após o final da sequência controlada. Use-a para acrescentar outro elemento ao vetor.
Exemplo
// cliext_vector_push_back.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
vector::rbegin (STL/CLR)
Designa o início da sequência controlada invertida.
Sintaxe
reverse_iterator rbegin();
Comentários
A função membro retorna um iterador reverso que designa o último elemento da sequência controlada ou logo após o início de uma sequência vazia. Portanto, ele designa o beginning da sequência invertida. Use-o para obter um iterador que designa o início current da sequência controlada que é vista na ordem inversa, mas seu status poderá mudar se o tamanho da sequência controlada for alterado.
Exemplo
// cliext_vector_rbegin.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect first two items in reversed sequence
cliext::vector<wchar_t>::reverse_iterator rit = c1.rbegin();
System::Console::WriteLine("*rbegin() = {0}", *rit);
System::Console::WriteLine("*++rbegin() = {0}", *++rit);
// alter first two items and reinspect
*--rit = L'x';
*++rit = L'y';
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
*rbegin() = c
*++rbegin() = b
a y x
vector::reference (STL/CLR)
O tipo de uma referência para um elemento.
Sintaxe
typedef value_type% reference;
Comentários
O tipo descreve uma referência a um elemento.
Exemplo
// cliext_vector_reference.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
cliext::vector<wchar_t>::iterator it = c1.begin();
for (; it != c1.end(); ++it)
{ // get a reference to an element
cliext::vector<wchar_t>::reference ref = *it;
System::Console::Write("{0} ", ref);
}
System::Console::WriteLine();
// modify contents " a b c"
for (it = c1.begin(); it != c1.end(); ++it)
{ // get a reference to an element
cliext::vector<wchar_t>::reference ref = *it;
ref += (wchar_t)(L'A' - L'a');
System::Console::Write("{0} ", ref);
}
System::Console::WriteLine();
return (0);
}
a b c
A B C
vector::rend (STL/CLR)
Designa o fim da sequência controlada invertida.
Sintaxe
reverse_iterator rend();
Comentários
A função membro retorna um iterador reverso que aponta para logo após o início da sequência controlada. Portanto, ele designa o end da sequência invertida. Use-o para obter um iterador que designa o fim current da sequência controlada vista na ordem inversa, mas seu status poderá mudar se o tamanho da sequência controlada for alterado.
Exemplo
// cliext_vector_rend.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect first two items
cliext::vector<wchar_t>::reverse_iterator rit = c1.rend();
--rit;
System::Console::WriteLine("*-- --rend() = {0}", *--rit);
System::Console::WriteLine("*--rend() = {0}", *++rit);
// alter first two items and reinspect
*--rit = L'x';
*++rit = L'y';
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
*-- --rend() = b
*--rend() = a
y x c
vector::reserve (STL/CLR)
Garante uma capacidade de crescimento mínima para o contêiner.
Sintaxe
void reserve(size_type count);
Parâmetros
count
A nova capacidade mínima do contêiner.
Comentários
A função membro garante que capacity(), de agora em diante, retorne pelo menos count. Use-a para garantir que o contêiner não precise realocar o armazenamento para a sequência controlada até que ele tenha crescido para o tamanho especificado.
Exemplo
// cliext_vector_reserve.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for (int i = 0; i < c1.size(); ++i)
System::Console::Write("{0} ", c1.at(i));
System::Console::WriteLine();
// increase capacity
cliext::vector<wchar_t>::size_type cap = c1.capacity();
System::Console::WriteLine("capacity() = {0}, ok = {1}",
cap, c1.size() <= cap);
c1.reserve(cap + 5);
System::Console::WriteLine("capacity() = {0}, ok = {1}",
c1.capacity(), cap + 5 <= c1.capacity());
return (0);
}
a b c
capacity() = 4, ok = True
capacity() = 9, ok = True
vector::resize (STL/CLR)
Altera o número de elementos.
Sintaxe
void resize(size_type new_size);
void resize(size_type new_size, value_type val);
Parâmetros
new_size
O novo tamanho da sequência controlada.
val
O valor do elemento de preenchimento.
Comentários
As funções membro garantem que vector::size (STL/CLR)(), de agora em diante, retorne new_size. Se for necessário tornar a sequência controlada mais longa, a primeira função membro acrescenta elementos com valor value_type(), enquanto a segunda função membro acrescenta elementos com valor val. Para encurtar a sequência controlada, ambas as funções membro apagam efetivamente as últimas instâncias de vector::size (STL/CLR).() -new_size do elemento. Use-a para garantir que a sequência controlada tenha tamanho new_size, cortando ou preenchendo a sequência controlada atual.
Exemplo
// cliext_vector_resize.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
// construct an empty container and pad with default values
cliext::vector<wchar_t> c1;
System::Console::WriteLine("size() = {0}", c1.size());
c1.resize(4);
for each (wchar_t elem in c1)
System::Console::Write("{0} ", (int)elem);
System::Console::WriteLine();
// resize to empty
c1.resize(0);
System::Console::WriteLine("size() = {0}", c1.size());
// resize and pad
c1.resize(5, L'x');
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
size() = 0
0 0 0 0
size() = 0
x x x x x
vector::reverse_iterator (STL/CLR)
O tipo de um iterador inverso para a sequência controlada.
Sintaxe
typedef T3 reverse_iterator;
Comentários
O tipo descreve um objeto de tipo T3 não especificado que pode servir como um iterador reverso para a sequência controlada.
Exemplo
// cliext_vector_reverse_iterator.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c" reversed
cliext::vector<wchar_t>::reverse_iterator rit = c1.rbegin();
for (; rit != c1.rend(); ++rit)
System::Console::Write("{0} ", *rit);
System::Console::WriteLine();
// alter first element and redisplay
rit = c1.rbegin();
*rit = L'x';
for (; rit != c1.rend(); ++rit)
System::Console::Write("{0} ", *rit);
System::Console::WriteLine();
return (0);
}
c b a
x b a
vector::size (STL/CLR)
Conta o número de elementos.
Sintaxe
size_type size();
Comentários
A função membro retorna o comprimento da sequência controlada. Use para determinar o número de elementos que estão na sequência controlada no momento. Se sua preocupação é apenas se a sequência tem tamanho diferente de zero, confira vector::empty (STL/CLR)().
Exemplo
// cliext_vector_size.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("size() = {0} starting with 3", c1.size());
// clear the container and reinspect
c1.clear();
System::Console::WriteLine("size() = {0} after clearing", c1.size());
// add elements and clear again
c1.push_back(L'a');
c1.push_back(L'b');
System::Console::WriteLine("size() = {0} after adding 2", c1.size());
return (0);
}
a b c
size() = 3 starting with 3
size() = 0 after clearing
size() = 2 after adding 2
vector::size_type (STL/CLR)
O tipo de uma distância com sinal entre dois elementos.
Sintaxe
typedef int size_type;
Comentários
O tipo descreve uma contagem de elementos não negativos.
Exemplo
// cliext_vector_size_type.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// compute positive difference
cliext::vector<wchar_t>::size_type diff = c1.end() - c1.begin();
System::Console::WriteLine("end()-begin() = {0}", diff);
return (0);
}
a b c
end()-begin() = 3
vector::swap (STL/CLR)
Alterna o conteúdo de dois contêineres.
Sintaxe
void swap(vector<Value>% right);
Parâmetros
direita
Contêiner com o qual trocar conteúdos.
Comentários
A função membro troca as sequências controladas entre *this e direita. É feito em um tempo constante e não gera exceções. Use como uma maneira rápida de trocar o conteúdo entre dois contêineres.
Exemplo
// cliext_vector_swap.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct another container with repetition of values
cliext::vector<wchar_t> c2(5, L'x');
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// swap and redisplay
c1.swap(c2);
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
x x x x x
x x x x x
a b c
vector::to_array (STL/CLR)
Copia a sequência controlada para uma nova matriz.
Sintaxe
cli::array<Value>^ to_array();
Comentários
A função membro retorna uma matriz que contém a sequência controlada. Use para obter uma cópia da sequência controlada em formato de matriz.
Exemplo
// cliext_vector_to_array.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// copy the container and modify it
cli::array<wchar_t>^ a1 = c1.to_array();
c1.push_back(L'd');
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// display the earlier array copy
for each (wchar_t elem in a1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c d
a b c
vector::value_type (STL/CLR)
O tipo de um elemento.
Sintaxe
typedef Value value_type;
Comentários
O tipo é um sinônimo do parâmetro de modelo Value.
Exemplo
// cliext_vector_value_type.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c" using value_type
for (cliext::vector<wchar_t>::iterator it = c1.begin();
it != c1.end(); ++it)
{ // store element in value_type object
cliext::vector<wchar_t>::value_type val = *it;
System::Console::Write("{0} ", val);
}
System::Console::WriteLine();
return (0);
}
a b c
vector::vector (STL/CLR)
Constrói um objeto contêiner.
Sintaxe
vector();
vector(vector<Value>% right);
vector(vector<Value>^ right);
explicit vector(size_type count);
vector(size_type count, value_type val);
template<typename InIt>
vector(InIt first, InIt last);
vector(System::Collections::Generic::IEnumerable<Value>^ right);
Parâmetros
count
Número de elementos a inserir.
first
Início do intervalo a ser inserido.
last
Fim do intervalo a ser inserido.
direita
Objeto ou intervalo a inserir.
val
Valor do elemento a ser inserido.
Comentários
O construtor:
vector();
inicializa a sequência controlada sem elementos. Use-o para especificar uma sequência controlada inicial vazia.
O construtor:
vector(vector<Value>% right);
inicializa a sequência controlada com a sequência [right.begin(), right.end()). Use-o para especificar uma sequência controlada inicial que é uma cópia da sequência controlada pelo objeto de vetor right.
O construtor:
vector(vector<Value>^ right);
inicializa a sequência controlada com a sequência [right->begin(), right->end()). Use-o para especificar uma sequência controlada inicial que é uma cópia da sequência controlada pelo objeto de matriz cujo identificador é right.
O construtor:
explicit vector(size_type count);
inicializa a sequência controlada com elementos de contagem, cada um com o valor value_type(). Use-o para preencher o contêiner com elementos todos com o valor padrão.
O construtor:
vector(size_type count, value_type val);
inicializa a sequência controlada com elementos contagem, cada um com valor val. Você a usa para preencher o contêiner com elementos todos com o mesmo valor.
O construtor:
template<typename InIt>
vector(InIt first, InIt last);
inicializa a sequência controlada com a sequência [first, last). Use-a para tornar a sequência controlada uma cópia de outra sequência.
O construtor:
vector(System::Collections::Generic::IEnumerable<Value>^ right);
inicializa a sequência controlada com a sequência designada pelo enumerador direito. Use-o para tornar a sequência controlada uma cópia de outra sequência descrita por um enumerador.
Exemplo
// cliext_vector_construct.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
// construct an empty container
cliext::vector<wchar_t> c1;
System::Console::WriteLine("size() = {0}", c1.size());
// construct with a repetition of default values
cliext::vector<wchar_t> c2(3);
for each (wchar_t elem in c2)
System::Console::Write("{0} ", (int)elem);
System::Console::WriteLine();
// construct with a repetition of values
cliext::vector<wchar_t> c3(6, L'x');
for each (wchar_t elem in c3)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct with an iterator range
cliext::vector<wchar_t>::iterator it = c3.end();
cliext::vector<wchar_t> c4(c3.begin(), --it);
for each (wchar_t elem in c4)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct with an enumeration
cliext::vector<wchar_t> c5( // NOTE: cast is not needed
(System::Collections::Generic::IEnumerable<wchar_t>^)%c3);
for each (wchar_t elem in c5)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct by copying another container
cliext::vector<wchar_t> c7(c3);
for each (wchar_t elem in c7)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct by copying a container handle
cliext::vector<wchar_t> c8(%c3);
for each (wchar_t elem in c8)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
size() = 0
0 0 0
x x x x x x
x x x x x
x x x x x x
x x x x x x
x x x x x x
operator!= (vector) (STL/CLR)
Comparação de vetor diferente de.
Sintaxe
template<typename Value>
bool operator!=(vector<Value>% left,
vector<Value>% right);
Parâmetros
esquerda
Contêiner esquerdo a comparar.
direita
Contêiner direito a comparar.
Comentários
A função do operador retorna !(left == right). Use-a para testar se left não é ordenado da mesma forma que right quando os dois vetores são comparados elemento por elemento.
Exemplo
// cliext_vector_operator_ne.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign to a new container
cliext::vector<wchar_t> c2;
c2.push_back(L'a');
c2.push_back(L'b');
c2.push_back(L'd');
// display contents " a b d"
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("[a b c] != [a b c] is {0}",
c1 != c1);
System::Console::WriteLine("[a b c] != [a b d] is {0}",
c1 != c2);
return (0);
}
a b c
a b d
[a b c] != [a b c] is False
[a b c] != [a b d] is True
operator< (vector) (STL/CLR)
Comparação de vetor menor que.
Sintaxe
template<typename Value>
bool operator<(vector<Value>% left,
vector<Value>% right);
Parâmetros
esquerda
Contêiner esquerdo a comparar.
direita
Contêiner direito a comparar.
Comentários
A função de operador retorna true se, para a posição i mais baixa para a qual !(right[i] < left[i]) também é verdade que left[i] < right[i]. Caso contrário, ela retornará left->size() < right->size(), que você usará para testar se left é ordenado antes de right quando os dois conjuntos são comparados elemento por elemento.
Exemplo
// cliext_vector_operator_lt.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign to a new container
cliext::vector<wchar_t> c2;
c2.push_back(L'a');
c2.push_back(L'b');
c2.push_back(L'd');
// display contents " a b d"
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("[a b c] < [a b c] is {0}",
c1 < c1);
System::Console::WriteLine("[a b c] < [a b d] is {0}",
c1 < c2);
return (0);
}
a b c
a b d
[a b c] < [a b c] is False
[a b c] < [a b d] is True
operator<= (vector) (STL/CLR)
Comparação de vetor menor ou igual a.
Sintaxe
template<typename Value>
bool operator<=(vector<Value>% left,
vector<Value>% right);
Parâmetros
esquerda
Contêiner esquerdo a comparar.
direita
Contêiner direito a comparar.
Comentários
A função do operador retorna !(right < left). Use-a para testar se left não é ordenado após right quando os dois vetores são comparados elemento por elemento.
Exemplo
// cliext_vector_operator_le.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign to a new container
cliext::vector<wchar_t> c2;
c2.push_back(L'a');
c2.push_back(L'b');
c2.push_back(L'd');
// display contents " a b d"
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("[a b c] <= [a b c] is {0}",
c1 <= c1);
System::Console::WriteLine("[a b d] <= [a b c] is {0}",
c2 <= c1);
return (0);
}
a b c
a b d
[a b c] <= [a b c] is True
[a b d] <= [a b c] is False
operator== (vector) (STL/CLR)
Comparação vetor igual a.
Sintaxe
template<typename Value>
bool operator==(vector<Value>% left,
vector<Value>% right);
Parâmetros
esquerda
Contêiner esquerdo a comparar.
direita
Contêiner direito a comparar.
Comentários
A função do operador retornará true somente se as sequências controladas por left e right tiverem o mesmo comprimento e, para cada posição i, left[i] ==right[i]. Use-a para testar se left é ordenado da mesma forma que right quando os dois vetores são comparados elemento por elemento.
Exemplo
// cliext_vector_operator_eq.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign to a new container
cliext::vector<wchar_t> c2;
c2.push_back(L'a');
c2.push_back(L'b');
c2.push_back(L'd');
// display contents " a b d"
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("[a b c] == [a b c] is {0}",
c1 == c1);
System::Console::WriteLine("[a b c] == [a b d] is {0}",
c1 == c2);
return (0);
}
a b c
a b d
[a b c] == [a b c] is True
[a b c] == [a b d] is False
operator> (vector) (STL/CLR)
Comparação de vetor maior que.
Sintaxe
template<typename Value>
bool operator>(vector<Value>% left,
vector<Value>% right);
Parâmetros
esquerda
Contêiner esquerdo a comparar.
direita
Contêiner direito a comparar.
Comentários
A função do operador retorna right<left. Use-a para testar se left é ordenado após right quando os dois vetores são comparados elemento por elemento.
Exemplo
// cliext_vector_operator_gt.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign to a new container
cliext::vector<wchar_t> c2;
c2.push_back(L'a');
c2.push_back(L'b');
c2.push_back(L'd');
// display contents " a b d"
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("[a b c] > [a b c] is {0}",
c1 > c1);
System::Console::WriteLine("[a b d] > [a b c] is {0}",
c2 > c1);
return (0);
}
a b c
a b d
[a b c] > [a b c] is False
[a b d] > [a b c] is True
operator>= (vector) (STL/CLR)
Comparação de vetor maior que ou igual a.
Sintaxe
template<typename Value>
bool operator>=(vector<Value>% left,
vector<Value>% right);
Parâmetros
esquerda
Contêiner esquerdo a comparar.
direita
Contêiner direito a comparar.
Comentários
A função do operador retorna !(left < right). Use-a para testar se left não é ordenado antes de right quando os dois vetores são comparados elemento por elemento.
Exemplo
// cliext_vector_operator_ge.cpp
// compile with: /clr
#include <cliext/vector>
int main()
{
cliext::vector<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign to a new container
cliext::vector<wchar_t> c2;
c2.push_back(L'a');
c2.push_back(L'b');
c2.push_back(L'd');
// display contents " a b d"
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("[a b c] >= [a b c] is {0}",
c1 >= c1);
System::Console::WriteLine("[a b c] >= [a b d] is {0}",
c1 >= c2);
return (0);
}
a b c
a b d
[a b c] >= [a b c] is True
[a b c] >= [a b d] is False
Comentários
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulte https://aka.ms/ContentUserFeedback.
Enviar e exibir comentários de