String c ++ remova o último caractere

A classe C ++ String tem muitas funções de membro. Dois deles são as funções Pop_back () e EASE (). A função pop_back () remove o último elemento da string. A função EASE () pode apagar um elemento em qualquer lugar da string. Existem três variantes da função de apagar. Eles diferem no tipo de argumentos que eles tomam. Tais funções com o mesmo nome são chamadas de funções sobrecarregadas.

As cadeias de C ++ podem ser declaradas de duas maneiras principais: como um ponteiro constante para os chars (matriz de chars) ou instanciados da classe String da biblioteca de cordas. Aqui, as funções Pop_back () e EASE () são do objeto String, instanciadas da classe String. O último elemento de uma matriz de chars não pode ser removido porque uma variedade de cargas não é um objeto instanciado.

É verdade que uma string literal consiste em valores que são caracteres. Cada personagem está dentro de um elemento. Então a string literal realmente consiste em elementos. O último personagem é removido com seu último elemento.

Este artigo explica como remover o último elemento de uma string, junto com seu personagem.

Conteúdo do artigo

• void pop_back ()
• Erase do iterador (const_iterator p)
• Erase do iterador (const_iterator primeiro, const_iterator Último)
• Basic_string & Erase (size_type pos = 0, size_type n = npos)
• Conclusão

void pop_back ()

Esta função de membro da classe String remove o último elemento da string. A função retorna vazios. Isso significa que nada é devolvido e nenhuma variável pode receber qualquer coisa devolvida dele. O uso desta função é ilustrado no seguinte programa:

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

