Como usar o vetor C ++

Uma matriz é uma série dos mesmos tipos de objetos em locais consecutivos de memória. Uma matriz não pode aumentar o minério de redução de comprimento. Um vetor é como uma matriz, mas seu comprimento pode ser aumentado ou reduzido. Um vetor, portanto, tem muito mais operações do que uma matriz. C ++ possui muitas bibliotecas, todas formadas na biblioteca padrão C ++. Uma dessas bibliotecas é a biblioteca de contêineres. Um contêiner é uma coleção de objetos e certas operações podem ser executadas na coleção. Os contêineres C ++ podem ser agrupados em dois conjuntos: recipientes de sequência e contêineres associativos. Os contêineres de sequência são vetoriais, Array (não a mesma matriz discutida anteriormente), deque, Forward_list e List. Essas são coleções diferentes (estruturas de dados semelhantes a matrizes) e cada uma oferece trade-offs distintos. Qualquer programador deve saber como decidir se deve usar um vetor, uma matriz, um deque, um forward_list ou uma lista. Quando um programador precisa de uma estrutura que requer mais operações do que aquelas associadas a uma matriz comum, a matriz comum não deve ser usada. Se a tarefa envolver inserções e deleções frequentes no meio da sequência, uma lista ou forward_list devem ser usados. Se a tarefa envolver inserções e deleções frequentes no início ou no final de uma sequência, então um deque deve ser usado. Um vetor deve ser usado quando esses tipos de operações não forem necessários. Este artigo mostra como usar o vetor C ++. Você precisará de algum conhecimento de ponteiros de C ++, referências e matrizes para entender este artigo.

Classe e objetos

Uma classe é um conjunto de variáveis ​​e funções que funcionam juntas, onde as variáveis ​​não têm valores atribuídos. Quando os valores são atribuídos às variáveis, uma classe se torna um objeto. Valores diferentes dados à mesma classe resultam em objetos diferentes; isto é, objetos diferentes podem ser da mesma classe, mas têm valores diferentes. Criar um objeto de uma classe também é conhecido como instanciando o objeto.

O termo vetor descreve uma classe. Um objeto criado a partir de um vetor tem um nome escolhido pelo programador.

É necessária uma função que pertence a uma classe para instanciar um objeto da classe. Em C ++, essa função tem o mesmo nome que o nome da classe. Diferentes objetos criados (instanciados) da classe têm nomes distintos dados a cada um deles pelo programador.

Criar um objeto de uma classe significa construir o objeto; também significa instantar o objeto.

A classe vetorial

A classe vetorial já foi definida e está na biblioteca. Para usar a classe vetorial, um programador deve incluir o cabeçalho do vetor no arquivo com a seguinte diretiva de pré -processamento:

#incluir

Depois que o cabeçalho está incluído, todos os recursos do vetor (membros de dados e funções membros) se tornam acessíveis. Para usar o objeto de contagem para produzir dados para o terminal (console), o cabeçalho do objeto também deve ser incluído. Para escrever um programa com o vetor, no mínimo, os seguintes cabeçalhos devem ser incluídos:

#incluir
#incluir

Instanciando um vetor

int foo [10];

Acima está a declaração de uma matriz com o nome "Foo" e o número de elementos "10.”Esta é uma variedade de números inteiros. A declaração de um vetor é semelhante. Para um vetor, o número de elementos é opcional, pois o comprimento do vetor pode aumentar ou diminuir.

Neste ponto do programa, a classe vetorial já foi definida na biblioteca, e o cabeçalho foi incluído. O vetor pode ser instanciado da seguinte maneira:

std :: vetor vtr (8);

Aqui, o vetor é da função de construtor especial. O tipo de dados que o vetor manterá é "int", em suportes de ângulo. O termo "vtr" é o nome escolhido pelo programador para o vetor. Finalmente, "8", entre parênteses, é o número tentativo de números inteiros que o vetor terá.

