Introdução aos arquivos de cabeçalho C++ — arquivos de cabeçalho <cstdio>

Introdução aos arquivos de cabeçalho C++ - <cstdio>arquivos de cabeçalho

<cstdio>arquivo principal

Introdução

<cstdio>É para <stdio.h>expressar o conteúdo na forma de um arquivo de cabeçalho C++. <stdio.h>É o arquivo de cabeçalho na biblioteca de funções padrão C, a saber: entrada e saída com buffer padrão. Fornece operações básicas de fluxo de entrada e saída de texto (incluindo telas e arquivos, etc.). Como a linguagem C não fornece palavras-chave dedicadas à entrada e saída de texto, esta biblioteca é a biblioteca de carregamento de programas em linguagem C mais comum.

Nota: Há uma diferença <cstdio>entre <stdio.h>, não o mesmo arquivo.

visão geral

namespace std {
    
    
  using size_t = ;
  using FILE = ;
  using fpos_t = ;
}
 
#define NULL 
#define _IOFBF 
#define _IOLBF 
#define _IONBF 
#define BUFSIZ 
#define EOF 
#define FOPEN_MAX 
#define FILENAME_MAX 
#define L_tmpnam 
#define SEEK_CUR 
#define SEEK_END 
#define SEEK_SET 
#define TMP_MAX 
#define stderr 
#define stdin 
#define stdout 
 
namespace std {
    
    
  int remove(const char* filename);
  int rename(const char* old, const char* new);
  FILE* tmpfile();
  char* tmpnam(char* s);
  int fclose(FILE* stream);
  int fflush(FILE* stream);
  FILE* fopen(const char* filename, const char* mode);
  FILE* freopen(const char* filename, const char* mode, FILE* stream);
  void setbuf(FILE* stream, char* buf);
  int setvbuf(FILE* stream, char* buf, int mode, size_t size);
  int fprintf(FILE* stream, const char* format, ...);
  int fscanf(FILE* stream, const char* format, ...);
  int printf(const char* format, ...);
  int scanf(const char* format, ...);
  int snprintf(char* s, size_t n, const char* format, ...);
  int sprintf(char* s, const char* format, ...);
  int sscanf(const char* s, const char* format, ...);
  int vfprintf(FILE* stream, const char* format, va_list arg);
  int vfscanf(FILE* stream, const char* format, va_list arg);
  int vprintf(const char* format, va_list arg);
  int vscanf(const char* format, va_list arg);
  int vsnprintf(char* s, size_t n, const char* format, va_list arg);
  int vsprintf(char* s, const char* format, va_list arg);
  int vsscanf(const char* s, const char* format, va_list arg);
  int fgetc(FILE* stream);
  char* fgets(char* s, int n, FILE* stream);
  int fputc(int c, FILE* stream);
  int fputs(const char* s, FILE* stream);
  int getc(FILE* stream);
  int getchar();
  int putc(int c, FILE* stream);
  int putchar(int c);
  int puts(const char* s);
  int ungetc(int c, FILE* stream);
  size_t fread(void* ptr, size_t size, size_t nmemb, FILE* stream);
  size_t fwrite(const void* ptr, size_t size, size_t nmemb, FILE* stream);
  int fgetpos(FILE* stream, fpos_t* pos);
  int fseek(FILE* stream, long int offset, int whence);
  int fsetpos(FILE* stream, const fpos_t* pos);
  long int ftell(FILE* stream);
  void rewind(FILE* stream);
  void clearerr(FILE* stream);
  int feof(FILE* stream);
  int ferror(FILE* stream);
  void perror(const char* s);
}

algum conhecimento

Biblioteca C++ para realizar operações de entrada/saída

As operações de entrada e saída também podem ser implementadas em C++ usando a biblioteca de entrada e saída padrão C ( <cstdio>, em linguagem C <stdio.h>). A biblioteca utiliza os chamados “streams” para manipular dispositivos físicos como teclados, impressoras, terminais ou outros tipos de arquivos suportados pelo sistema. Um stream é uma abstração para interagir com esses dispositivos físicos de maneira uniforme. Todos os fluxos têm propriedades semelhantes, independentemente das características individuais dos dispositivos físicos associados.

