Gerenciando o console com as classes iostream em C ++

Na computação, o console é o teclado do computador e o monitor de computador. No passado, a saída era enviada diretamente para a tela do monitor e não para uma janela exibida no monitor. Para o usuário comum de computador, os aplicativos hoje não usam o monitor explicitamente. Esses aplicativos usam o Windows exibido no monitor. No entanto, o programador de computador ainda precisa usar a tela do monitor. Embora o programador ainda precise usar a tela do monitor, o sistema operacional não permite que ele faça isso. O sistema operacional fornece uma janela que simula a tela do monitor. No sistema operacional do Windows, esta janela é chamada de prompt de comando. No sistema operacional Linux e suas variantes, esta janela é chamada de terminal.

Espera -se que o leitor já saiba como usar o prompt de comando ou o terminal. Este artigo explica como ler personagens e strings do teclado e enviar caracteres e strings para o terminal (ou prompt de comando). Todo programador C ++ precisa saber neste artigo.

Para ter a entrada do teclado e saída para o terminal, o programa deve começar com:

#incluir
usando namespace std;

Conteúdo do artigo

• Objetos de fluxo estreito do Iostream padrão
• Obtendo caracteres e cordas do teclado
• Exibindo e excluindo caracteres antes de pressionar Enter
• Enviando caracteres e strings para o monitor
• Argumentos para um programa C ++
• Conclusão

Objetos de fluxo estreito do Iostream padrão

A classe iostream, os objetos padrão, Cout, CIN, Cerr e Toplog, foram instanciados e já na biblioteca padrão. O programador apenas os usa sem instantá -los novamente.

cout

A declaração a seguir na função Main () envia o texto: “Isso é saída.”Para o terminal:

cout << "This is output.";

Cout é um objeto iostream de saída na biblioteca padrão, já instanciada. << is the insertion operator, which sent the bytes, “This is output.” to the output stream object, cout. When the statement is executed, the text appears on the screen.

Com a declaração acima, o prompt de comando re-exibido aparece à direita da frase de saída. Não vai para a próxima linha. "ENDL" no final da declaração a seguir forçará o que for impresso pela tela para a próxima linha:

cout << "This is output." << endl;

"ENDL" é uma variável predefinida. O conteúdo da tela também pode ser forçado para a próxima linha com:

cout << "This is output." << '\n';

Com o uso de '\ n', todas as linhas de texto ainda podem não aparecer na tela imediatamente. "Endl" libera a linha completa de texto na tela.

Nota: Uma string enviada para cout está em citações duplas, enquanto um personagem enviado está em citações únicas. Uma série de cordas e chars pode ser enviada em uma declaração, cada uma precedida por << . All that will appear in one line at the output if '\n' is not in the series.

CIN

CIN é o objeto de entrada Iostream padrão, já instanciado e disponível na biblioteca padrão. Considere o seguinte segmento de código na função Main ():

char txt [50];
cout << "Enter a word and press Enter:" txt;
cout << txt << endl;

A primeira declaração declara uma matriz vazia de 50 caracteres. A segunda declaração instrui o usuário a digitar uma palavra na próxima linha de tela e pressionar a tecla Enter. Observe o uso de "endl" que força o usuário a inserir texto na próxima linha da tela. À medida que o usuário digita o texto, o texto inserido é ecoado na tela enquanto entra no objeto CIN. Depois de pressionar Enter, a terceira declaração no segmento de código é executada. Esta terceira declaração envia o texto inserido para a variável, txt. O texto inserido não deve ser superior a 50 caracteres neste caso. Observe o uso do operador de extração, >>. A última declaração exibe o texto inserido na tela.

CIN pode levar mais de uma palavra do teclado, separado por espaços. Essas palavras terão que ser extraídas para diferentes variáveis. O seguinte segmento de código ilustra o seguinte:

char txt [20];
int;
float ft;
cout << "Enter 3 values and press Enter:" txt >> it >> ft;
cout << txt << " << it << " << ft << endl;

