Curso de Linguagem C aplicada á Engenharia (DOC)
34 pág.

Curso de Linguagem C aplicada á Engenharia (DOC)


DisciplinaLinguagem e Estruturação Linguagem C130 materiais933 seguidores
Pré-visualização34 páginas
< tmp.c */

#include<string.h> /* strstr() necessita */

#include<stdio.h>

main(int argc, char *argv[])

{

char string[128];

int line=0;

while(fgets(string, sizeof(string),stdin))

{

++line;

if(strstr(string, argv[1])) printf(&quot;%02d %s&quot;,line,string);

}

}

O fluxo stderr é usado para mostrar mensagens de erro na tela, quando a saída do programa esta redirecionada p/ outro dispositivo que nao seja a tela:

#include <stdio.h>

main(int argc, char *argv[])

{

FILE *fp;

int count;

char letter;

if(argc!=2){puts(&quot;Digite o nome do arquivo!&quot;);exit(1);}

if(!(fp = fopen(argv[1],&quot;w&quot;))){

	 fputs(&quot;Erro na abertura do arquivo&quot;,stderr);

 /* 2ª opçao: puts(&quot;Erro na abertura do arquivo&quot;); -> vai p/ stdout,isto é,

 tela ou outro dispositivo */

	 exit(1);

			 }

else for(letter='A';letter<='Z'; letter++) putc(letter, fp);

fclose(fp);

}

Se a saída deste programa (stdout) for redirecionada para algum outro arquivo, a mensagem de erro forçosamente aparecerá na tela porque estamos escrevendo em stderr.

fprintf() e fscanf():

Comportam-se como printf() e scanf() só que escrevem e lêem de arquivos de disco. Todos os códigos de formato e modificadores sao os mesmos.

Protótipo:

int fprintf(FILE *fp, char *string_de_controle, lista_de_argumentos);

int fscanf(FILE *fp, char *string_de_controle, lista_de_argumentos);

Header: stdio.h

Embora fprintf() e fscanf() sejam a maneira mais fácil de ler e escrever tipos de dados nos mais diversos formatos, elas nao sao as mais eficientes em termos de tamanho de código resultante e velocidade. Quando o formato de leitura e escrita for de importância secundária, deve-se dar preferência a fread() e fwrite().

/* imprime os quadrados de 0 a 10 no arquivo quad.dat no formato

número - quadrado */

#include<stdio.h>

#include<stdlib.h>

main()

{

int i;

FILE *out;

if((out=fopen(&quot;quad.dat&quot;,&quot;wt&quot;))==NULL){ /* sempre texto c/ fscanf() e fprintf() */

puts(&quot;Nao posso abrir arquivo!&quot;);

exit(1); }

for (i=0; i<=10; i++){

fprintf(out,&quot;%d %d\n&quot;, i , i*i);

		 }

fclose(out);

}

Deixaremos o exemplo de uso de fscanf() para o próximo capítulo (Alocaçao Dinâmica).

Apagando arquivos: remove()

int remove(char *nome_arquivo);

Retorna zero em caso de successo e nao zero se falhar.

9) Alocaçao dinâmica da memória:

Existem três funçoes básicas de gerenciamento dinâmico da memória:

malloc() 	aloca determinado tamanho de memória

free() 	libera a memória alocada por malloc() p/ ser reutilizada

realloc() 	encolhe ou expande o bloco de memória alocado por malloc(), se necessário move-o para caber no espaço disponível

Protótipos: (header em stdlid.h)

void *malloc (unsigned numbytes);

malloc() retorna um ponteiro void, isto é, ele pode apontar p/ o que se desejar: uma matriz, estrutura, número. numbytes() normalmente é calculado por sizeof(). Se nao houver memória suficiente retorna um ponteiro nulo.

void free(void *p);

free() libera a memória alocada a partir do ponteiro gerado por malloc(). NUNCA use free() p/ liberar o bloco de memória apontada por um ponteiro que nao tenha sido gearado por malloc(), ou a memória usada será perdida.

void *realloc(void *p, unsigned tamanho);

realloc() altera o tamanho da memória alocada por p para o tamanho especificado por 'tamanho'. Se nao houver memória suficiente retorna um ponteiro nulo e libera (executa free()) o bloco original.

/* lê um arquivo numérico de nome a especificar no formato de 2 colunas */

#include<dos.h>

#include<stdio.h>

#include<stdlib.h>