Os fluxos <cstdio>operam na biblioteca como ponteiros para objetos FILE. Um ponteiro para um objeto FILE representa exclusivamente um fluxo e é usado como parâmetro em operações que projetam o fluxo.

Existem três fluxos padrão: stdin, stdout e stderr, que são criados automaticamente e publicamente para todos os programas que usam a biblioteca.

propriedades de fluxo

Os fluxos possuem propriedades que definem quais funções podem ser aplicadas a eles e como tratar a entrada ou saída de dados deles. fopenA maioria dessas propriedades são definidas no momento em que o stream é associado (aberto) ao arquivo por meio da função:

acesso de leitura/gravação

Especifica se os fluxos têm acesso de leitura ou gravação (ou ambos) à mídia física associada.

texto/binário

Considera-se que um fluxo de texto representa uma sequência de linhas de texto, cada linha terminada por um caractere de nova linha. Dependendo do ambiente operacional do programa, pode ocorrer alguma conversão de caracteres para adaptar alguns caracteres especiais à particularidade do ambiente do arquivo de texto. Um fluxo binário, por outro lado, é uma sequência de caracteres escritos ou lidos de um meio físico sem qualquer conversão, que corresponde um a um aos caracteres lidos ou escritos no fluxo.

esconderijo

Um cache é um bloco de memória onde os dados são acumulados antes de serem lidos ou gravados em um arquivo ou dispositivo associado. Os fluxos podem ser totalmente armazenados em buffer, em buffer de linha ou não em buffer. Para fluxos com buffer completo, os dados são lidos/gravados quando o fluxo está cheio, para fluxos com buffer de linha, quando um caractere de nova linha é encontrado, e para fluxos sem buffer, os caracteres são lidos/gravados imediatamente.

orientação

Quando aberto, o fluxo não é direcionado. Quando operações de entrada/saída são executadas neles, elas se tornam orientadas a bytes ou orientadas a bytes largos, dependendo de qual operador é aplicado (geralmente as funções definidas em são orientadas a bytes, enquanto as funções definidas em função são orientadas a bytes largos).

indicador

Os fluxos são usados ​​para indicadores internos específicos que indicam seu estado atual e que afetam o comportamento das operações de entrada e saída neles:

indicador de erro

Este indicador é definido quando ocorre um erro em uma operação relativa ao fluxo. O indicador pode ferrorser detectado pela função e pode ser redefinido chamando clearerr, freopenou .rewind

indicador de fim de arquivo

Uma vez definido, indica que a próxima operação de leitura ou gravação neste fluxo atingiu o fim do arquivo. Ele pode ser detectado pela função e pode ser redefinido feofchamando clearerrou freopenchamando qualquer uma das funções de relocação ( rewind, fseeke ).fsetpos

indicador de localização

É um ponteiro interno para cada fluxo que aponta para o próximo caractere para a próxima operação de E/S ler ou escrever. Seu valor pode ser obtido pela função ftellou fgetpose pode ser alterado usando a função de relocação rewinde função.fseekfsetpos

função

Arquivo de ação:

• removeexcluir arquivo (função)

• renamerenomear arquivo (função)

• tmpfileabra um arquivo temporário (função)

• tmpnamgerar um nome de arquivo temporário (função)

Acesso ao arquivo:

• fclosefechar arquivo (função)

• fflushfluxo de descarga (função)

• fopenabrir arquivo (função)

• freopenreabrir o stream com um arquivo ou modo (função) diferente

• setbufdefinir cache de fluxo (função)

• servbufalterar buffer de fluxo (função)

Entrada/saída formatada:

fprintfgravar dados formatados em stream (função)

• fscanfLer dados formatados de um stream (função)

• printfimprimir dados formatados para stdout(função)

• scanfstdinler dados formatados de (função)

• snprintfGravar dados formatados em buffer de comprimento fixo (função)

• sprintfgravar dados formatados em string (função)

• sscanfLer dados formatados de uma string (função)

• vfprintfGrava dados formatados da lista variada no fluxo (função)

• vfscanfLer dados formatados do fluxo na lista de argumentos variáveis ​​(função)

• vprintfimprima os dados formatados na lista variada para stdout(função)

• vscanfLer dados formatados na lista de argumentos variáveis ​​(função)

