136 lines
6.9 KiB
Markdown
136 lines
6.9 KiB
Markdown
|
---
|
||
|
title: Input and Output
|
||
|
localeTitle: Entrada e saída
|
||
|
---
|
||
|
## Entrada e Saída com Fluxos
|
||
|
|
||
|
Para imprimir coisas no console, ou ler a partir dele, use `cout` e `cin` , que são os chamados `streams` . Essa metáfora é usada porque você usa fluxos como o que você usaria uma pia ou um toque: ou você descarrega dados em uma pia ( `cout` ) ou obtém dados de um toque ( `cin` ).
|
||
|
|
||
|
### Saída com cout
|
||
|
|
||
|
O programa "Hello World" usa `cout` para imprimir "Hello World!" para o console:
|
||
|
|
||
|
```C++
|
||
|
#include<iostream>
|
||
|
using namespace std;
|
||
|
|
||
|
int main()
|
||
|
{
|
||
|
cout << "Hello world!" << endl;
|
||
|
}
|
||
|
```
|
||
|
|
||
|
As duas primeiras linhas no topo são necessárias para você usar `cout` e outros fluxos. `#include<iostream>` faz com que os objetos de fluxo estejam disponíveis e `using namespace std;` permite que você digite `cout` diretamente ao invés de ter que digitar `std::cout` , isto é, ter que especificar que queremos usar `cout` do namespace `std` .
|
||
|
|
||
|
`cout` significa "Console Output" e é um chamado _fluxo de saída_ que representa o console. Quando você quiser imprimir algo no console, você pode colocá-lo em `cout` ; imagine-o como um buraco que leva ao terminal. Para colocar coisas neste buraco, uma de cada vez, você usa o operador `<<` , também conhecido como o _operador de inserção_ 1 . O operador pode ser acorrentado, ou seja, você pode colocar várias coisas em uma após a outra. O seguinte irá imprimir "O bolo é uma mentira":
|
||
|
|
||
|
`cout << "The cake " << "is " << "a " << "lie." << endl;`
|
||
|
|
||
|
`endl` significa "End Line" e é outro item que vem de `<iostream>` . Quando você coloca `endl` em `cout` , ele irá imprimir um caractere de nova linha ( "\\ n") para o console, e também _alinhada_ `cout` , o que significa que ele irá forçar `cout` para imprimir tudo o que você colocar nele _agora._ Se você não colocar `endl` em `cout` , `cout` pode manter os dados que você colocou nele, mas esperar por mais dados antes de realmente imprimir tudo. Isto é chamado de _buffer_ e é muito bom para o desempenho, mas se você já tiver dado tudo o que é suposto para imprimir, você quer `cout` imprimi-lo immediatelly. Portanto, é uma boa prática terminar com `endl` em lugares onde faz sentido.
|
||
|
|
||
|
Quase tudo pode ser colocado em um fluxo: strings, números, variáveis, expressões, etc. Aqui estão alguns exemplos de inserções de fluxo válidas:
|
||
|
|
||
|
```C++
|
||
|
// Notice we can use the number 42 and not the string "42".
|
||
|
cout << "The meaning of life is " << 42 << endl;` // Output: The meaning of life is 42
|
||
|
```
|
||
|
|
||
|
```C++
|
||
|
string name = "Tim";
|
||
|
cout << "Except for you, " << name << endl;`// Output: Except for you, Tim
|
||
|
```
|
||
|
|
||
|
```C++
|
||
|
string name = "Tim";
|
||
|
cout << name;
|
||
|
cout << " is a great guy!" << endl;`
|
||
|
// Output: Tim is a great guy!
|
||
|
```
|
||
|
|
||
|
```C++
|
||
|
int a = 3;
|
||
|
cout << a*2 + 18/a << endl;`// Output: 12
|
||
|
```
|
||
|
|
||
|
### Uma nota sobre o espaço em branco
|
||
|
|
||
|
C ++ sempre coloca _você_ no controle e faz exatamente as coisas que você diz para fazer. Isso às vezes pode ser surpreendente, como no exemplo a seguir:
|
||
|
|
||
|
```C++
|
||
|
string name = "Sarah";
|
||
|
cout << "Good morning" << name << "how are you today? << endl;
|
||
|
```
|
||
|
|
||
|
Você pode esperar que seja impresso "Bom dia Sarah, como você está hoje?", Mas na verdade, a saída seria "Bom dia, Sarah, como você está hoje?". A razão para esse bug é que você não escreveu espaços nas strings ao redor do `name` , e assim, como você não especificou nenhum espaço, o `cout` não imprimiu nenhum. A versão correta seria: `cout << "Good morning " << name << " how are you today? << endl;`
|
||
|
|
||
|
Quebras de linha também não acontecem sozinhas. Você pode pensar que isso imprimiria uma receita em quatro linhas:
|
||
|
|
||
|
```C++
|
||
|
cout << "To make bread, you need:";
|
||
|
cout << "* One egg";
|
||
|
cout << "* One water";
|
||
|
cout << "* Two wheat";
|
||
|
```
|
||
|
|
||
|
mas a saída é na verdade tudo em uma linha: "Para fazer pão, você precisa: \* Um ovo \* Uma água \* Dois de trigo". Isso ocorre porque não há caracteres de nova linha no final das linhas, portanto, naturalmente, o C ++ assume que não queremos imprimir caracteres de nova linha.
|
||
|
|
||
|
Você poderia consertar isso adicionando `endl` s após cada linha, porque, como discutido anteriormente, o `endl` insere um caractere de nova linha no fluxo de saída. No entanto, isso também força o buffer a ser liberado, o que nos perde um pouco o desempenho, já que poderíamos imprimir todas as linhas de uma só vez. Portanto, o melhor seria adicionar caracteres reais de nova linha no final das linhas e usar somente `endl` no final:
|
||
|
|
||
|
```C++
|
||
|
cout << "To make bread, you need:\n";
|
||
|
cout << "* One egg\n";
|
||
|
cout << "* One water\n";
|
||
|
cout << "* Two wheat" << endl;
|
||
|
```
|
||
|
|
||
|
Se você está apenas imprimindo uma pequena receita, o tempo que você economiza é minúsculo e não vale a pena, mas se você estiver imprimindo milhões de itens, a diferença pode ser muito perceptível.
|
||
|
|
||
|
### Entrada com cin
|
||
|
|
||
|
Para ler a partir do console, você usa o _fluxo de entrada_ `cin` da mesma forma como faria `cout` , mas em vez de colocar as coisas em `cin` , você "tirá-los". O programa a seguir lê dois números do usuário e os adiciona juntos:
|
||
|
|
||
|
```C++
|
||
|
#include<iostream>
|
||
|
using namespace std;
|
||
|
|
||
|
int main()
|
||
|
{
|
||
|
int a, b; // Variables to hold the two numbers.
|
||
|
|
||
|
cout << "Please enter the first number:" << endl;
|
||
|
cin >> a;
|
||
|
cout << "Please enter the second number:" << endl;
|
||
|
cin >> b;
|
||
|
|
||
|
cout << "The sum of your numbers is: " << a + b << endl;
|
||
|
}
|
||
|
```
|
||
|
|
||
|
`cin` significa "Console Input" e é um _fluxo de entrada_ que representa a entrada do console. Na expressão `cin >> a;` , os dados são lidos de `cin` e salvos na variável `a` , usando o operador `>>` , o _operador de extração_ 2 . O operador de extração lê exatamente a quantidade de dados necessária para gravar na variável que especificamos e pula qualquer espaço em branco, portanto, se o usuário digitar "6", isso será lido apenas como o valor `6` .
|
||
|
|
||
|
Vale a pena notar que o `cin` irá parar todo o programa para esperar que o usuário digite seu valor. O programa não continuará até que o usuário tenha pressionado enter e alguns dados serão gravados na variável. Se o usuário apenas pressionar enter sem digitar nada, o `cin` continuará esperando por um valor.
|
||
|
|
||
|
O operador de extração `<<` pode ser encadeado também. Aqui está o mesmo programa da última vez, mas escrito de uma maneira mais concisa:
|
||
|
|
||
|
```C++
|
||
|
#include<iostream>
|
||
|
using namespace std;
|
||
|
|
||
|
int main()
|
||
|
{
|
||
|
int a, b; // Variables to hold the two numbers.
|
||
|
|
||
|
cout << "Please enter two numbers:" << endl;
|
||
|
cin >> a >> b;
|
||
|
cout << "The sum of your numbers is: " << a + b << endl;
|
||
|
}
|
||
|
```
|
||
|
|
||
|
Quando encadeado, o operador de extração primeiro lerá os dados de `cin` para preencher `a` e, em seguida, lerá os dados para preencher `b` .
|
||
|
|
||
|
As instruções printf e scanf padrão de C também podem ser usadas com o c ++ importando ' ' arquivo de cabeçalho.
|
||
|
|
||
|
## Fontes
|
||
|
|
||
|
1. http://www.cplusplus.com/reference/ostream/ostream/operator%3C%3C/
|
||
|
2. http://www.cplusplus.com/reference/istream/istream/operator%3E%3E/
|