Como reverter um vetor em C ++

Se um vetor tem elementos na sequência, 'a', 'b', 'c', 'd', 'e' e é reconfigurado de modo que sua sequência se torne, 'e', 'd', ' C ',' b ',' a ' Então o vetor foi revertido. Infelizmente, essa reversibilidade direta não é possível em C++. No entanto, um vetor em C ++ pode ser iterado pelas costas, e isso é reversibilidade indireta. Com isso, não há necessidade de reverter o vetor literalmente. Este artigo explica como iterar um vetor em C ++ da parte traseira e modificar seus elementos.

Antes de usar um vetor em C ++, o programa deve começar com,

#incluir
#incluir
usando namespace std;

com a biblioteca vetorial incluída. É mais fácil entender a iteração reversa depois de ter um resumo da iteração de encaminhamento. Portanto, a iteração avançada é resumida primeiro antes que a iteração reversa seja explicada.

Conteúdo do artigo

• Iteração avançada
• Iteração reversa
• Iterador reverso constante
• Conclusão

Iteração avançada

A iteração avançada lida com dois iteradores. Um iterador é um objeto de ponteiro elaborado com características especiais. Aqui, os dois iteradores de interesse são devolvidos pela função Begin () Membro e pela função final () do membro. A função Begin () Membro retorna um iterador que aponta para o primeiro elemento do vetor. A função final () do membro retorna um iterador que aponta logo além do último elemento do vetor.

Suponha que o nome do vetor seja VTR, a seguinte declaração retornará um iterador de início:

vetor:: iterador p = vtr.começar();

onde p é o nome dado ao iterador de início. A declaração a seguir retornará um iterador final:

vetor:: iterator q = vtr.fim();

Onde q é o nome dado ao final do iterador, ele pode ser visto das duas declarações acima de que P e Q são do mesmo tipo e podem até ser trocadas.

Todos os segmentos de código deste artigo são escritos na função principal (). O código a seguir lê todos os elementos do vetor, do início ao último elemento:

vetor vtr = 'a', 'b', 'c', 'd', 'e';
para (vetor:: iterador p = vtr.começar(); p != vtr.fim(); p ++)
cout << *p << ";

cout < vtr = 'A', 'B', 'C', 'D', 'E';
vetor:: iterator q = vtr.fim();
para (q = --q; q> = vtr.começar(); Q--)
cout << *q << ";

cout << endl;

A saída é:

A B C D E

O código nos parênteses do loop for a explicação. P é um iterador que primeiro aponta para o primeiro elemento do vetor. Embora ainda não esteja apontando logo além do vetor, é incrementado por p ++ para apontar para cada elemento no vetor. Quando aponta para um elemento no vetor, o valor (caractere) do elemento é obtido com *p no corpo do loop for. * é o operador indiretivo.

O código a seguir lê e exibe os valores no vetor do último elemento para o primeiro elemento, usando o iterador final:

vetorvtr = 'a', 'b', 'c', 'd', 'e';
vetor:: iterator q = vtr.fim();
para (q = --q; q> = vtr.começar(); Q--)
cout << *q << ";

cout << endl;

A saída é:

E D C B A

O final do iterador aponta logo além do final do vetor, e isso não é um elemento. Então, ele deve ser diminuído primeiro antes de apontar para o último elemento. A partir daí, a iteração pode voltar para trás.

A condição do tempo para o loop for aqui é: “Se q é maior ou igual ao iterador de início”. Não pode ser "se q não for igual ao iterador de início", pois isso excluiria o primeiro elemento.

Esta é uma maneira informal de iterar para trás. Isto é, esta é uma maneira informal de reverter um vetor indiretamente.

Alterando o valor de um elemento

Quando a instanciação do vetor não é precedida por const (para constante), o valor de qualquer elemento no vetor pode ser alterado. O código a seguir ilustra o seguinte:

vetor vtr = 'a', 'b', 'c', 'd', 'e';
vetor:: iterator q = vtr.fim();
Q--; Q--; Q--;
*q = 'z';
vetor:: iterator r = vtr.fim();
para (r = - -r; r> = vtr.começar(); r--)
cout << *r << ";

cout << endl;

A saída é:

E d z b a

O iterador final, Q é diminuído três vezes com “Q-; Q-; Q-; ” para apontar para 'C'.

Se a instanciação do vetor for precedida com const, nenhum valor do elemento poderá ser alterado. Nesse caso, o constante para a frente iterador deve ser devolvido para o final ou iniciar o iterador. O código a seguir não será compilado porque é feita uma tentativa de alterar o valor de 'C':

const vetor vtr = 'a', 'b', 'c', 'd', 'e';
vetor:: const_iterator q = vtr.fim();
Q--; Q--; Q--;
*q = 'z';