O termo "std" significa espaço para nome padrão. Este termo deve ser seguido por um cólon duplo, neste contexto. Qualquer um pode escrever sua própria biblioteca de classe vetorial e usá -la. No entanto, o C ++ já possui uma biblioteca padrão com nomes padrão, incluindo “Vector.”Para usar um nome padrão, o nome padrão deve ser precedido por std :: . Para evitar digitar STD :: Cada vez no programa para um nome padrão, o arquivo do programa pode iniciar o seguinte:

#incluir
#incluir
usando namespace std;

Sobrecarregando uma função

Quando duas ou mais assinaturas de função diferentes têm o mesmo nome, esse nome é considerado sobrecarregado. Quando uma função é chamada, o número e o tipo de argumentos determinam qual função é executada.

Construindo um vetor

Construir um vetor significa instanciando (criando) um objeto vetorial. A função construtora está sobrecarregada da seguinte forma:

Nome do vetor

Isso cria um vetor de comprimento zero e digite “t."A declaração a seguir cria um vetor de comprimento zero do tipo" Float "com o nome" VTR: "

vetor vtr;

Nome do vetor (n)

Isso cria um vetor com n elementos do tipo “t.”Uma declaração para este vetor com quatro elementos flutuantes é o seguinte:

vetor vtr (4);

Nome do vetor (n, t)

Isso cria um vetor de n elementos inicializados para o valor t. A afirmação a seguir cria um vetor de 5 elementos, onde cada elemento tem o valor 3.4:

vetor VTR (5, 3.4);

Construindo com inicialização

Um vetor pode ser construído (criado) e inicializado ao mesmo tempo, de uma das duas maneiras a seguir:

vetor vtr = 1.1, 2.2, 3.3, 4.4;

Ou

vetor Vtr 1.1, 2.2, 3.3, 4.4;

Observe que não há parênteses logo após o nome do objeto. Parênteses usados ​​logo após o nome do objeto deve ter a lista de inicializadores, como segue:

vetor vtr (1.1, 2.2, 3.3, 4.4);

Um vetor pode ser construído e inicializado posteriormente com a lista de inicializador. Nesse caso, os parênteses não serão usados:

vetor vtr;
vtr = 1.1, 2.2, 3.3, 4.4;

Vector V2 (V1)

Este é um construtor de cópia. Cria um vetor V2 como uma cópia do vetor V1. O código a seguir ilustra o seguinte:

vetor Vtr1 (5, 3.4);
vetor vtr2 (vtr1);

Atribuindo um vetor durante a construção

Durante a construção, um vetor vazio pode ser criado enquanto outro é atribuído a ele, como segue:

vetor Vtr1 1.1, 2.2, 3.3, 4.4;
vetor vtr2 = vtr1;

A segunda declaração é equivalente a:

vetor vtr2 = 1.1, 2.2, 3.3, 4.4;

const vetor

Um vetor const é um vetor cujos elementos não podem ser alterados. Os valores neste vetor são somente leitura. Quando criado, o vetor aparece o seguinte:

const vetor Vtr 1.1, 2.2, 3.3, 4.4;

Neste tipo de vetor, nenhum elemento pode ser adicionado ou removido. Além disso, nenhum valor pode ser alterado.

Construindo com o iterador

Um modelo fornece uma representação genérica para um tipo de dados. Um iterador fornece uma representação genérica de digitalização através dos valores de um contêiner. A sintaxe para criar um vetor com um iterador é o seguinte:

modelo
vetor (inputIterator primeiro, inputIterator Último, const alocator & = alocator ());

Isso constrói um vetor para o intervalo [primeiro, último) usando o alocador especificado, que será discutido mais adiante neste artigo.

Destruindo um vetor

Para destruir um vetor, basta permitir que ele saia do escopo e destrua é tratado automaticamente.

Capacidade do vetor

size_type capacidade () const Noexcept

O número total de elementos que o vetor pode manter sem exigir a realocação é retornado pela função de membro da capacidade. Um segmento de código para isso é o seguinte:

vetor vtr (4);
int num = vtr.capacidade();
cout << num << '\n';

A saída é 4.

Reserva (n)

O espaço de memória nem sempre está disponível gratuitamente. Espaço extra pode ser reservado com antecedência. Considere o seguinte segmento de código:

vetor vtr (4);
vtr.reserva (6);
cout << vtr.capacity() << '\n';