• vsnprintfGrave os dados formatados na lista de parâmetros variáveis ​​no buffer de comprimento fixo (função)

• vsprintfEscreva os dados formatados na lista variada em uma string (função)

• vsscanfLer dados formatados de uma string em uma lista variada (função)

Entrada/saída de string:

• fgetcObtenha um personagem de um stream (função)

• fgetsObtenha uma string de um stream (função)

• fputcescrever caracteres em um fluxo (função)

• fputsgrava uma string em um stream (função)

• getcObtenha um personagem de um stream (função)

• getcharstdinobter caractere de (função)

• getsstdinobter string de (função)

• putcescrever caracteres em um fluxo (função)

• putcharescrever caractere stdout(função)

• putsescrever string em stdout(função)

• ungetcnão obtém um caractere de um fluxo (função)

Entrada/saída direta:

• freadLer pedaços de dados de um stream (função)

• fwritegravar um pedaço de dados em um fluxo (função)

Localização de arquivo:

• fgetposobter a posição atual do fluxo (função)

• fseekreposicionar indicador de posição do fluxo (função)

• fsetposdefinir indicador de posição do fluxo (função)

• ftellObtenha a posição atual do stream (função)

• rewindDefina a posição do fluxo para iniciar (função)

Manipulação de erros:

• clearerrlimpar indicador de erro (função)

• feofverifique o indicador de fim de arquivo (função)

• ferrorverifique o indicador de erro (função)

• perrorimprimir mensagem de erro (função)

macro

• BUFSIZEtamanho do buffer (constante)

• EOFfim do arquivo (constante)

• FILENAME_MAXO comprimento máximo do nome do arquivo (constante)

• FOPEN_MAXLimite potencial em fluxos continuamente abertos (constante)

• L_tmpnamComprimento mínimo de nomes de arquivos temporários (constante)

• NULLnullponteiro (macro)

• TMP_MAXNúmero de arquivos temporários (constante)

• Também: _IOFBF, _IOLBF, _IONBF(usado em setvbuf)

• SEEK_CURe SEEK_END( SEEK_SETusado em fseek).

tipo

• FILEobjeto (tipo) contendo informações sobre o fluxo de controle

• fpos_tobjeto (tipo) contendo informações no local especificado no arquivo

• size_ttipo inteiro sem sinal (tipo)

contente

//　-*-　C++　-*-　forwarding　
header.
 
//　Copyright　(C)　1997,　1998,　1999,　2000,　2001,　2002,　2003
//　Free　Software　Foundation,　Inc.
//
//　This　file　is　part　of　the　GNU　ISO　C++　Library.　This　library　is　free
//　software;　you　can　redistribute　it　and/or　modify　it　under　the
//　terms　of　the　GNU　General　Public　License　as　published　by　the
//　Free　Software　Foundation;　either　version　2,　or　(at　your　option)
//　any　later　version.
 
//　This　library　is　distributed　in　the　hope　that　it　will　be　useful,
//　but　WITHOUT　ANY　WARRANTY;　without　even　the　implied　warranty　of
//　MERCHANTABILITY　or　FITNESS　FOR　A　PARTICULAR　PURPOSE.　See　the
//　GNU　General　Public　License　for　more　details.
 
//　You　should　have　received　a　copy　of　the　GNU　General　Public　License　along
//　with　this　library;　see　the　file　COPYING.　If　not,　write　to　the　Free
//　Software　Foundation,　59　Temple　Place　-　Suite　330,　Boston,　MA　02111-1307,
//　USA.
 
//　As　a　special　exception,　you　may　use　this　file　as　part　of　a　free　software
//　library　without　restriction.　Specifically,　if　other　files　instantiate
//　templates　or　use　macros　or　inline　functions　from　this　file,　or　you　compile
//　this　file　and　link　it　with　other　files　to　produce　an　executable,　this
//　file　does　not　by　itself　cause　the　resulting　executable　to　be　covered　by
//　the　GNU　General　Public　License.　This　exception　does　not　however
//　invalidate　any　other　reasons　why　the　executable　file　might　be　covered　by
//　the　GNU　General　Public　License.
 
//
//　ISO　C++　14882:　27.8.2　C　Library　files
//
 
