int fgetc (el archivo * Stream)
int del fputc (int CH, el archivo * Corriente)
de función fgetc () devuelve un carácter de la posición actual del flujo de entrada, y el archivo puntero al siguiente puntero de carácter al final del archivo si, la función devuelve EOF, en este momento representa el final de esta operación, cuando la finalización de la lectura y escritura de archivos, el archivo debe ser cerrado.
de fputc () función escribe un valor en la terminación del archivo de flujo de caracteres ch especificado por la posición actual y el puntero del archivo después de un movimiento. de fputc () Valor de retorno de la función es el valor de los caracteres escritos, regresa EOF error.
el int fscanf (Corriente del archivo *, char * formato, arg_list)
int fprintf (Corriente del archivo *, char * formato, arg_list)
formato de archivo es leído por una letra que corresponda a la función antes descrita f se convierte en el fscanf () y fprintf ( )
en el que, puntero archivo de flujo para la corriente, y los dos parámetros restantes scanf () y printf () utilizar el mismo.
char * fgets (char * str, int num, FILE * stream) // fila de datos de lectura sensación
fputs int (char * STR, el archivo * stream)
la función fgets () lee la corriente desde el archivo de flujo en al mayoría de los personajes num-1. y ponerlos en los puntos array de caracteres de str. Lee los caracteres encontrados hasta el retorno de carro o EOF (final del archivo) hasta que el, o leer el carácter definido.
fputs () función escribe el archivo de flujo str puntas cadena. Cuando la operación tiene éxito, la función devuelve 0, si no devuelven un valor distinto de cero.
int fread (void * buf, int size, int cuenta, el archivo * stream)
int fwrite (void * buf, int size, int cuenta, el flujo FILE *)
función fread () lee a partir del recuento secuencia de archivo chorro directo (el número de campos ) campos, cada uno del tamaño de campo (longitud del campo) caracteres de longitud, y los pusieron BUF (cadena de caracteres apuntada por tampón).
devuelve la función fread () el número de campos en realidad leer. Si el número requerido de llamadas de función para leer campo excede el número de campos almacenados en el archivo, un error o al final del archivo, la detección debe tenerse en cuenta que la operación real.
la función fwrite del array de caracteres buf (tampón) (puntos) en la cuenta (número de campos) Campos escrito flujo de corriente en punta, cada campo de caracteres de tamaño largo, la función devuelve un éxito de los campos de operación cuando se escribe número.
Acerca de lectura y escritura de archivos en bloques, sólo se puede crear formato de archivo binario al crear el archivo.
Por lo general, para el formato más complejo de los datos de entrada, podemos tomar como entrada de la cadena de datos en varios formatos, y luego convierte la cadena en el formato deseado. C proporciona la función:
int atoi (char * PTR)
un flotador del atof (char * PTR)
long int atol (char * PTR)
convertir respectivamente la cadena a entero, real y entero largo. Utilice el archivo de cabecera math.h que contenga o stdlib.h escrito antes del programa.
#include "stdafx.h"
#include <stdio.h>
// serán almacenados en el disco para leer y escribir archivos en los caracteres de texto especificados uno por uno, para leer desde el archivo, y luego mostrarlo en la pantalla.
int main (int argc, char * argv [])
{
Char CH;
el archivo * FP;
int I;
IF ((FP = el fopen (argv [. 1], "R & lt")) == NULL) / * abierto una por el argv [1] en referencia al archivo * /
{
printf ( "No se abra");
return 0;
}
el tiempo (! (CH = fgetc (FP)) = EOF) / * un personaje lee desde el archivo, a la pantalla * / {
putchar (CH); // Si imprime el mismo printf tiempo ( "(% d)" , ch); putchar chino no se puede mostrar correctamente
}
fclose (fp);
printf ( "el Hello World \ el n-!");
return 0;
}
#include "stdafx.h"
#include <stdio.h>
#include <string.h>
// cadena de escritura en el disco, y escribe un archivo de texto test.txt:
int main (int argc, char * argv [] )
{
el archivo * FP;
STR char [128];
IF ((FP = el fopen ( "test.txt", "W")) == NULL)
{
el printf ( "No abierto");
return 0;
}
el tiempo (( ! strlen (gets (str)) ) = 0) / * Si la longitud de la cuerda es igual a cero, entonces el fin * /
{
fputs (STR, FP); / * escribir una cadena * /
fputs ( "\ n", FP); / * escribir un retorno de carro * /
}
fclose (FP);
printf ( "Hola Mundo \ n");
return 0;
}
# include "el stdafx.h"
#include <stdio.h>
// algunos escritura de datos con formato de archivo de texto, y de la cual archivo a leer método de formateo que se muestran en la pantalla,
// datos con formato dos registros de los estudiantes, incluyendo el nombre, número de estudiante, dos resultados sujetos.
int main (int argc, char * el argv [])
{
el archivo * FP;
int I;
struct STU {/ * Definición del tipo de estructura * /
char nombre [15];
Char NUM [. 6];
un flotador Nota [2];
} estudiante; las variables / * Descripción de la estructura * /
if ((PF = el fopen ( "test.txt", "W")) == NULL) / * abrir un archivo de texto sólo por escrito * /
{
printf ( "no puede abrir archivo ");
return 0;
}
la printf (" entrada de datos: \ n- ");
for (i = 0; I <2; i ++)
{
Scanf (" % S% F% F% S", student.name, Estudiante. num,
Y student.score [1]); / * entrada de teclado * /
fprintf (FP, "% S% S% 7.2F% 7.2F \ n-", student.name, student.num,
student.score [0],
Student .score [1]); archivos / escritura * * /
}
fclose (FP); / * Cerrar el archivo * /
if ((PF = el fopen ( "test.txt", "R ^")) == NULL) / * sólo lectura vuelva a abrir el archivo de texto * /
{
printf ( "No se puede abrir el archivo");
return 0;
}
printf ( "salida de archivo: \ n");
// la función de escaneado fscanf solamente se fija formato de exploración, Ya sea envoltura no se ajusta. Si una línea única escanear se escanea entonces mitad de los datos de nuevo por debajo
mientras que (fscanf (fp, "% s% s% f% f \ n", student.name, student.num, y student.score [0], y student.score [1])! = EOF) / * leer el archivo * / {
printf ( "% s% s% 7.2F% 7.2F \ n", student.name, student.num, student.score [0], student.score [1]); / * visualización a la pantalla * /
}
fclose ( fp); / * archivo de cierre * /
printf ( "Hola Mundo \ n- el!");
return 0;
}
#include "la stdafx.h"
int main (int argc, char * el argv [])
{
el archivo * FP1;
int I;
struct STU {/ * Definición de la estructura * /
char nombre [15];
Char NUM [. 6];
un flotador Resultado [2];
} Estudiante;
SI ((FP1 = el fopen ( "test.txt", "WB")) == NULL) / * por escrito binaria única columna abierta * /
{
printf ( "No se puede abrir el archivo") ;
return 0;
}
la printf ( "entrada de datos: \ n-");
for (i = 0; I <2; i ++)
{
Scanf ( "% S% F% F% S", student.name, student.num, y student.score [0], y student.score [1]); / * entrada de un registro * /
fwrite (& Student, el sizeof (Student) ,. 1, FP1);/ * Bloque se escribe en el archivo * /
}
fclose (FP1);
if ((FP1 = fopen ( " test.txt", "rb")) == NULL) / * escribir sólo para volver a abrir el archivo en binario * /
{
printf ( "No se puede abrir el archivo");
return 0;
}
printf ( " la salida de archivo: \ n- ");
for (i = 0; I <2; i ++)
{
fread (& Student, el sizeof (Student) ,. 1, FP1); / * bloque leído desde el archivo a un * /
el printf (" % S % s% 7.2F% 7.2F \ n ", student.name, student.num, student.score [0], student.score [1]); / * visualización a la pantalla * /
}
fclose (FP1);
el printf ( ) "el Hello World \ n- el!";
return 0;
}
Otro ejemplo de la vida y la muerte no es, aconsejar por favor:
#include "stdafx.h"
#include <stdio.h>
#include <string.h>
// cadena de escritura en el disco, y escribe un archivo de texto test.txt:
int main (int argc, char * argv [] )
{
el archivo * FP1, FP2 *;
Char STR [128];
. IF ((FP1 = el fopen ( "el test1.txt", "R & lt")) == NULL) / * de sólo lectura archivos * 1 /
{
printf ( "archivo no se puede abrir \ n");
return 0;
}
if ((FP2 = el fopen ( "es test2.txt", "W")) == NULL) archivo / * abierta para sólo escritura * 2 /
{
printf ( "el archivo no se puede abrir \ n");
return 0;
}
el tiempo ((strlen (fgets (STR, 128, FP1)))> 0)
{
fputs (STR, FP2);/ * Leer la cadena desde el archivo y escribe el archivo 1 * 2 /
printf ( "% S", STR); / * en la pantalla * /
}
fclose (FP1);
fclose (FP2);
}