A saída é 6. Então, o espaço extra reservado é 6 - 4 = 2 elementos. A função retorna vazios.

tamanho () const noexcept

Isso retorna o número de elementos no vetor. O código a seguir ilustra esta função:

vetor vtr (4);
flutuar sz = vtr.tamanho();
cout << sz << '\n';

A saída é 4.

encolher para caber()

Depois de fornecer capacidade extra para um vetor com a função Reserve (), o vetor pode ser dimensionado para se encaixar no seu tamanho original. O código a seguir ilustra o seguinte:

vetor vtr (4);
vtr.reserva (6);
vtr.encolher para caber();
int sz = vtr.tamanho();
cout << sz << '\n';

A saída é 4 e não 6. A função retorna vazios.

redimensionar (sz), redimensionar (sz, c)

Isso redimensiona o vetor. Se o novo tamanho for menor que o tamanho antigo, os elementos no final serão apagados. Se o novo tamanho for mais longo, algum valor padrão será adicionado ao final. Para ter um valor adicionado específico, use a função redize () com dois argumentos. O segmento de código a seguir ilustra o uso dessas duas funções:

vetor Vtr1 1.1, 2.2, 3.3, 4.4;
vtr1.redimensionar (2);
cout << "New size of vtr1: " << vtr1.size() << '\n';
vetor Vtr2 1.1, 2.2;
Vtr2.redimensionar (4, 8.8);
cout << "vtr2: "<< vtr2[0] <<" "<< vtr2[1] <<"
"<< vtr2[2] <<" "<< vtr2[3] << '\n';

A saída é a seguinte:

Novo tamanho de Vtr1: 2
Vtr2: 1.1 2.2 8.8 8.8

As funções retornam vazio.

vazio () const Noexcept

Esta função retorna 1 para verdadeiro se não houver elementos no vetor e 0 para false se o vetor estiver vazio. Se um vetor tiver 4 locais para um tipo específico de dados, como flutuação, sem nenhum valor de flutuação, esse vetor não está vazio. O código a seguir ilustra o seguinte:

vetor vtr;
cout << vtr.empty() << '\n';
vetor vt (4);
cout << vt.empty() << '\n';
vetor v (4,3.5);
cout << v.empty() << '\n';

A saída é a seguinte:

1
0
0

Acesso ao elemento vetorial

Um vetor pode ser sub-roteiro (indexado) como uma matriz. A contagem de índice começa de zero.

vectorname [i]

A operação "VectorName [i]" retorna uma referência ao elemento no I^º índice do vetor. O código seguinte sai 3.3 para o vetor acima:

vetor Vtr 1.1, 2.2, 3.3, 4.4;
flutuar fl = vtr [2];
cout << fl << '\n';

vectorname [i] const

A operação "VectorName [i] const" é executada em vez de "vectorname [i]" quando o vetor é um vetor constante. Esta operação é usada no seguinte código:

const vetor Vtr 1.1, 2.2, 3.3, 4.4;
flutuar fl = vtr [2];
cout << fl << '\n';

A expressão retorna uma referência constante ao i^º elemento do vetor.

Atribuir um valor com subscrito

Um valor pode ser atribuído a um vetor não constante, como segue:

vetor Vtr 1.1, 2.2, 3.3, 4.4;
VTR [2] = 8.8;
cout << vtr[2] << '\n';

A saída é 8.8.

vectorname.em (i)

“VECTORNAME.AT (i) "é como" VECTORNAME [i] ", mas" Vectorname.em (i) ”é mais confiável. O código a seguir mostra como esse vetor deve ser usado:

vetor Vtr 1.1, 2.2, 3.3, 4.4;
flutuar fl = vtr.em (2);
cout << fl << '\n';
em () é uma função de membro vetorial.

vectorname.em (i) const

“VECTORNAME.AT (i) const ”é como“ VECTORNAME [i] const ”, mas“ VecTorName.em (i) const ”é mais confiável. “VECTORNAME.em (i) const ”é executado em vez de“ VecTorname.em (i) ”quando o vetor é um vetor constante. Este vetor é usado no seguinte código:

