Introducción a los archivos de encabezado de C++: archivos de encabezado <cstdio>

Introducción a los archivos de encabezado de C++: <cstdio>archivos de encabezado

<cstdio>archivo principal

Introducción

<cstdio>Es para <stdio.h>expresar el contenido en forma de un archivo de encabezado C++. <stdio.h>Es el archivo de encabezado en la biblioteca de funciones estándar de C, a saber: entrada y salida almacenadas en búfer estándar. Proporciona operaciones básicas de flujo de entrada y salida de texto (incluidas pantallas y archivos, etc.). Dado que el lenguaje C no proporciona palabras clave dedicadas a la entrada y salida de texto, esta biblioteca es la biblioteca de carga de programas en lenguaje C más común.

Nota: Hay una diferencia <cstdio>con <stdio.h>, no es el mismo archivo.

descripción general

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);
}

algún conocimiento

Biblioteca C++ para realizar operaciones de entrada/salida

Las operaciones de entrada y salida también se pueden implementar en C++ utilizando la biblioteca de entrada y salida estándar de C ( <cstdio>, en lenguaje C <stdio.h>). La biblioteca utiliza los llamados "flujos" para manipular dispositivos físicos como teclados, impresoras, terminales u otros tipos de archivos admitidos por el sistema. Una secuencia es una abstracción para interactuar con estos dispositivos físicos de manera uniforme. Todas las corrientes tienen propiedades similares independientemente de las características individuales de sus dispositivos físicos asociados.

Las secuencias <cstdio>operan en la biblioteca como punteros a objetos ARCHIVO. Un puntero a un objeto ARCHIVO representa de forma única una secuencia y se utiliza como parámetro en las operaciones que diseñan la secuencia.

Hay tres flujos estándar: stdin, stdout y stderr, que se crean automáticamente de forma pública para todos los programas que utilizan la biblioteca.

propiedades de la corriente

Las secuencias tienen propiedades que definen qué funciones se les pueden aplicar y cómo tratar la entrada o salida de datos de ellas. fopenLa mayoría de estas propiedades se definen en el momento en que la secuencia se asocia (abre) con el archivo mediante la función:

acceso de lectura/escritura

Especifica si las transmisiones tienen acceso de lectura o escritura (o ambos) a sus medios físicos asociados.

texto/binario

Se considera que una secuencia de texto representa una secuencia de líneas de texto, cada línea terminada por un carácter de nueva línea. Dependiendo del entorno operativo del programa, puede ocurrir alguna conversión de caracteres para adaptar algunos caracteres especiales a la particularidad del entorno del archivo de texto. Una secuencia binaria, por otro lado, es una secuencia de caracteres escritos o leídos en un medio físico sin ninguna conversión, que corresponde uno a uno a los caracteres leídos o escritos en la secuencia.

cache

Un caché es un bloque de memoria donde se acumulan datos antes de leerlos o escribirlos en un archivo o dispositivo asociado. Las transmisiones se pueden almacenar en búfer completo, en búfer de línea o sin búfer. Para secuencias con búfer completo, los datos se leen/escriben cuando la secuencia está llena, para secuencias con búfer de línea, cuando se encuentra un carácter de nueva línea y para secuencias sin búfer, los caracteres se leen/escriben inmediatamente.

orientación

Cuando se abre, la transmisión no está dirigida. Cuando se realizan operaciones de entrada/salida en ellos, se vuelven orientadas a bytes o a bytes amplios, según el operador aplicado (normalmente las funciones definidas en están orientadas a bytes, mientras que las funciones definidas en función están orientadas a bytes amplios).

indicador

Los flujos se utilizan para indicadores internos específicos que indican su estado actual y que afectan el comportamiento de las operaciones de entrada y salida en ellos:

indicador de error

Este indicador se establece cuando se produce un error en una operación relativa a la secuencia. El indicador puede ferrorser detectado por la función y se puede restablecer llamando a clearerr, freopeno .rewind

indicador de fin de archivo