string str = "lmnopqr";
cout <str.pop_back ();
para (int i = 0; icout <cout <retornar 0;

A saída é:

Lmnopqr
LMNOPQ

O último personagem foi removido. As duas primeiras linhas do programa incluem as bibliotecas necessárias. Um deles, é claro, é a biblioteca de cordas. A biblioteca de string deve ser incluída, pois todas as strings envolvidas são instanciadas da classe String. A próxima linha é uma declaração. Ele declara que todos os nomes abaixo são do espaço de nome padrão, a menos que indicado de outra forma.

O corpo principal () da função começa com a declaração (instanciação) do objeto String. A próxima declaração exibe o literal desta string recém -declarada na saída. A declaração após remove o último caractere, usando a função Pop_back (). O próximo segmento de código usa um loop for com índices para exibir todos os caracteres, que não têm mais o último, em uma sequência contínua.

Erase do iterador (const_iterator p)

Se o iterador apontar para o último elemento (caractere), a função de membro da apagar poderá remover o último elemento. Esta função retorna um iterador que aponta para o elemento logo após o removido (ou logo após o último elemento, se o removido foi o último elemento). O programa a seguir ilustra o seguinte:

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

string str = "lmnopqr";
cout <string :: iterator p = str.fim();
P--;
string :: iterator it = str.apagar (P);
para (int i = 0; icout <cout <retornar 0;

A saída é:

Lmnopqr
LMNOPQ

As três primeiras linhas do programa são explicadas da mesma maneira que o programa anterior. No corpo da função main (), a primeira declaração declara o objeto String. A próxima declaração exibe o literal desta string recém -declarada na saída. Esta impressão ainda poderia ter sido feita com um loop para. A declaração após obtém um iterador que aponta logo após o último elemento do personagem. Isso é feito com a função de membro, end (). Observe a maneira como o iterador foi declarado (lado esquerdo de, =). Então o iterador está diminuído para apontar para o último elemento.

Em seguida, o último elemento é removido com a função de membro EASE (). O próximo segmento de código usa um loop for com índices para exibir todos os caracteres, que não têm mais o último no terminal em uma sequência contínua.

Erase do iterador (const_iterator primeiro, const_iterator Último)

Esta função de membro apagaria uma variedade de elementos de caracteres da string. Aqui, primeiro é um iterador que aponta para o primeiro elemento do intervalo. O iterador retornou pontos para o elemento que estava lá, logo após o intervalo. Se não houvesse elementos lá, apontaria para o final da string. O último é um iterador que aponta para o último elemento do intervalo. Este último elemento não está envolvido na apagamento.

Para remover o último elemento, o truque é fazer “último”, apontar logo além do último elemento da string; e fazer o "primeiro" ponto no último elemento da string. Com tudo isso, a função apaga retirará o último elemento. O programa a seguir mostra como é feito:

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

string str = "lmnopqr";
cout <string :: iterator p = str.começar();
p = p + 6;
string :: iterator q = str.fim();
string :: iterator it = str.apagar (p, q);
para (it = --it; it> = str.começar(); isto--)
cout << *it;
cout <retornar 0;

A saída é:

Lmnopqr
QPONML

Depois de remover o personagem, R (juntamente com seu elemento), a string restante foi impressa de caractere por caracteres, mas na ordem inversa.

As três primeiras linhas do programa são explicadas da mesma maneira que o programa anterior. No corpo da função main (), a primeira declaração declara o objeto String. A próxima declaração imprime a string recém -declarada.

O segmento de código a seguir tem três declarações. O primeiro declara um iterador que aponta para o primeiro personagem da string. Mais seis caracteres da corda devem ser contados antes do último personagem, 'r' é alcançado. Então, a segunda declaração deste segmento adiciona 6 ao iterador. A próxima declaração neste segmento declara um iterador, q, que aponta logo após o final da string. A situação está agora definida para apagar o último elemento: q pontos logo após 'r' e P aponta para 'r'.

A declaração que apaga 'r' é:

string :: iterator it = str.apagar (p, q);

Depois que 'r' é apagado, o último personagem se torna 'q'. O iterador devolvido, 'It' aqui, aponta logo após 'q'.

O próximo segmento de código é um loop para. A declaração de inicialização deste loop para simplesmente diminui "ele" para apontar para o novo último personagem, 'q'. 'Q' é impresso no terminal. O loop for continua a diminuir "it", imprimindo o personagem correspondente, enquanto 'it' é maior que o STR.começar(). Quando "It" é igual a STR.BEGIN (), isto é, "It" está apontando para 'L', as impressões de loop para 'l' e para. Dessa forma, a string sem 'r' é impressa em ordem inversa.

Para obter o valor apontado para um iterador, precede o iterador com o operador indiretivo, * .

Basic_string & Erase (size_type pos = 0, size_type n = npos)

Esta função de membro apaga um intervalo, assim como a função acima. No entanto, ele usa índices e não iteradores. Se o argumento POS for 0, o intervalo começará a partir do primeiro elemento. Se o argumento n é o comprimento da string (número de caracteres), o intervalo termina no último caractere. Ambos os argumentos têm seus valores padrão. Esta função retorna o objeto da classe String, com os caracteres do intervalo removidos.

O truque para jogar aqui é tornar o valor do POS o índice do último personagem. O índice do último caractere (elemento) é o tamanho (comprimento) da lista menos 1. O segundo argumento aqui deve ser omitido para este problema. O último índice é dado por,

str.tamanho () - 1

O programa a seguir, usa essa função de membro, para tirar o último personagem, 'r' da string:

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

string str = "lmnopqr";
cout <int l = str.tamanho () - 1;
string ret = str.apagar (l);
para (int i = 0; i cout <cout <para (int i = 0; i cout <cout <retornar 0;

A saída é:

Lmnopqr
LMNOPQ
LMNOPQ

A corda original e de retorno perdida 'r'. As três primeiras linhas do programa são explicadas da mesma maneira que o programa anterior. No corpo da função main (), a primeira declaração declara o objeto String. A próxima declaração imprime a string recém -declarada.

A próxima declaração determina o índice do último elemento da string original. A declaração após apagar o último caractere usando este índice. O próximo segmento de código imprime os caracteres da string de retorno, um por um, usando índices. O último segmento de código imprime os caracteres da string original, um por um, usando índices.

Conclusão

A função normal da classe String Class, para remover o último caractere de uma string, com seu elemento que a segura, é a função pop_back (). Existem três funções de membro sobrecarregadas () que também podem ser usadas para isso. Um deles leva um iterador que aponta para o último personagem e remove o último personagem. Outro leva um intervalo, indicado por dois iteradores: um iterador aponta para o último personagem e os outros pontos logo após o último personagem. Com isso, o último personagem é retirado. A terceira função sobrecarregada usa o índice do último caractere para removê -lo. Toda a discussão neste artigo foi compatível com C ++ 20.