Como você expande um vetor em c++?

Se "expandir" aqui significa incluir mais elementos no vetor para que seu tamanho (comprimento) aumente, um vetor poderá ser expandido. No entanto, “expandir um vetor” não é uma frase clássica em c++. De fato, "expandir" em C ++ realmente significa, substitua o nome de um objeto com os valores de seu conteúdo.Se um vetor consiste em literais de string, o vetor poderá ser substituído por uma string composta por literais de string. No entanto, isso deve ser feito manualmente. Isto é, deve ser feito pelo programador e não por uma biblioteca.

Não obstante, este post explicará como substituir um vetor de literais de cordas, com uma corda dos literais. Este post também explicará as diferentes maneiras pelas quais o vetor C ++ pode ser aumentado em comprimento. O comprimento de um vetor em C ++ é chamado de tamanho.

O vetor tem funções de membro. Seu tamanho pode ser aumentado usando as funções de membro: redize (), insert (), emplace () e push_back (). Este artigo explica as diferentes maneiras pelas quais o vetor pode ser expandido, ou seja, aumentado em tamanho; e no caso do vetor de literais de cordas, substituído por todos os literais de cordas.

Faça codificação de vetores dentro do corpo da função principal (), a menos que haja um bom motivo para fazê -lo antes do corpo da função principal (). Não se esqueça de começar o programa com:

#incluir
#incluir
usando namespace std;

Conteúdo do artigo

• Vetor de cordas, para uma corda
• Aumento do tamanho do vetor
• Redimensionamento
• Inserção
• Emplace
• Retrocesso
• Conhecendo a duração de um vetor
• Capacidade de um vetor
• Reserva espaço para vetor
• Conclusão

Vetor de cordas para uma corda

Um vetor de literais de cordas pode ser substituído por uma corda dos literais. Os literais serão separados por vírgulas na única corda. O código a seguir ilustra o seguinte:

Vectorvtr = "Toyota", "Mitsubishi", "Ford", "Mercedes", "Jeep";
Char Arrchars [100];
int ctr = 0; //contador
int i = 0;
para (i = 0; iconst char* str = vtr [i];
int j = 0;
para (j = 0; str [j] != '\ 0'; j ++)
Arrchars [ctr] = str [j];
++Ctr;

Arrchars [ctr] = ','; ++ ctr; Arrchars [ctr] = ";
++Ctr;

Arrchars [ctr] = '\ 0';
cout<A saída é:

Toyota, Mitsubishi, Ford, Mercedes, Jeep,

Qual é uma corda longa. Uma sequência de matriz e uma string literal em citações duplas são fundamentalmente a mesma coisa, terminando em '\ 0'; Embora o final da sequência de citações dupla seja implícito. A string final longa tem apenas um '\ 0' no final da sequência do personagem. O código ainda pode ser modificado para remover a última vírgula e espaço.

Aumento do tamanho do vetor

Redimensionamento

A função Size () do membro pode ser usada para retornar o tamanho () de um vetor, como mostra o código a seguir:

vetorvtr 'f', 'g', 'h', 'i', 'j';
cout<A saída é 5.

Void Ressiense (size_type sz)

Para aumentar o tamanho de um vetor, o vetor deve ser redimensionado para um número maior. O código a seguir faz isso usando a função do membro, redimensione (size_type sz):

vetorvtr 'f', 'g', 'h', 'i', 'j';
vtr.redimensionar (7);
vtr [5] = 'k';
vtr [6] = 'l';
para (int i = 0; icout<
cout<A saída é:

F g h i j k l

Quando um vetor é apenas redimensionado com a função de membro redimensionada (), novos locais vazios são disponibilizados no final do vetor. Esses novos locais podem ser preenchidos.

Void Ressiense (size_type SZ, const T&C)

O mesmo valor pode ser adicionado aos novos locais no final do vetor usando este método de sobrecarga redimensionados (). Ilustração:

vetorvtr 'f', 'g', 'h', 'i', 'j';
vtr.redimensionar (8, 'z');
para (int i = 0; icout<
cout<A saída é:

F g h i j z z z

Inserção

A inserção ocorre em frente ao elemento apontado pelo iterador.

inserir (posição const_iterator, const t & x)

O código a seguir mostra como essa função é usada:

vetorvtr 'f', 'g', 'h', 'i', 'j';
vetor :: iterator p = vtr.começar();
p ++, p ++;
char id = 'z';
vtr.inserir (p, id);
para (int i = 0; icout<
cout<A saída é:

F g z H i j

'Z' foi inserido na frente de H. A função Begin () Membro retorna um iterador que aponta para o primeiro elemento do vetor. O iterador pode então ser incrementado para a posição desejada. Observe que o segundo argumento esperado para Insert () aqui é um identificador.

Iterator Insert (posição const_iterator, t && x)

O código a seguir mostra como essa função é usada:

vetorvtr 'f', 'g', 'h', 'i', 'j';
vetor :: iterator p = vtr.começar();
p ++, p ++;
vtr.inserir (p, 'z');
para (int i = 0; icout<
cout<A saída é:

F g z H i j

'Z' foi inserido na frente de H. A função Begin () Membro retorna um iterador que aponta para o primeiro elemento do vetor. Observe que o segundo argumento esperado para Insert () aqui é um literal.

Inserção de iterador (posição const_iterator, size_type n, const t & x)

O mesmo valor pode ser inserido mais de uma vez. O código a seguir ilustra o seguinte:

vetorvtr 'f', 'g', 'h', 'i', 'j';
vetor :: iterator p = vtr.começar();
p ++, p ++;
char id = 'z';
vtr.inserir (p, 3, id);
para (int i = 0; icout<
cout<A saída é:

F g z z z H i j

ITERATOR INSERT (posição const_iterator, inputIterator First, inputIterator Última)

Um intervalo de outro vetor pode ser inserido. O código a seguir ilustra o seguinte:

vetor outrovtr = 'k', 'l', 'm', 'n', 'o';
vetor :: iterator i = outrovvtr.começar();
i = i + 1;
vetor :: iterator j = outrovvtr.fim();
j = j - 2;
vetorvtr 'f', 'g', 'h', 'i', 'j';
vetor :: iterator p = vtr.começar();
p ++, p ++;
vtr.inserir (p, i, j);
para (int i = 0; icout<
cout<A saída é:

F g l m h i j

Para o outro vetor, o intervalo é obtido da seguinte. Este iterador, fui incrementado para apontar para o próximo elemento. A função final () do membro retorna um iterador que aponta logo após o último elemento. Este iterador, j foi diminuído duas vezes subtraindo 2 dele, e depois apontou para o elemento, 'n'.

Neste ponto, o intervalo imaginado é:

'L', 'm', 'n'

No entanto, com C ++, o último elemento em um intervalo não estará envolvido (inserido). Então, apenas "'l', 'm'" é inserido.

Iterator Insert (posição const_iterator, inicializer_list il)

Uma lista literal vetorial pode ser inserida. O código a seguir ilustra o seguinte:

vetorvtr 'f', 'g', 'h', 'i', 'j';
vetor :: iterator p = vtr.começar();
p ++, p ++;
vtr.inserir (p, 'k', 'l', 'm', 'n', 'o');
para (int i = 0; icout<
cout<A saída é:

F g k l m n o h i j

Emplace

O uso de emplace () é semelhante ao uso de insert (), e muitos programadores preferem inserir ().

Emplace dentro

Para o código a seguir, 'z' é colocado dentro dos valores, 'f', 'g', 'h', 'i', 'j':

vetorvtr 'f', 'g', 'h', 'i', 'j';
vetor :: iterator p = vtr.começar();
p ++, p ++;
vtr.emplace (P, 'Z');
para (int i = 0; icout<
cout<A saída é:

Emplace na frente

Para o código a seguir, 'Z' é colocado na frente dos valores, 'f', 'g', 'h', 'i', 'j':

vetorvtr 'f', 'g', 'h', 'i', 'j';
vetor :: iterator p = vtr.começar();
vtr.emplace (P, 'Z');
para (int i = 0; icout<
cout<O iterador retornado por BEGN () não foi incrementado; E assim a saída é:

Z f g h i j

Retrocesso

A função de membro push_back () pode ser usada para anexar um elemento. O código a seguir ilustra o seguinte:

vetorvtr 'f', 'g', 'h', 'i', 'j';
vtr.push_back ('z');
para (int i = 0; icout<
cout<A saída é:

F g h i j z

Um elemento também pode ser anexado usando a função do membro emplace_back (). O código a seguir ilustra o seguinte:

vetorvtr 'f', 'g', 'h', 'i', 'j';
vtr.emplace_back ('z');
para (int i = 0; icout<
cout<A saída é:

F g h i j z

Conhecendo a duração de um vetor

O tamanho de um vetor significa o número de elementos no vetor. Isso pode ser obtido usando a função de membro do tamanho (). O programa a seguir ilustra o seguinte:

#incluir
#incluir
usando namespace std;
int main ()

vetorvtr = 'f', 'g', 'h', 'i', 'j', 'k';
int sz = vtr.tamanho();
cout<retornar 0;

A saída é 6.

Capacidade de um vetor

A capacidade de um vetor não deve ser confundida com o tamanho do vetor. Quando um vetor está sendo manipulado e aumentado, os locais de seus elementos na memória do computador estão sendo alterados (realocados). A capacidade de um vetor é o número total de elementos que o vetor pode manter sem exigir realocação. Adia com o tamanho inicial do vetor. O programa a seguir ilustra isso para um vetor vazio e para um vetor de 5 elementos:

#incluir
#incluir
usando namespace std;
int main ()

vetor vtr1;
vetor vtr2 'f', 'g', 'h', 'i', 'j';
int cap1 = vtr1.capacidade();
int cap2 = vtr2.capacidade();
cout<< cap1 <cout<< cap2 <retornar 0;

A saída é:

0
5

Reserva espaço para vetor

Void Reserve (size_type n)

O espaço vetorial pode ser reservado com esta função. O programa a seguir se reserva um espaço de 5 elementos:

#incluir
#incluir
usando namespace std;
int main ()

vetorvtr = 'f', 'g', 'h';
vtr.reserva (5);
int cap = vtr.capacidade();
cout<< "New Capacity: " << cap <vtr.push_back ('i');
vtr.push_back ('j');
vtr.push_back ('k');
para (int i = 0; icout<
cout<retornar 0;

A saída é:

Nova capacidade: 5
F g h i j k

Os espaços reservados incluem aqueles para os elementos iniciais. O fato de 5 espaços serem reservados, não significa que um elemento não pode ser anexado além de 5 elementos.

Conclusão

"Expandir um vetor" não é uma frase clássica em c++. No entanto, se "expandir um vetor" significa, aumentando o comprimento de um vetor, então, sim, um vetor pode ser expandido. Em C ++, o comprimento de um vetor ou qualquer contêiner C ++ é chamado de tamanho. O vetor pode ser expandido com as seguintes funções de membro: redize (), insert (), emplace () e push_back (). Outras funções de membro relacionadas são: size (), capacidade () e reserva (). Em muitos programas de C ++, um vetor seria aumentado e diminuído várias vezes. Um vetor pode ser diminuído, usando a função de membro da apagamento - veja mais adiante. Se um vetor consiste em literais de cordas, o vetor poderá ser substituído por uma longa sequência composta por literais de cordas.