#include<ctype.h>

#include<math.h>

#include<conio.h>

#include<alloc.h>

main(argc,argv)

int argc;

char *argv[];

{

FILE *in;

float *x, *y;

float tempx, tempy;

int i, teste,numlido;

if(argc!=2){puts(&quot;Digite o nome do arquivo!&quot;);exit(1);}

if((in=fopen(argv[1],&quot;rt&quot;))==NULL){ /* sempre texto c/ fscanf() e fprintf() */

puts(&quot;Nao posso abrir arquivo!&quot;);

exit(1); }

x=(float*)malloc(sizeof(float));

if(!x){LBLMEM:puts(&quot;Memória insuficiente!&quot;);exit(1);}

y=(float*)malloc(sizeof(float));

if(!y){goto LBLMEM;}

i=0;

while(1){

teste=fscanf(in,&quot;%f%f&quot;,&tempx,&tempy);

if(teste==-1)break; /* testa EOF: fscanf() retorna -1 quando encontra-o */

*(x+i)=tempx; /* para fugir de erro de linkagem do compilador - BUG da versao 1.0 do Turbo C++ */

*(y+i)=tempy;

i++;

x=realloc(x,((unsigned)(i+1))*sizeof(float));

if(!x){LBLALOC:puts(&quot;Erro de alocaçao!&quot;);exit(1);}

y=realloc(y,((unsigned)(i+1))*sizeof(float));

if(!y){goto LBLALOC;}

	}

fclose(in);

numlido=i-1;

for(i=0;i<=numlido;i++)printf(&quot;%f %f\n&quot;,*(x+i),*(y+i));

}

10) Estruturas:

 Em C, uma estrutura é uma coleçao de variáveis referenciada sob um nome, provendo um meio de manter informaçoes relacionadas juntas. Uma declaraçao de estrutura permite que se se crie variáveis de estruturas. As variáveis que compreendem uma estrutura sao chamadas de elementos da estrutura:

struct endereco {

char nome[30];

char rua[40];

char cidade[20];

char estado[3];

unsigned long int cep;

		};

Obs1) O nome \u201cendereco\u201d é chamada etiqueta da estrutura

Obs2) Até aqui nao foi alocada nenhuma memória

struct endereco info_adr;

/* declara a variável info_adr como sendo do tipo estrutura endereco */

/* somente agora é alocada memória */

Outra maneira, alocando memória já na declaraçao da estrutura:

struct endereco {

char nome[30];

char rua[40];

char cidade[20];

char estado[3];

unsigned long int cep;

		}info_adr, binfo, cinfo;

/*Isto definirá um tipo de estrutura chamada endereco e declarará as variáveis

info_adr, binfo, cinfo como sendo deste tipo.*/

 Se você necessita somente de uma variável de um determinado tipo, a etiqueta

nao é necessária:

struct {

char nome[30];

char rua[40];

char cidade[20];

char estado[3];

unsigned long int cep;

		}info_adr;

/* declara uma variável chamada info_adr como definida pela estrutura que a

precedeu */

A forma geral de uma declaraçao de estrutura é:

 struct nome_do_tipo_da_estrutura {

tipo nome_de_elemento_1;

tipo nome_de_elemento_2;

tipo nome_de_elemento_3;

	.

	.

	.

tipo nome_de_elemento_N;

				 }variáveis_estrutrura;

onde o nome do tipo da estrutura (etiqueta) ou as variáveis da estrutura pode ser omitido, mas nao os dois.

Referenciando os membros da estrutura: operador ponto

nome_da_variável_estrutura.nome_do_elemento

Exemplo:

info_adr.cep=91720260; /* atribui */

printf(&quot;%lu&quot;, info_adr.cep); /* imprime cep na tela */

printf(&quot;%s&quot;,info_adr.nome); /* imprime nome */

for(t=0;info_adr.nome[t];++t)putchar(info_adr.nome[t]); /* ídem caracter por caractere */

Matrizes de estruturas:

struct endereco info_adr[100]; /* cria 100 conjuntos de variáveis que sao */

			 /* organizadas como definido na estrutura */

			 /* endereco */

printf(&quot;%lu&quot;, info_adr[2].cep); /* imprime na tela o cep da estrutura 3 da */

				/* matriz de 100 estruturas */

 Matrizes de estruturas sao muito comuns em planilhas de cálculo tipo Lotus,

em que se armazena uma grande quantidade de dados encadeados.