const vetor Vtr 1.1, 2.2, 3.3, 4.4;
flutuar fl = vtr.em (2);
cout << fl << '\n';
em () const é uma função de membro vetorial.

Atribuindo um valor com a função AT ()

Um valor pode ser atribuído a um vetor não constante com a função AT (), como segue:

vetor Vtr 1.1, 2.2, 3.3, 4.4;
vtr.em (2) = 8.8;
cout << vtr[2] << '\n';

A saída é 8.8.

Problema com sub-scripts

O problema com a sub-scripts (indexação) é que, se o índice estiver fora do alcance, o zero poderá ser retornado ou um erro poderá ser emitido em tempo de execução.

frente()

Isso retorna uma referência ao primeiro elemento do vetor sem remover o elemento. A saída do código a seguir é 1.1.

vetor Vtr 1.1, 2.2, 3.3, 4.4;
flutuar fl = vtr.frente();
cout << fl << '\n';

O elemento não é removido do vetor.

frente () const

Quando a construção do vetor é precedida por const, a expressão "front () const" é executada em vez de "front ().”Isso é usado no seguinte código:

const vetor Vtr 1.1, 2.2, 3.3, 4.4;
flutuar fl = vtr.frente();
cout << fl << '\n';

Uma referência constante é retornada. O elemento não é removido do vetor.

voltar()

Isso retorna uma referência ao último elemento do vetor sem remover o elemento. A saída do código a seguir é 4.4.

vetor Vtr 1.1, 2.2, 3.3, 4.4;
flutuar fl = vtr.voltar();
cout << fl << '\n';

Back () const

Quando a construção do vetor é precedida pela const, a expressão "Back () const" é executada em vez de "traseiro ().”Isso é usado no seguinte código:

const vetor Vtr 1.1, 2.2, 3.3, 4.4;
flutuar fl = vtr.voltar();
cout << fl << '\n';

Uma referência constante é retornada. O elemento não é removido do vetor.

Acesso de dados vetoriais

data () NoExcept; data () const NoExcept;

Qualquer um deles retorna um ponteiro de modo que [data (), data () + size ()) é um intervalo válido.

Isso será abordado com mais detalhes mais tarde no artigo.

Iteradores retornando e o vetor

Um iterador é como um ponteiro, mas tem mais funcionalidade do que um ponteiro.

Begin () NoExcept

Retorna um iterador que aponta para o primeiro elemento do vetor, como no seguinte segmento de código:

vetor Vtr 1.1, 2.2, 3.3, 4.4;
vetor:: iterator iter = vtr.começar();
cout << *iter << '\n';

A saída é 1.1. Observe que a declaração que recebe o iterador foi declarada. O iterador é desreferenciado em uma expressão de retorno para obter o valor da mesma maneira que um ponteiro é desreferenciado.

BEGIN () const NoExcept;

Retorna um iterador que aponta para o primeiro elemento do vetor. Quando a construção do vetor é precedida pela const, a expressão "Begin () const" é executada em vez de "Begin ().”Sob esta condição, o elemento correspondente no vetor não pode ser modificado. Isso é usado no seguinte código:

const vetor Vtr 1.1, 2.2, 3.3, 4.4;
vetor:: const_iterator iter = vtr.começar();
cout << *iter << '\n';

A saída é 1.1. Observe que "const_iterator" foi usado desta vez, em vez de apenas "iterador" para receber o iterador devolvido.

end () noexcept

Retorna um iterador que aponta imediatamente além do último elemento do vetor. Considere o seguinte segmento de código:

vetor Vtr 1.1, 2.2, 3.3, 4.4;
vetor:: iterator iter = vtr.fim();
cout << *iter << '\n';

A saída é 0, o que não tem sentido, pois não há elemento concreto além do último elemento.

end () const noexcept

Retorna um iterador que aponta imediatamente além do último elemento do vetor. Quando a construção do vetor é precedida por "const", a expressão "end () const" é executada em vez de "end (end ().”Considere o seguinte segmento de código:

const vetor Vtr 1.1, 2.2, 3.3, 4.4;
vetor:: const_iterator iter = vtr.fim();
cout << *iter << '\n';