Una vez configurado, indica que la siguiente operación de lectura o escritura en esta secuencia ha llegado al final del archivo. Puede ser detectado por la función y se puede restablecer feofllamando a clearerr, freopeno llamando a cualquiera de las funciones de reubicación ( rewindy fseek) .fsetpos

indicador de ubicación

Es un puntero interno para cada flujo que apunta al siguiente carácter para leer o escribir la siguiente operación de E/S. Su valor se puede obtener mediante ftellla función o fgetposy se puede cambiar utilizando la función de reubicación rewindy fseekla fsetposfunción.

función

Archivo de acción:

• removeeliminar archivo (función)

• renamecambiar el nombre del archivo (función)

• tmpfileabrir un archivo temporal (función)

• tmpnamgenerar un nombre de archivo temporal (función)

Acceso a archivos:

• fclosecerrar archivo (función)

• fflushflujo de descarga (función)

• fopenabrir archivo (función)

• freopenvolver a abrir la transmisión con un archivo o modo (función) diferente

• setbufestablecer caché de transmisión (función)

• servbufcambiar el buffer de flujo (función)

Entrada/salida formateada:

fprintfescribir datos formateados para transmitir (función)

• fscanfLeer datos formateados de una secuencia (función)

• printfimprimir datos formateados en stdout(función)

• scanfstdinleer datos formateados de (función)

• snprintfEscribir datos formateados en un búfer de longitud fija (función)

• sprintfescribir datos formateados en una cadena (función)

• sscanfLeer datos formateados de una cadena (función)

• vfprintfEscribe datos formateados de la lista variada en la secuencia (función)

• vfscanfLeer datos formateados de la secuencia en la lista de argumentos variables (función)

• vprintfimprimir los datos formateados en la lista variada a stdout(función)

• vscanfLeer datos formateados en la lista de argumentos variables (función)

• vsnprintfEscriba los datos formateados en la lista de parámetros variables en el búfer de longitud fija (función)

• vsprintfEscriba los datos formateados en la lista variada en una cadena (función)

• vsscanfLeer datos formateados de una cadena en una lista variada (función)

Entrada/salida de cadena:

• fgetcObtener un personaje de una secuencia (función)

• fgetsObtener una cadena de una secuencia (función)

• fputcescribir caracteres en una secuencia (función)

• fputsescribe una cadena en una secuencia (función)

• getcObtener un personaje de una secuencia (función)

• getcharstdinobtener carácter de (función)

• getsstdinobtener cadena de (función)

• putcescribir caracteres en una secuencia (función)

• putcharescribir carácter stdout(función)

• putsescribir cadena en stdout(función)

• ungetcno obtiene un carácter de una secuencia (función)

Entrada/salida directa:

• freadLeer fragmentos de datos de una secuencia (función)

• fwriteescribir un fragmento de datos en una secuencia (función)

Ubicación del archivo:

• fgetposobtener la posición actual de la secuencia (función)

• fseekIndicador de posición del flujo de reposición (función)

• fsetposestablecer indicador de posición de flujo (función)

• ftellObtener la posición actual de la transmisión (función)

• rewindEstablecer la posición de la transmisión para iniciar (función)

Manejo de errores:

• clearerrindicador de error claro (función)

• feofcomprobar el indicador de fin de archivo (función)

• ferrorcomprobar indicador de error (función)

• perrorimprimir mensaje de error (función)

macro

• BUFSIZEtamaño del buffer (constante)

• EOFfin de archivo (constante)

• FILENAME_MAXLa longitud máxima del nombre de archivo (constante)

• FOPEN_MAXLímite potencial de flujos abiertos continuamente (constante)

• L_tmpnamLongitud mínima de nombres de archivos temporales (constante)

• NULLnullpuntero (macro)

• TMP_MAXNúmero de archivos temporales (constante)

• También: _IOFBF, _IOLBF, _IONBF(usado en setvbuf)

• SEEK_CUR, SEEK_ENDy SEEK_SET(usado en fseek).

tipo

• FILEobjeto (tipo) que contiene información sobre el flujo de control

• fpos_tobjeto (tipo) que contiene información en la ubicación especificada en el archivo

• size_ttipo entero sin signo (tipo)

contenido

//　-*-　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