Iteração reversa

A iteração reversa tem dois principais iteradores. Esses iteradores são devolvidos pelas funções de membro, RBegin () e rend (). rend () retorna um iterador que aponta logo na frente do primeiro elemento do vetor. rBegin () retorna um iterador que aponta para o último elemento do vetor. O código a seguir lê e exibe os elementos do vetor, do primeiro ao último, na direção direta:

vetor vtr = 'a', 'b', 'c', 'd', 'e';
vetor>: reverse_iterator p = vtr.rend ();
para (p = - -p; p> = vtr.rBegin (); P--)
cout << *p << ";

cout << endl;

A saída é:

A B C D E

O iterador reverso é usado. Como o rend () retorna um iterador que aponta logo na frente do primeiro elemento, o que não é um elemento, ele deve ser incrementado para apontar para o primeiro elemento. Como estamos lidando com o iterador reverso, o operador de incremento aqui é - e não ++. Além disso, na condição de tempo,> = é usado em vez de <= .

O código a seguir lê e exibe os valores no vetor, desde o último elemento até o primeiro elemento, usando o iterador de rbegin ():

vetor vtr = 'a', 'b', 'c', 'd', 'e';
para (vetor:: reverse_iterator q = vtr.rBegin (); q <= vtr.rend(); q++)
cout << *q << ";

cout << endl;

A saída é:

E D C B A

A função de membro rBegin () retorna um iterador que aponta para o último elemento do vetor. O iterador retornado é um reverse_iterator. rend () retorna um iterador que aponta pouco antes do primeiro elemento. Observe que a condição de tempo para o loop for tem apenas =, já que estamos lidando com um iterador reverso. Decremento com este iterador é ++ e não -.

Alterando o valor de um elemento

Quando a instanciação do vetor não é precedida por const (para constante), o valor de qualquer elemento no vetor pode ser alterado com o reverse_iterator. O código a seguir ilustra isso, com o reverse_iterator:

vetor vtr = 'a', 'b', 'c', 'd', 'e';
vetor:: reverse_iterator q = vtr.rBegin ();
q ++; q ++;
*q = 'x';
para (vetor:: reverse_iterator r = vtr.rBegin (); r <= vtr.rend(); r++)
cout << *r << ";

cout << endl;

A saída é:

E d x b a

O iterador rBegin (), q é diminuído duas vezes com “q ++; q ++; ” para apontar para 'C', já que ele inicialmente aponta para o último elemento.

Se a instanciação do vetor for precedida com const, nenhum valor do elemento poderá ser alterado, com um iterador, seja reverse_iterator iterator (ou para a frente). Nesse caso, o constante iterador reverso deve ser devolvido para a função rBegin () ou rend (). O código a seguir não será compilado porque é feita uma tentativa de alterar o valor de 'C':

const vetor vtr = 'a', 'b', 'c', 'd', 'e';
vetor:: const_reverse_iterator q = vtr.rBegin ();
q ++; q ++;
*q = 'x';

Iterador reverso constante

CRBEGIN () se comporta como RBegin (), mas retorna um const_reverse_iterator, independentemente de a instanciação do vetor ter sido iniciada com const ou não. Isso significa que o valor do iterador retornado não pode ser alterado. Crend () se comporta como rend (), mas retorna um const_reverse_iterator, se a instanciação do vetor foi ou não iniciada com const. Isso significa que o valor do iterador retornado não pode ser alterado.

O código a seguir exibe todos os valores do vetor, usando const_reverse_iterator, começando do último elemento:

vetor vtr = 'a', 'b', 'c', 'd', 'e';
para (vetor:: const_reverse_iterator q = vtr.crBegin (); q <= vtr.crend(); q++)
cout << *q << ";

cout << endl;

A saída é:

E D C B A

O código a seguir não será compilado porque estamos lidando aqui com um constante iterador reverso. A instanciação do vetor não é precedida por const.

vetor vtr = 'a', 'b', 'c', 'd', 'e';
para (vetor:: reverse_iterator q = vtr.rBegin (); q <= vtr.rend(); q++)
cout << *q << ";

cout << endl;

Conclusão

Um vetor não pode ser revertido literalmente. No entanto, pode ser iterado de volta à frente para ter um resultado semelhante. Com a iteração avançada, as funções de membro, BEGIN () e END () estão envolvidas. No caso de iteração reversa, funções de membro, rBegin () e rend () estão envolvidas. Nesse caso, o iterador envolvido é reverse_iterator e não um iterador. Ainda neste caso, ++ é - e> = é <= . There is also const_reverse_iterator, for crbegin() and crend() member functions.