A saída é 0. Observe que "const_iterator" foi usado desta vez, em vez de apenas "iterador" para receber o iterador devolvido.

Iteração reversa

É possível ter um iterador que itera do final para pouco antes do primeiro elemento.

rBegin () NoExcept

Retorna um iterador que aponta para o último elemento do vetor, como no seguinte segmento de código:

vetor Vtr 1.1, 2.2, 3.3, 4.4;
vetor:: reverse_iterator riter = vtr.rBegin ();
cout << *rIter << '\n';

A saída é 4.4.

Observe que a declaração que recebe o iterador reverso foi declarada. O iterador é desreferenciado em uma expressão de retorno para obter o valor da mesma maneira que um ponteiro é desreferenciado.

rBegin () const Noexcept;

Retorna um iterador que aponta para o último elemento do vetor. Quando a construção do vetor é precedida por "const", a expressão "rBegin () const" é executada em vez de "rbegin ().”Sob esta condição, o elemento correspondente no vetor não pode ser modificado. Este recurso é usado no seguinte código:

const vetor Vtr 1.1, 2.2, 3.3, 4.4;
vetor:: const_reverse_iterator riter = vtr.rBegin ();
cout << *rIter << '\n';

A saída é 4.4.

Observe que o const_reverse_iterator foi usado desta vez, em vez de apenas o reverse_iterator, para receber o iterador devolvido.

rend () noexcept

Retorna um iterador que aponta pouco antes do primeiro elemento do vetor. Considere o seguinte segmento de código:

vetor Vtr 1.1, 2.2, 3.3, 4.4;
vetor:: reverse_iterator riter = vtr.rend ();
cout << *rIter << '\n';

A saída é 0, o que não tem sentido, pois não há elemento concreto antes do primeiro elemento.

rend () const noexcept

Retorna um iterador que aponta pouco antes do primeiro elemento do vetor. Quando a construção do vetor é precedida por "const", a expressão "rend () const" é executada em vez de "rend ().”Considere o seguinte segmento de código:

const vetor Vtr 1.1, 2.2, 3.3, 4.4;
vetor:: const_reverse_iterator riter = vtr.rend ();
cout << *rIter << '\n';

A saída é 0.

Observe que o const_reverse_iterator foi usado desta vez, em vez de apenas o reverse_iterator, para receber o iterador devolvido.

Modificadores de vetor

Um modificador que modifica o vetor pode levar ou devolver um iterador.

a.Emplace (P, Args)

Insira um objeto do tipo t construído com std :: forward (args)… antes de P.

Para detalhes - veja mais tarde

Inserir (IteratorPosition, valor)

Insere uma cópia do valor na posição do iterador do vetor. Retorna o iterador (posição) no vetor onde a cópia foi colocada. O código a seguir mostra onde o valor foi colocado:

vetor vtr 10, 20, 30, 40;
vetor:: iterator iter = vtr.começar();
++iter;
++iter;
vtr.inserir (iter, 25);
cout << vtr[1] << " << vtr[2]<< '
' << vtr[3] << '\n';

A saída é: 20 25 30.

Observe que o iterador foi avançado (incrementado) como um ponteiro.

Uma lista de inicializadores também pode ser inserida, como ilustra o código a seguir:

vetor vtr 10, 20, 30, 40;
vetor:: iterator iter = vtr.começar();
++iter;
++iter;
vtr.inserir (iter, 25, 28);
cout << vtr[1] << " << vtr[2]<< '
' << vtr[3]<< " << vtr[4] << '\n';

A saída é: 20 25 28 30.

Apagar (posição)

Remove um elemento na posição apontado pelo iterador e depois retorna a posição do iterador. O código a seguir ilustra o seguinte:

vetor vtr 10, 20, 30, 40;
vetor:: iterator iter = vtr.começar();
++iter;
++iter;
vtr.apagar (iter);
cout << vtr[0] << " << vtr[1] << '
' << vtr[2]<< '\n';

A saída é: 10 20 40

push_back (t), push_back (rv)

Usado para adicionar um único elemento no final do vetor. Use push_back (t) da seguinte forma:

