Funções mais úteis de membro do vetor C ++

As funções de membro do vetor C ++ podem ser colocadas nas seguintes categorias: construção, capacidade, iteradores, acesso a elementos e modificadores. Cada uma dessas categorias tem muitas funções. Todas essas funções não são usadas em muitas aplicações. Este artigo explica o mais útil dessas funções. Com exceção da categoria Modificadores, não mais de três funções para cada categoria são explicadas neste artigo. A categoria Modificadores pode ser dividida em mais sub -categorias. Em cada uma dessas sub -categorias, não mais que três funções serão explicadas. Se mais de três funções forem explicadas para uma determinada categoria, elas serão ensinadas por meio de ilustração.

Um programa para usar o vetor C ++ deve começar com,

#incluir
#incluir

Conteúdo do artigo

• Construção/destruição
• Capacidade
• Acesso ao iterador e vetorial
• Acesso ao elemento
• Empurre e volte para trás
• Inserção
• Atribuindo elementos (substituições)
• Apagar
• Claro
• Trocando
• Conclusão

Construção/destruição

Os seguintes segmentos de código mostram maneiras diferentes de criar o mesmo vetor:

vetor vtr;
vtr.push_back (5.5);
vtr.push_back (6.6);
vtr.push_back (7.7);
vtr.push_back (8.8);
vtr.push_back (9.9);
vetor vtr (3); // com número inicial de elementos
vtr [0] = 5.5;
VTR [1] = 6.6;
VTR [2] = 7.7;
vetor Vtr (5, 0.0); //Não. Elementos: 5; cada valor: 0.0
vetor vtr 5.5, 6.6, 7.7, 8.8, 9.9; // inicializando
vetor vtr = 5.5, 6.6, 7.7, 8.8, 9.9; // Construindo e copiando
vetor vtr;
vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vetor Vtr1 5.5, 6.6, 7.7, 8.8, 9.9;
vetor vtr2 (vtr1);
const vetor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;

A const vetor é um vetor cujos elementos não podem ser alterados. Os valores são somente leitura.

Destruição

Para destruir um vetor, deixe -o sair do escopo.

Capacidade

tamanho () const noexcept

O número de elementos em um vetor é devolvido por esta função de membro. Com o seguinte segmento de código, a saída é 5:

vetor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
flutuar sz = vtr.tamanho();
cout << sz << '\n';
vazio () const Noexcept

Este método retorna true (1) se o vetor não tiver elemento e falso (0) se o vetor tiver pelo menos um elemento. Com o código a seguir, a saída é 1 (para verdadeiro):

vetor vtr = ;
bool bl = vtr.vazio();
cout << bl << '\n';

Acesso ao iterador e vetorial

Um iterador é um ponteiro elaborado. Quando o vetor, vtr foi criado, vtr.começar() retornaria um iterador, apontando para o primeiro elemento da lista. Pode então ser incrementado para acessar os elementos após o primeiro, de acordo.

Quando o vetor, vtr foi criado, vtr.fim() retornaria um iterador, apontando logo após o último elemento da lista. Então pode ser diminuído para acessar o último elemento e elementos antes do último, de acordo. O programa a seguir ilustra o seguinte:

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

vetor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vetor:: iterator iterb = vtr.começar();
iterb ++;
vetor:: iterator itere = vtr.fim();
ITERE--;
cout << *iterB << ", " << *iterE << " << endl;
*iterb = 66.66; *ITERE = 99.99;
cout << *iterB << ", " << *iterE << " << endl;
retornar 0;

A saída é:

6.6, 9.9
66.66, 99.99

Os valores de dois elementos foram acessados, lidos e alterados por dois iteradores.

Acesso ao elemento

em (i)

Isso é semelhante ao VTR [i], e é melhor. Pode ser usado para ler ou alterar o valor de um elemento. A contagem de índice começa de zero. O leitor pode testar o seguinte programa:

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

vetor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
cout << vtr[1] << ", " << vtr[4] << " << endl;
VTR [1] = 66.66; VTR [4] = 99.99;
cout << vtr[1] << ", " << vtr[4] << " << endl;
retornar 0;

A saída é:

6.6, 9.9
66.66, 99.99

Os valores de dois elementos foram acessados, lidos e alterados através da referência.

Retornando o primeiro valor

O código a seguir retorna (copia) o primeiro elemento:

vetor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
flutuar val = vtr.frente();
cout << val << endl;

A saída é, 5.5. A função de membro usada aqui é: Front ().

Retornando o último valor

O código a seguir retorna (copia) o último elemento:

vetor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
flutuar val = vtr.voltar();
cout << val << endl;

A saída é, 9.9. A função de membro usada aqui é: back ().

Empurre e volte para trás

retrocesso()

Um elemento pode ser anexado na parte de trás do vetor. O valor pode ser literal ou ser representado pelo identificador. O código a seguir ilustra o seguinte:

flutuar FLT = 10.10;
vetor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vtr.push_back (FLT);
para (int i = 0; icout << vtr[i] << ", ";
cout << endl;

A lista original é:

5.5, 6.6, 7.7, 8.8, 9.9

A nova lista é:

5.5, 6.6, 7.7, 8.8, 9.9, 10.1

pop_back ()

O último elemento pode ser removido do vetor. O código a seguir ilustra o seguinte:

vetor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vtr.pop_back ();
para (int i = 0; icout << vtr[i] << ", ";
cout << endl;

A lista original é:

5.5, 6.6, 7.7, 8.8, 9.9

A nova lista é:

5.5, 6.6, 7.7, 8.8

Observação: O vetor não possui as funções de membro push_front () e pop_front ().

Inserção

Inserções em frente ao elemento apontado para, pelo iterador.

inserir (p, e)

Isso insere um elemento antes do elemento apontado pelo iterador, p. e pode ser um literal ou identificador. Ilustração:

flutuar FLT = 7.0;
vetor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vetor:: iterator iterb = vtr.começar();
iterb ++; iterb ++;
vtr.inserir (iterb, FLT);
para (int i = 0; icout << vtr[i] << ", ";
cout << endl;

A lista original é:

5.5, 6.6, 7.7, 8.8, 9.9

A nova lista é:

5.5, 6.6, 7, 7.7, 8.8, 9.9

Esta função de inserção retorna um iterador (não codificado) que aponta para o elemento inserido.

inserir (p, il)

Uma lista pode ser inserida na frente do elemento apontado pelo iterador. Ilustração:

vetor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vetor:: iterator iterb = vtr.começar();
iterb = iterb + 2;
vtr.inserir (iterb, 7.1, 7.2, 7.3);
para (int i = 0; icout << vtr[i] << ", ";
cout << endl;

A lista original é:

5.5, 6.6, 7.7, 8.8, 9.9

A nova lista é:

5.5, 6.6, 7.1, 7.2, 7.3, 7.7, 8.8, 9.9

Esta função de inserção retorna um iterador (não codificado) que aponta para o primeiro elemento inserido.

inserir (p, n, t)

Insere o mesmo valor t, n vezes, em frente ao elemento apontado por p. Ilustração:

vetor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vetor:: iterator iterb = vtr.começar();
iterb = iterb + 2;
vtr.inserir (iterb, 3, 7.1);
para (int i = 0; icout << vtr[i] << ", ";
cout << endl;

A lista original é:

5.5, 6.6, 7.7, 8.8, 9.9

A nova lista é:

5.5, 6.6, 7.1, 7.1, 7.1, 7.7, 8.8, 9.9

Esta função de inserção retorna um iterador (não codificado) que aponta para o primeiro elemento inserido.

inserir (p, i, j)

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

vetor vtr1 = 7.1, 7.2, 7.3, 7.4, 7.5;
vetor:: iterator iterb1 = vtr1.começar();
iterb1 = iterb1 + 1;
vetor:: iterator itEre1 = vtr1.fim();
Irete1 = itEre1 - 2;
vetor vtr2 = 5.5, 6.6, 7.7, 8.8, 9.9;
vetor:: iterator iterb2 = vtr2.começar();
iterb2 = iterb2 + 2;
Vtr2.inserir (iterb2, iterb1, itre1);
para (int i = 0; icout << vtr2[i] << ", ";
cout << endl;

A lista original para o VTR2 é:

5.5, 6.6, 7.7, 8.8, 9.9

A nova lista para VTR2 é:

5.5, 6.6, 7.2, 7.3, 7.7, 8.8, 9.9

O intervalo identificado a ser copiado é [7.2, 7.3, 7.4), indicado como [i, j), significando o último valor, 7.4 não está incluído.

Esta função de inserção retorna um iterador (não codificado) que aponta para o primeiro elemento inserido.

Atribuindo elementos (substituições)

Atribuir a elementos significa substituir os elementos por cópias. Todas as funções de membro da tarefa, retorno vazio.

Atribuir (IL)

Uma lista pode substituir todos os elementos do vetor em questão. A lista pode ser mais longa ou mais curta. Ilustração para lista curta:

vetor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vetor:: iterator iterb = vtr.começar();
iterb = iterb + 2;
vtr.Atribuir (55.55, 66.66, 77.77);
para (int i = 0; icout << vtr[i] << ", ";
cout << endl;

A lista original é:

5.5, 6.6, 7.7, 8.8, 9.9

A nova lista é:

55.55, 66.66, 77.77

Ilustração para uma lista mais longa:

vetor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vetor:: iterator iterb = vtr.começar();
iterb = iterb + 2;
vtr.Atribuir (55.55, 66.66, 77.77, 88.88, 99.99, 1010.1111);
para (int i = 0; icout << vtr[i] << ", ";
cout << endl;

A lista original é:

5.5, 6.6, 7.7, 8.8, 9.9

A nova lista é:

55.55, 66.66, 77.77, 88.88, 99.99, 1010.11

atribuir (n, t)

O mesmo valor, repetido várias vezes, pode substituir todos os elementos do vetor em questão. A nova lista pode ser mais longa ou mais curta. Ilustração para lista curta:

vetor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vetor:: iterator iterb = vtr.começar();
iterb = iterb + 2;
vtr.Atribuir (2, 77.77);
para (int i = 0; icout << vtr[i] << ", ";
cout << endl;

A lista original é:

5.5, 6.6, 7.7, 8.8, 9.9

A nova lista é:

77.77, 77.77

atribuir (i, j)

Um intervalo pode ser copiado de outro vetor e usado para substituir todo o conteúdo do vetor de interesse. O código a seguir ilustra o seguinte:

vetor vtr1 = 7.1, 7.2, 7.3, 7.4, 7.5;
vetor:: iterator iterb1 = vtr1.começar();
iterb1 = iterb1 + 1;
vetor:: iterator itEre1 = vtr1.fim();
Irete1 = itEre1 - 2;
vetor vtr2 = 5.5, 6.6, 7.7, 8.8, 9.9;
vetor:: iterator iterb2 = vtr2.começar();
iterb2 = iterb2 + 2;
Vtr2.atribuir (iterb1, itre1);
para (int i = 0; icout << vtr2[i] << ", ";
cout << endl;

A lista original para o VTR2 é:

5.5, 6.6, 7.7, 8.8, 9.9

A nova lista para VTR2 é:

7.2, 7.3

O intervalo identificado a ser copiado é [7.2, 7.3, 7.4), indicado como [i, j), significando o último valor, 7.4 não está incluído.

Apagar

Usa o iterador.

Apagar (Q)

Remove o elemento apontado por q, reduzindo o comprimento do vetor. Retorna o iterador apontando para o próximo elemento, após a remoção. Exemplo:

vetor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vetor:: iterator iterb = vtr.começar();
iterb = iterb + 2;
vetor:: iterator itr = vtr.apagar (iterb);
para (int i = 0; icout << vtr[i] << ", ";
cout << endl;
cout << *itR << endl;

A lista original é:

5.5, 6.6, 7.7, 8.8, 9.9

A saída é:

5.5, 6.6, 8.8, 9.9,
8.8

Apagar (Q1, Q2)

Remove uma variedade de elementos que começam a partir disso apontados para o iterador Q1, para o apontado pelo Q2, mas excluindo o de Q2 - ou seja, ele remove [Q1, Q2). Retorna o iterador apontando para o próximo elemento, após a remoção do alcance. Ilustração:

vetor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vetor:: iterator iterb = vtr.começar();
iterb = iterb + 2;
vetor:: iterator itere = vtr.fim();
itre = itere - 1;
vetor:: iterator itr = vtr.apagar (iterb, itre);
para (int i = 0; icout << vtr[i] << ", ";
cout << endl;
cout << *itR << endl;

A lista original é:

5.5, 6.6, 7.7, 8.8, 9.9

A saída é:

5.5, 6.6, 9.9,
9.9

Claro

claro()

Retorna vazio. Todos os elementos em um vetor podem ser removidos, reduzindo o comprimento do vetor a zero. É assim:

vetor vtr = 5.5, 6.6, 7.7, 8.8, 9.9;
vtr.claro();
cout << vtr.size() << endl;

A lista original é:

5.5, 6.6, 7.7, 8.8, 9.9

A saída é:

0

Trocando

x.troca (y)

Os elementos de dois vetores diferentes podem ser trocados, independentemente de seus diferentes comprimentos. Ilustração:

vetor vtr1 = 1.1, 2.2, 3.3, 4.4;
vetor vtr2 = 5.5, 6.6, 7.7, 8.8, 9.9;
Vtr2.troca (vtr1);
cout << "New vtr1: ";
para (int i = 0; icout << vtr1[i] << ", ";
cout << endl;
cout << "New vtr2: ";
para (int i = 0; icout << vtr2[i] << ", ";
cout << endl;

A saída é:

Novo Vtr1: 5.5, 6.6, 7.7, 8.8, 9.9,
Novo Vtr2: 1.1, 2.2, 3.3, 4.4,

Conclusão

O vetor C ++ tem muitas funções de membro. Essas funções podem ser categorizadas nas seguintes subcategorias: construção/destruição, capacidade, acesso de iterador e vetorial, acesso a elementos, empurrar e recuar, inserir, atribuir elementos (substituições), apagar, limpar e trocar. As funções mais úteis em cada uma dessas subcategorias foram explicadas acima.