Você pode fazer um vetor de vetores em C++?
Este artigo explica como criar um vetor de vetores e como aplicar algumas funções de membros óbvias do vetor, ao vetor de vetores. Para fazer isso, o programa C ++ deve começar com:
#incluir#incluir
usando namespace std;
Observe a inclusão da biblioteca vetorial.
Conteúdo do artigo
- Construção
- Acesso com índices
- Acessando em sequência
- Inserindo uma linha
- Anexando uma linha
- Apagando linhas
- Claro
- Conclusão
Construção
A construção de um vetor normal começa com:
vetorNome é o nome do vetor. O código a seguir cria um vetor unidimensional com uma lista de inicialização apoiada de 5 caracteres:
vetorPara construir um vetor de vetores, comece com:
vetorObserve como um modelo de vetor se tornou outro argumento de modelo. Portanto, deve ser interpretado como vetor de vetores do mesmo tipo. Nome é o nome do vetor de vetores. O código a seguir cria um vetor bidimensional com 6 listas de inicialização apoiadas de 5 caracteres cada para 6 linhas.
vetor'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e';
O vetor externo literal, possui delimitadores, e. Cada vetor para uma linha possui delimitadores, e. Os literais vetoriais da linha são separados por vírgulas. O semicolon final está na extremidade inferior direita da tabela de criação. O vetor 2D também poderia ter sido criado da seguinte maneira:
vetorvetor
Ou seja, um vetor 1D é criado e seu nome de variável é usado como identificadores para as diferentes linhas.
Agora, as linhas podem realmente ter conteúdos diferentes. Nesse caso, cada linha será um vetor diferente com um nome diferente.
Acesso com índices
A sintaxe para acessar um elemento é:
2dVecTorName [i] [j]Onde eu é a variável para uma linha específica, e j é a variável para uma coluna específica. A contagem de fileiras começa com zero, e a contagem de colunas também começa com zero. O vetor bidimensional de vetores não precisa ser regular; isto é, o número de colunas para cada linha não precisa ser o mesmo. O código a seguir lê o valor da linha 2 do índice (terceira linha) e da coluna 3 do índice (quarta coluna):
vetor'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e';
char ch = vtr [2] [3];
cout << ch << endl;
A saída é, 'd'.
Isso pode ser alterado e lido novamente da mesma maneira, com o seguinte segmento de código:
vtr [2] [3] = 'z';char ch = vtr [2] [3];
cout << ch << endl;
Nesse caso, a saída é 'z'.
Acessando em sequência
A primeira linha pode ser acessada a partir do primeiro elemento, depois o segundo elemento, depois o terceiro elemento, até o último elemento da primeira linha. Em seguida, a próxima linha pode ser acessada da mesma maneira, depois a depois, e depois a seguinte, até que a última linha seja concluída. Isso precisa de dois loops como o código a seguir ilustra:
vetoronedv = 'a', 'b', 'c', 'd', 'e';vetor
para (int i = 0; i
cout<
cout<
A B C D E
A B C D E
A B C D E
A B C D E
A B C D E
Observe que Twodv.size () fornece o número de linhas para toda a tabela, enquanto TWODV [i].tamanho () fornece o número de células (colunas) para uma linha específica.
Inserindo uma linha
Inserindo na frente
Uma linha é para um vetor 2D, pois uma célula é para um vetor 1D. A mesma abordagem de inserção é usada, mas, em vez de uma célula literal, é usada uma literal em linha; Em vez de um identificador de valor, um identificador de linha (e.g., twodv [i]) é usado. O código a seguir mostra como uma linha é inserida em frente ao vetor 2D:
vetor'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e';
vetor
vetoronedv = '*', '$', '%', '$', '&';
twodv.inserir (p, onedv);
para (int i = 0; i
cout<
cout<
A B C D E
A B C D E
A B C D E
A B C D E
A função Begin () Membro retorna um iterador que aponta para a primeira linha do vetor 2D. Observe que o iterador retornou deve ser do tipo vetor de vetores (e.g. vetor
Inserindo dentro
O código a seguir insere uma linha dentro da tabela, em frente à terceira linha pontiaguda:
vetor'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e';
vetor
p ++; p ++;
vetoronedv = '*', '$', '%', '$', '&';
twodv.inserir (p, onedv);
para (int i = 0; i
cout<
cout<
A B C D E
* $ % $ &
A B C D E
A B C D E
O iterador foi incrementado duas vezes para apontar para a terceira linha antes da inserção. A declaração de inserção poderia ter sido igualmente escrita como,
twodv.inserir (p, '*', '$', '%', '$', '&');O resultado teria sido o mesmo.
Anexando uma linha
Uma linha pode ser anexada usando a função unidimensional push_back (). O código a seguir ilustra o seguinte:
vetor'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e';
vetoronedv = '*', '$', '%', '$', '&';
twodv.push_back (onedv);
para (int i = 0; i
cout<
cout<
A B C D E
A B C D E
A B C D E
* $ % $ &
A declaração push_back () poderia ter sido igualmente escrita como,
twodv.push_back ('*', '$', '%', '$', '&');O resultado teria sido o mesmo.
Apagando linhas
O código a seguir usa a função unidimensional do membro do vetor () para apagar a segunda e a terceira linhas, embora o segundo iterador esteja apontando para a quarta fila, do vetor de 5 fileiras de vetores:
vetor'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e';
vetor
p ++;
vetor
Q--; Q--;
twodv.apagar (p, q);
para (int i = 0; i
cout<
cout<
A B C D E
A B C D E
A função unidimensional do membro vetorial retorna um iterador, que está apontando logo após o final do vetor unidimensional (que agora é um vetor de vetores). É diminuído duas vezes no código acima, para apontar para a última, mas uma linha. Sempre que uma variedade de elementos ou linhas deve ser apagada, o elemento ou a linha apontada pelo segundo iterador não é apagada.
Claro
Um elemento é para um vetor unidimensional, pois uma linha é para um vetor bidimensional (vetor de vetores). Todas as linhas de um vetor podem ser apagadas com a função unidimensional clear (). O código a seguir ilustra o seguinte:
vetor'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e',
'A', 'b', 'c', 'd', 'e';
twodv.claro();
para (int i = 0; i
cout<
cout<
Conclusão
Um elemento é para um vetor unidimensional, pois uma linha é para um vetor bidimensional (vetor ou vetores). Todas as funções de membro unidimensional para o vetor unidimensional podem ser usadas para o vetor bidimensional, abordando as linhas em vez dos elementos. As células individuais da tabela podem ser acessadas com TWODV [i] [J], onde TWODV, eu e J tenho seus significados comuns. O vetor de linhas pode ser abordado com TWODV, e cada linha pode ser abordada com TWODV [i].