Observe a declaração:

CIN >> txt >> it >> ft;

A primeira palavra é extraída para txt, a próxima e a última a ft. Se a entrada fosse,

um 25 3.6

então a saída pelo segmento de código seria,

um 25 3.6

Cerr

O programa a seguir tem um erro:

#incluir
usando namespace std;
int main ()

em myint;
retornar 0;

A primeira declaração em main () não está correta. Se o nome do arquivo com o código for “Temp.CC ”e o arquivo executável resultante deve ser chamado de“ temp ”, então o seguinte comando g ++ enviará a mensagem de erro do compilador para o arquivo,“ Erro.TXT":

G ++ -o Temper temperamento.CC 2> Erro.TXT

Se o arquivo “erro.txt ”não existe, seria criado. Observe a parte “2> erro.txt ”do comando g ++.

A tela é o destino de saída padrão e também é o destino de erro padrão. Se “2> erro.txt ”é omitido do comando g ++, a mensagem de erro do compilador seria enviada para o destino de erro padrão, que ainda é a tela (monitor).

O objeto de fluxo que representa o destino de saída padrão está cout. O objeto de fluxo que representa o destino de erro padrão é Cerr. Um erro de tempo de execução do programa pode ser enviado para a tela da seguinte forma:

Cerr << "The error message!" << '\n';

entupir

Um aplicativo leva diferentes entradas em momentos diferentes. Todas as entradas podem ser re-exibidas na tela. Todas as entradas podem ser salvas em um arquivo. Isso está registrando. O destino padrão de registro é a tela. O objeto padrão de fluxo de registro é um entupimento. O código a seguir será exibido novamente o texto de entrada para a tela:

char txt [50];
cout<<"Enter text and press Enter:"txt;
entupir<

Se o texto de entrada for "input_text", o entupimento re-display "input_text" na tela.

Na prática, o registro geralmente é redirecionado para um arquivo. O programa a seguir ilustra o seguinte:

#incluir
usando namespace std;
int main ()

Freopen ("log.txt "," w ", stdout);
cout << "input_text" << endl;

Observe o uso da função, Freopen () e seus argumentos. Seu primeiro argumento é o nome do arquivo de log. Se o arquivo não existir, seria criado. Seu segundo argumento é "W" para "Write". Seu terceiro argumento é stdout para saída padrão. A segunda instrução na função Main () usa o cout para enviar o texto de registro para o arquivo. Nota: O código de entrada real não foi mostrado neste programa.

Obtendo caracteres e cordas do teclado

Enquanto o usuário está digitando entrada, os caracteres são enviados para o buffer de fluxo de entrada e exibidos na tela. Quando o usuário pressiona a tecla Enter, todos os caracteres estão no buffer; Além disso, o cursor vai para o início da próxima linha abaixo, na tela. O programa continua até a próxima declaração do programa, após a declaração de leitura de entrada.

O objeto CIN possui métodos, com os quais esta seção se preocupa.

Lendo o primeiro personagem

get (char_type & c):
O segmento de código a seguir mostra como ler o primeiro caractere, a partir do buffer de fluxo de entrada:

char ch;
cout << "Input text:" << endl;
CIN.obtenha (ch);
cout << ch << endl;

A primeira declaração declara um personagem sem atribuição. A segunda declaração diz ao usuário para inserir um personagem. Quando o usuário digita o caractere e pressiona a tecla Enter, a terceira declaração copia o personagem do buffer de fluxo de entrada para a variável, CH.

Mesmo se o usuário digitar em mais de um caractere, o primeiro caractere seria levado pelo segmento de código.

pegar():
get () sem argumento, retorna o código ASCII decimal. Considere o seguinte segmento de código:

cout << "Input text:" << endl;
cout << cin.get() << endl;

Se a entrada for "ASDFG", então 97 será devolvido, que é o código ASCII decimal para 'a'.

