A operação de E/S C++ usa o conceito de fluxo. A série de bytes ou fluxo de dados é chamada de fluxo. Acelera o desempenho.
Se os bytes forem transferidos da memória principal para um dispositivo como uma impressora, tela, conexão de rede, etc., isso é chamado de operação de saída.
Uma operação de entrada ocorre quando os bytes fluem de um dispositivo, como uma impressora, uma tela ou uma conexão de rede, para a memória principal.
Em C++, funções predefinidas e as declarações são fornecidas por meio de arquivos de cabeçalho, permitindo que você execute tarefas específicas sem precisar escrever um novo código desde o início. Alguns arquivos de cabeçalho importantes para operações de entrada/saída em C++ incluem funções para realizar tarefas de entrada e saída de maneira eficaz. A Biblioteca Padrão C++, uma coleção de classes e métodos criados na linguagem de programação C++, contém esses arquivos de cabeçalho. Vamos discutir os principais arquivos de cabeçalho para operações de entrada/saída:
| Arquivo de cabeçalho | Função e Descrição |
|---|---|
| É usado para definir o cout, cin e cerr objetos, que correspondem ao fluxo de saída padrão, fluxo de entrada padrão e fluxo de erro padrão, respectivamente. | |
| É usado para declarar serviços úteis para realizar E/S formatada, como setprecision e setw. | |
| É usado para declarar serviços para processamento de arquivos controlado pelo usuário. |
iostream: É um dos arquivos de cabeçalho mais importantes para operações de entrada/saída em C++. Ele significa 'entrada-saída' fluxo. Para trabalhar com diversas formas de fluxos de entrada/saída, o iostream arquivo de cabeçalho inclui as classes istream (fluxo de entrada) e ostream (fluxo de saída) bem como suas classes derivadas ifstream, ofstream , e stringstream . As classes mais usadas deste arquivo de cabeçalho são cin (entrada padrão) e cout (saída padrão) , que permite ler a entrada do usuário e exibir a saída no console. Por exemplo:
#include using namespace std; int main() { int num; cout <> num; cout << 'You entered: ' << num << endl; return 0; } Saída
Enter a number: 42 You entered: 42
iomanip: Este arquivo de cabeçalho significa 'manipulação de entrada-saída' . Ele fornece ferramentas para formatar entrada e saída . Ele permite que você modifique o alinhamento, largura, precisão e outros recursos de formatação de entrada e saída. Setw, setprecision, fixo, esquerda, direita e outras funções usadas regularmente estão listadas abaixo. É especialmente útil para apresentar dados de uma determinada maneira.
Exemplo:
#include #include using namespace std; int main() { double pi = 3.14159; cout << fixed << setprecision(2) << 'Value of pi: ' << pi << endl; return 0; } Saída
c número aleatório
Value of pi: 3.14
fluxo: O arquivo de cabeçalho para operações de entrada/saída de arquivo é chamado stream . Inclui aulas para leitura e gravação em arquivos ifstream (fluxo de arquivo de entrada) e ofstream (fluxo de arquivo de saída) . O sistema usa essas classes para abrir arquivos somente leitura e somente gravação.
Exemplo:
#include #include using namespace std; int main() { ofstream outputFile('output.txt'); if (outputFile.is_open()) { outputFile << 'Hello, File I/O!'; outputFile.close(); cout << 'File is written successfully.' << endl; } else { cout << 'Failed to open the file.' << endl; } return 0; } Saída
The file was written successfully.
Esses arquivos de cabeçalho estão entre os mais cruciais para tarefas de entrada/saída C++. Cada um tem uma finalidade específica e oferece as ferramentas necessárias para gerenciar com sucesso tarefas que envolvem entrada e saída, seja interagindo com o console, formatação de saída ou trabalhando com arquivos.
Em C++, frequentemente usamos 'usando namespace std;' após os arquivos de cabeçalho. O espaço para nome padrão; A instrução é freqüentemente usada em C++ para simplificar o código ao trabalhar com componentes de biblioteca padrão. Vamos examinar a função e a aplicação desta declaração com mais detalhes:
A espaço para nome é uma técnica para agrupar identificadores semelhantes (como classes, funções , e variáveis ) para evitar conflitos de nomenclatura. A Biblioteca Padrão C++ fornece suas partes (como cin, cout, etc.) no namespace std.
O termo 'padrão' é encurtado para 'padrão' , e todos os elementos da biblioteca padrão estão contidos nela. Ao fazer isso, os conflitos de nomes com os identificadores configurados no seu código são reduzidos.
Agora vamos falar sobre por que usar o namespace std; declaração é usada:
Sem usar o namespace std:
#include int main() { std::cout << 'Hello, world!' << std::endl; return 0; } With using namespace std: #include using namespace std; int main() { cout << 'Hello, world!' << endl; return 0; } Como você pode ver, usando o espaço para nome padrão; declaração permite que você omita o std:: prefixo ao acessar componentes da biblioteca padrão. Isso torna seu código mais curto e legível, pois você não precisa repetir padrão:: antes de cada identificador de biblioteca padrão.
Arquivos de cabeçalho da biblioteca de E/S
Fluxo de saída padrão (cout):
O objeto cout é um objeto predefinido da classe ostream. Ele está conectado ao dispositivo de saída padrão, que geralmente é uma tela. O cout é usado em combinação com o operador de inserção de stream (<<) to show the output on a console< p>
Vejamos o exemplo simples de um fluxo de saída padrão (cout):
#include using namespace std; int main( ) { char ary[] = 'Welcome to C++ tutorial'; cout << 'Value of ary is: ' << ary << endl; } Saída
Value of ary is: Welcome to C++ tutorial
Fluxo de entrada padrão (cin)
O comendo é um objeto predefinido de fluxo aula. Ele está conectado ao dispositivo de entrada padrão, que geralmente é um teclado. O cin é usado em conjunto com o operador de extração de fluxo (>>) para ler a entrada de um console.
Vejamos o exemplo simples de fluxo de entrada padrão (cin):
#include using namespace std; int main( ) { int age; cout <> age; cout << 'Your age is: ' << age << endl; } Saída
Enter your age: 22 Your age is: 22
Linha final padrão (endl)
O fim é um objeto predefinido de nosso inimigo aula. Ele é usado para inserir caracteres de uma nova linha e liberar o fluxo.
Vejamos o exemplo simples de linha final padrão (endl):
#include using namespace std; int main( ) { cout << 'C++ Tutorial'; cout << ' Javatpoint'<<endl; cout << 'end of line'<<endl; } < pre> <p> <strong>Output</strong> </p> <pre> C++ Tutorial Javatpoint End of line </pre> <h3>Un-buffered standard error stream (cerr):</h3> <p> <strong> <em>cerr</em> </strong> stands for <strong> <em>'standard error'</em> .</strong> </p> <p>It is an unbuffered stream, meaning that output sent to <strong> <em>cerr</em> </strong> is immediately displayed on the console without buffering.</p> <p>It is typically used for displaying error messages and diagnostic information, which need to be displayed immediately to avoid delays caused by buffering.</p> <p> <strong>Example: using cerr:</strong> </p> <pre> #include int main() { std::cerr << 'This is an error message.' << std::endl; return 0; } </pre> <p> <strong>Output</strong> </p> <pre> This is an error message. </pre> <h3>buffered standard error stream (clog):</h3> <p>clog stands for <strong> <em>'standard log'</em> </strong> . It is a buffered stream, similar to cout. It's often used for writing informational or diagnostic messages that are less time-sensitive than errors. The use of buffering can improve performance when displaying a large number of messages.</p> <p> <strong>Example: using clog</strong> </p> <pre> #include int main() { std::clog << 'This is an informational message.' << std::endl; return 0; } </pre> <p> <strong>Output</strong> </p> <pre> This is an informational message. </pre> <p>In both examples, the output will appear on the console. However, the main difference between <strong> <em>cerr</em> </strong> and <strong> <em>clog</em> </strong> lies in their buffering behavior. Due to its unbuffered nature, messages given to <strong> <em>cerr</em> </strong> are displayed right away, but messages sent to clog may be buffered for greater speed. However, they will still eventually appear on the console.</p> <h4>Note: It is important to remember that the type of message you wish to display will determine whether you use cerr or clog. Use cerr for essential messages that need immediate attention (like error messages) and use clog for less critical diagnostic or informational messages that can be buffered for better performance.</h4> <hr></endl;> Fluxo de erro padrão sem buffer (cerr):
cerr apoia 'erro padrão' .
É um fluxo sem buffer, o que significa que a saída enviada para cerr é imediatamente exibido no console sem buffer.
Geralmente é usado para exibir mensagens de erro e informações de diagnóstico, que precisam ser exibidas imediatamente para evitar atrasos causados pelo buffer.
Exemplo: usando cerr:
#include int main() { std::cerr << 'This is an error message.' << std::endl; return 0; } Saída
This is an error message.
fluxo de erro padrão armazenado em buffer (entupimento):
entupimento significa 'registro padrão' . É um fluxo em buffer, semelhante ao cout. Geralmente é usado para escrever mensagens informativas ou de diagnóstico que são menos sensíveis ao tempo do que erros. O uso de buffer pode melhorar o desempenho ao exibir um grande número de mensagens.
Exemplo: usando entupir
#include int main() { std::clog << 'This is an informational message.' << std::endl; return 0; } Saída
This is an informational message.
Em ambos os exemplos, a saída aparecerá no console. No entanto, a principal diferença entre cerr e entupir reside em seu comportamento de buffer. Devido à sua natureza sem buffer, as mensagens dadas a cerr são exibidos imediatamente, mas as mensagens enviadas para entupir podem ser armazenadas em buffer para maior velocidade. No entanto, eles ainda aparecerão no console.