Usar um datatype novo chamado um ponteiro de lima com às limas de C. Este tipo é escrito como a LIMA *, e definido dentro de stdio.h. Um ponteiro de lima chamado output_file é declarado em uma indicação é como segue:

FILE *output_file;

Function Name	Operation
fopen()	Creates a new file for use Opens a new existing file for use
fclose	Closes a file which has been opened for use
getc()	Reads a character from
putc()	Writes a character to a file
fprintf()	Writes a set of data values to a file
fscanf()	Reads a set of data values from a file
getw()	Reads a integer from a file
putw()	Writes an integer to the file
fseek()	Sets the position to a desired point in the file
ftell()	Gives the current position in the file
rewind()	Sets the position to the begining of the file

Abrindo usar-se do ponteiro de lima fopen ()

Para abrir córregos, fopen () é usado. Para a abertura arquiva para a entrada, esta é o mais usado frequentemente. Antes que possa a alcançar, seu programa deve abrir uma lima. Esta função retorna o ponteiro de lima requerido. O ZERO do valor estará retornado, se a lima não puder ser aberta para nenhuma razão. o protótipo dos fopen é como segue:

FILE *fopen (const char *path, const char *mode);

fopen recolhe o trajeto à lima as well as a modalidade e para abrir a lima com. Fazer exame para o seguinte exemplo:

iFILE *Fp; Fp = fopen("/home/johndoe/input.dat", "r");

Para a leitura, isto abrirá a lima em /home/johndoe/input.dat. Você usar-se-á geralmente fopen como dado abaixo:

if ((output_file = fopen("output_file", "w")) == NULL)
fprintf(stderr, "Cannot open %s\n", "output_file");

fopen tomadas dois argumentos, ambos são cordas, o primeiro é o nome da lima a ser aberta, o segundo é um caráter do acesso, que seja geralmente um do seguinte:

abrir de “r” - a lima para a leitura
abrir de “a” - a lima para adicionar
abrir de “w” - a lima para a escrita
“w+” - abrir para a escrita e a leitura (a lima existente overwritten)
“r+” - abrir para a leitura e atualizar (a lima deve já existir)
“a+” - abrir para a adição e a leitura (a lima pode ou não pode existir)

Os seguintes fragmentis do código usaram-se começar o texto do primeiro elemento do <title>:

FILE *output_file;

Fechando um ponteiro de lima usando o fclose ()

Você usaria o fclose () fechar o córrego. O protótipo para o fclose é dado abaixo:

int fclose( FILE *stream );

I/O da lima:: fgets ()

As alternativas a scanf/fscanf são fgets. O protótipo é como segue:

char *fgets(char *s, int size, FILE *stream);

os fgets armazenam-na no ponteiro dos *s e lêem-nos dentro o tamanho - caráteres 1 do córrego. A corda sempre nulo-é terminada automaticamente. Se alcançar um EOF ou um newline, os fgets param de ler nos caráteres.

I/O da lima:: sscanf ()

A chamada da biblioteca do sscanf é acessível fazer a varredura de uma corda para um formato. O protótipo é como segue:

int sscanf(const char *str, const char *format, ...);

o sscanf faz exame de um ponteiro do caráter em vez de um ponteiro de lima e trabalha bem como o fscanf. Em vez de scanf/fscanf, usando a combinação de fgets/sscanf você pode evitar o problema da “digestão” (ou o erro, dependendo de quem você fala:)

I/O da lima:: fprintf ()

É às vezes útil também output aos córregos diferentes.

o fprintf () permite que nós façam exatamente a mesma coisa

O protótipo para o fprintf é como segue:

int fprintf(FILE *stream, const char *format, ...);

o fprintf recolhe um ponteiro especial chamado um ponteiro de lima, significado pela LIMA *. Aceita então o argumento e uma corda do formato e. A única diferença entre o printf e o fprintf é que o fprintf pode dirigir de novo a saída a um córrego particular. Estes córregos podem ser stderr, stdout, ou um ponteiro de lima. Mais nos ponteiros de lima quando nós começamos fopen. Um exemplo é dado abaixo:

fprintf(stderr, "ERROR: Cannot malloc enough memory.\n");

Esta saída a mensagem de erro ao erro padrão.

I/O da lima:: fscanf ()

o fscanf () é bàsicamente uma versão dos córregos do scanf. O protótipo para o fscanf é como segue:

int fscanf( FILE *stream, const char *format, ...);

I/O da lima:: fflush ()

Se o programa deixar de funcionar, o córrego não está escrito às vezes. Você pode fazer este usando a função do fflush (). Sometime é necessário nivelar forcefully um amortecedor a seu córrego. O protótipo para o fflush é como segue:

int fflush(FILE *stream);

Não muito difícil de usar-se, especificar o córrego ao fflush.

O programa que é dado abaixo do uso das exposições de operações de uma lima. O o programa escreve-o e os dados entram através do teclado. Caráter pelo caráter, para arquivar a entrada. O fim dos dados é indicado incorporando um caráter do EOF, que seja controle-z. a entrada da lima é closed neste sinal somente.

#include< stdio.h >

main()
{
file *f1;
printf("Data input output");
f1=fopen(Input,w); /*Open the file Input*/
while((c=getchar())!=EOF) /*get a character from key board*/
putc(c,f1); /*write a character to input*/
fclose(f1); /*close the file input*/
printf("\nData output\n");
f1=fopen(INPUT,r); /*Reopen the file input*/
while((c=getc(f1))!=EOF)
printf("%c",c);
fclose(f1);
}

Keywords: perl functions, c tutorial, php functions, c array, c time, c programs, c examples, c language, c library, c dll, unix c, c program, c example, standard c, array functions, file open, variable functions, unix file, functions tutorial, functions examples, file read, file write, simple c, sample c, variable c, functions example

HTML Quizes

XML Quizes