get (char_type* s, streamsize n)

Depois que o usuário insere uma frase e pressiona a tecla Enter, vários caracteres que começam a partir do primeiro, podem ser extraídos do buffer de fluxo de CIN. O código a seguir pode ser usado:

Char Str [10];
cout << "Input text:" << endl;
CIN.obtenha (str, 10);
cout << str << endl;

Se a entrada for "ótimas pessoas", então a saída será "ótima pessoa", de 9 caracteres e não 10. O caractere de string nu (\ 0) assume a décima posição no argumento de get. Então, para ter 9 caracteres no STR, seu tamanho de armazenamento deve ser de pelo menos 10, e o argumento get () deve ser 11. Se a linha de entrada inteira for desejada, o número de armazenamento de string deve ser pelo menos o número de caracteres digitados, mais 1. Portanto, se 12 caracteres forem digitados para toda a linha, o número deve ter 13 para o tamanho do armazenamento da string (str) e 13 para o argumento get (). Observe que um espaço é contado como um personagem.

get (char_type* s, streamsize n, char_type delim)
É possível extrair uma sub-string, delimitada à direita, pela primeira ocorrência de um personagem em particular, ou pelo fluxo da sub-string, que vem primeiro. Se o texto de entrada para o código a seguir for "ótimas pessoas", então "ótimo" será extraído:

Char Str [30];
cout << "Input text:" << endl;
CIN.obtenha (str, 6, 'o');
cout << str << endl;

A sexta posição desde o início é o caráter espacial e delimita a substring extraída exclusivamente. A sexta posição vem primeiro antes do único personagem, 'O'. Observe que o tamanho do armazenamento para STR pode ser o mais alto possível.

Se o texto de entrada para o código a seguir for "ótimas pessoas", "GR" será extraído:

Char Str [30];
cout << "Input text:" << endl;
CIN.obtenha (str, 10, 'e');
cout << str << endl;

A primeira ocorrência de 'e' vem antes da décima posição.

Obtendo todos os personagens de uma linha

Depois de pressionar a tecla Enter, todos os caracteres digitados na linha podem ser obtidos como mostrado no código a seguir:

cout << "Input text:" << endl;
enquanto (1)
char ch = (char) CIN.pegar();
cout << ch;
if (ch == '\ n')
quebrar;

O elenco com (char) converte cada número decimal no caractere ASCII correspondente.

olhadinha()

As funções get () membro não apenas leem o próximo personagem; eles removem do buffer de fluxo. No entanto, a função de membro do Peek () simples lê o próximo personagem (começando a partir do primeiro) sem removê -lo do buffer. No código a seguir, cada caractere é lido pela primeira vez com a função Peek () antes de ser removida, pela função get (). Tudo o que acontece depois que o usuário pressiona a tecla Enter:

cout << "Input text:" << endl;
enquanto (1)
char ch = (char) CIN.olhadinha();
cout << ch;
CIN.pegar();
if (ch == '\ n')
quebrar;

Se os próximos caracteres não fossem removidos por get (), Peek () só estaria lendo o primeiro personagem, e o loop irá iterar indefinidamente.

Exibindo e excluindo caracteres antes de pressionar Enter

Observe que, com o objeto CIN, a tecla Enter deve ser pressionada antes que haja ação. Bem, é possível que os caracteres sejam exibidos ao serem digitados e apagados antes de pressionar a tecla Enter. No entanto, isso significa interface com o sistema operacional. Os sistemas operacionais diferem. Portanto, isso significa codificação diferente para diferentes sistemas operacionais. Portanto, este tópico merece um tutorial totalmente diferente - veja mais tarde.

Enviando caracteres e strings para o monitor

O objeto Cout é um objeto de fluxo de saída, já instanciado e presente na biblioteca padrão C ++. cout é o principal objeto usado no envio de caracteres e strings para o monitor. Isso é feito com o operador de inserção, << . With the cin object, the text is obtained line-by-line. With the cout object, the text is added onto the same line until '\n' or endl is encountered.