vetor Vtr 1.1, 2.2, 3.3, 4.4;
vtr.push_back (5.5);
flutuar fl = vtr [4];
cout << fl << '\n';

A saída é 5.5.

push_back (rv): - Veja mais tarde.

pop_back ()

Remove o último elemento sem devolvê -lo. O tamanho do vetor é reduzido por 1. O código a seguir ilustra o seguinte:

vetor Vtr 1.1, 2.2, 3.3, 4.4;
vtr.pop_back ();
flutuar sz = vtr.tamanho();
cout << sz << '\n';

A saída é 3.

a.troca (b)

Dois vetores podem ser trocados, conforme ilustrado no seguinte segmento de código:

vetor Vtr1 1.1, 2.2, 3.3, 4.4;
vetor vtr2 10, 20;
vtr1.troca (vtr2);
cout << "vtr1: "<< vtr1[0] <<" "<< vtr1[1] <<"
"<< vtr1[2] <<" "<< vtr1[3] << '\n';
cout << "vtr2: "<< vtr2[0] <<" "<< vtr2[1] <<"
"<< vtr2[2] <<" "<< vtr2[3] << '\n';

A saída é:

Vtr1: 10 20 0 0
Vtr2: 1.1 2.2 3.3 4.4

Observe que o comprimento de um vetor é aumentado, se necessário. Além disso, os valores que não tiveram substituições são substituídos por algum valor padrão.

claro()

Remove todos os elementos do vetor, como ilustra o seguinte segmento de código:

vetor Vtr 1.1, 2.2, 3.3, 4.4;
vtr.claro();
cout << vtr.size() << '\n';

A saída é 0.

Igualdade e operadores relacionais para vetores

O operador ==

Retorna 1 para verdadeiro se os dois vetores tiverem o mesmo tamanho e os elementos correspondentes forem iguais; Caso contrário, ele retorna 0 para falso. Por exemplo:

vetor U 1, 2, 3;
vetor V 4, 5, 6;
bool bl = u == v;
cout << bl << '\n';

A saída é 0.

O != Operador

Retorna 1 para verdadeiro se os dois vetores não tiverem o mesmo tamanho e/ou os elementos correspondentes não forem iguais; Caso contrário, ele retorna 0 para falso. Por exemplo:

vetor U 1, 2, 3;
vetor V 4, 5, 6;
bool bl = u!= V;
cout << bl << '\n';

A saída é 1.

O < Operator

Retorna 1 para verdadeiro se o primeiro vetor for o subconjunto inicial do segundo vetor, com os elementos das duas partes iguais sendo iguais e na mesma ordem. Se ambos os vetores tiverem o mesmo tamanho e se move da esquerda para a direita e um elemento for encontrado no primeiro vetor que é menor que o elemento correspondente no segundo vetor, então eu ainda será retornado. Caso contrário, 0 para false é devolvido. Por exemplo:

vetor U 3, 1, 1;
vetor V 3, 2, 1;
bool bl = ucout << bl << '\n';

A saída é 1. < does not include the case when the size and order are the same.

O operador>

Retorna !(VOCÊ < V), where U is the first vector and V is the second vector, according to the above definitions.

O <= Operator

Retorna u <= V, where U is the first vector and V is the second vector, according to the above definitions.

O operador> =

Retorna !(VOCÊ <= V), where U is the first vector and V is the second vector, according to the above definitions.

Conclusão

Um vetor é um exemplo de um recipiente de sequência. Um vetor é uma forma "melhor" da matriz comum e é instanciada de uma classe. Os vetores têm métodos classificados em: Construção e atribuição, capacidade, acesso a elementos, acesso a dados, iteradores, modificadores e operadores sobrecarregados numéricos.

Existem outros contêineres de sequência, chamados list, Forward_list e Array. Se a tarefa envolver inserções e deleções frequentes no meio da sequência, uma lista ou forward_list devem ser usados. Se a tarefa envolver inserções e deleções frequentes no início ou no final da sequência, então um deque deve ser usado. E assim, os vetores devem ser usados ​​apenas quando esses tipos de operações não forem importantes.