/**　@file　cstdio
　*　This　is　a　Standard　C++　Library　file.　You　should　@c　#include　this　file
　*　in　your　programs,　rather　than　any　of　the　"*.h"　implementation　files.
　*
　*　This　is　the　C++　version　of　the　Standard　C　Library　header　@cstdio.h,
　*　and　its　contents　are　(mostly)　the　same　as　that　header,　but　are　all
　*　contained　in　the　namespace　@cstd.
　*/
 
 
#ifndef　_GLIBCXX_CSTDIO
#define　_GLIBCXX_CSTDIO　1
 
 
#pragma GCC　system_header
 
#include　<bits/c++config.h>
#include　<cstddef>
 
#include　<stdio.h>
 
//　Get　rid　of　those　macros　defined　in　<stdio.h>　in　lieu　of　real　functions.
 
#undef　clearerr
#undef　fclose
#undef　feof
#undef　ferror
#undef　fflush
#undef　fgetc
#undef　fgetpos
#undef　fgets
#undef　fopen
#undef　fprintf
#undef　fputc
#undef　fputs
#undef　fread
#undef　freopen
#undef　fscanf
#undef　fseek
#undef　fsetpos
#undef　ftell
#undef　fwrite
#undef　getc
#undef　getchar
#undef　gets
#undef　perror
#undef　printf
#undef　putc
#undef　putchar
#undef　puts
#undef　remove
#undef　rename
#undef　rewind
#undef　scanf
#undef　setbuf
#undef　setvbuf
#undef　sprintf
#undef　sscanf
#undef　tmpfile
#undef　tmpnam
#undef　ungetc
#undef　vfprintf
#undef　vprintf
#undef　vsprintf
 
namespace　std
{
    
    
　using　::FILE;
　using　::fpos_t;
  using　::clearerr;
　using　::fclose;
　using　::feof;
　using　::ferror;
　using　::fflush;
　using　::fgetc;
　using　::fgetpos;
　using　::fgets;
　using　::fopen;
　using　::fprintf;
　using　::fputc;
　using　::fputs;
　using　::fread;
　using　::freopen;
　using　::fscanf;
　using　::fseek;
　using　::fsetpos;
　using　::ftell;
　using　::fwrite;
　using　::getc;
　using　::getchar;
　using　::gets;
　using　::perror;
　using　::printf;
　using　::putc;
　using　::putchar;
　using　::puts;
　using　::remove;
　using　::rename;
　using　::rewind;
　using　::scanf;
　using　::setbuf;
　using　::setvbuf;
　using　::sprintf;
　using　::sscanf;
　using　::tmpfile;
　using　::tmpnam;
　using　::ungetc;
　using　::vfprintf;
　using　::vprintf;
　using　::vsprintf;
}
 
#if　_GLIBCXX_USE_C99
 
 
#undef　snprintf
#undef　vfscanf
#undef　vscanf
#undef　vsnprintf
#undef　vsscanf
 
namespace　__gnu_cxx
{
    
    
#if　_GLIBCXX_USE_C99_CHECK　||　_GLIBCXX_USE_C99_DYNAMIC
　
extern　"C"　int
　(snprintf)(char　*　
restrict,　
size_t,　
const　char　*　restrict,　...);
　extern　"C"　int
　(
vfscanf)(FILE　*　restrict,　const　char　*　restrict,　__gnuc_va_list);
　extern　"C"　int　(
vscanf)(const　char　*　
restrict,　__gnuc_va_list);
　
extern　"C"　int
　(vsnprintf)(char　*　restrict,　
size_t,　
const　char　*　restrict,　__gnuc_va_list);
　extern　"C"　int
　(
vsscanf)(const　char　*　restrict,　const　char　*　restrict,　__gnuc_va_list);
 
#endif
#if　!_GLIBCXX_USE_C99_DYNAMIC
　using　::snprintf;
　using　::
vfscanf;
　using　::
vscanf;
　using　::vsnprintf;
　using　::vsscanf;
#endif
}
 
 
namespace　std
{
    
    
　using　__gnu_cxx::
snprintf;
　using　__gnu_cxx::vfscanf;
　using　__gnu_cxx::vscanf;
　using　__gnu_cxx::vsnprintf;
　using　__gnu_cxx::
vsscanf;
}
 
#endif