Expressões que resultam em escalares podem ser argumentos para o operador de inserção. O operador converte o escalar em texto e coloca o texto no fluxo de objetos cout. Quando o texto é enviado para o objeto Cout, normalmente aparece na tela (monitor). No entanto, ocasionalmente, pode não aparecer imediatamente. Para o texto forçado na tela, insira o valor especial, "endl", logo após a inserção do texto. Isso fará com que o texto seja lavado na tela, e uma nova linha será adicionada. Nota: '\ n' simplesmente adiciona uma nova linha, mas não libera texto na tela.

O programa a seguir mostra como imprimir os valores de INT, Float e texto comum, na tela:

#incluir
usando namespace std;
int main ()

int it = 5;
float ft = 63.5;
cout << "The " << it << " items cost $" << ft << " US." << endl;
retornar 0;

A saída é:

Os 5 itens custam $ 63.5 nós.

O programa a seguir mostra como a sequência de um objeto instanciada de uma classe é impressa:

#incluir
usando namespace std;
struct st
char str [11] = "Algumas palavras";
obj;
int main ()

cout << obj.str << '\n';
retornar 0;

A saída é "algumas palavras".

Argumentos para um programa C ++

A execução do programa começa a partir da função principal (). A função Main () realmente tem dois parâmetros opcionais. A sintaxe da função principal () com os parâmetros opcionais é:

int main (int argc, char *argv [argc])

retornar 0;

Suponha que o nome do arquivo C ++ executável seja "temp". Suponha que os argumentos de que o programa precisa de seu ambiente (sistema operacional), digitado pelo usuário, é,

Artigos 3 Livro caneta "Big House"

Existem 5 argumentos aqui: "Artigos", "3", "Book", "Pen" e "Big House"

Cada um é texto. Um argumento numerado para um programa é texto. Em outras palavras, cada argumento é uma string. "Big House" está em citações porque é uma frase. O comando do terminal para executar este programa seria:

./artigos temp 3 caneta de livro "Big House"

Supondo que a temperatura do arquivo esteja no diretório doméstico. Observe que espaços e não vírgulas separam os argumentos.

Agora, na sintaxe da função main (), Argc é o número de argumentos para o programa, mais 1. Nesse caso, existem 5 argumentos para o programa. Então, Argc é 6. Na sintaxe, o argv [argc] é uma variedade de dicas para as cordas. O primeiro valor para esta matriz no argv [0] é dado pelo compilador. É um ponteiro para o nome do arquivo do programa. O restante dos valores são ponteiros para os argumentos do programa no pedido do usuário digitado em. O tamanho desta matriz é argc. Nesse caso, o tamanho é 1 + 5 = 6.

Suponha que, na compilação, o seguinte programa é nomeado Temp:

#incluir
usando namespace std;
int main (int argc, char ** argv)

cout << argv[0] << ", " << argv[1] <<
"," << argv[2] << ", " << argv[3] <<
"," << argv[4] << ", " << argv[5] << endl;
retornar 0;

Observe aqui que a matriz "char*argv [argc]" foi declarada como "char ** argv".

Se este programa for executado com o comando do terminal,

./artigos temp 3 caneta de livro "Big House"

Então a saída seria:

./temp, artigos, 3, livro, caneta, casa grande

Observe que o caminho do diretório foi incluído com o nome do arquivo executável.

Além disso, observe que, na execução do programa (chamando o programa), o valor para o ARGC não foi enviado.

Conclusão

A classe iostream tem quatro objetos importantes que são cout, CIN, Cerr e entupimento. CIN é um objeto de entrada, enquanto os demais são objetos de saída. Enquanto um programa está em execução, a entrada para o programa é diferente de quando o programa é começar a ser executado. Quando um programa começa a ser executado, a entrada do programa é unida ao comando para executar o programa, separado por espaços.