Princípios de programação em Linguagem C Cesar Tadeu Pozzer UFSM 16/08/2010

Princípios de programação em Linguagem C Cesar Tadeu Pozzer UFSM 16/08/2010 Introdução a Programação em Linguagem C Antes de um algoritmo ser executado no computador, ele deve ser traduzido em uma linguagem que o computador possa compreender. Para isso existem os compiladores, que varrem o algoritmo, verificam a existência de erros e o convertem na notação da máquina sendo usada. O código executável de um programa para PC não é igual ao código do mesmo programa para Mac, por exemplo. Neste curso será estudada a linguagem C [2][3] e o compilador usado será o Microsoft Visual C++ para plataforma Windows. Outra forma de executar programas é com o uso de interpretadores, como no caso da linguagem Lua, Javascript, etc. Interpretadores são frequentemente utilizados para fazer processamento de linguagens de script, como no caso engines de jogos e aplicativos gráficos, como o 3D Studio, dentre outros. Para transformar um algoritmo em C, várias adaptações devem ser feitas. C, como qualquer outra linguagem, tem um nível de formalismo muito maior que um algoritmo. Em C, as variáveis devem ter um tipo específico. Por exemplo: Tipo Descrição do tipo int Usado para armazenar números inteiros. Ex: 30, -10, 1001 float Usado para armazenar números reais. Ex: 12.1, 0.003, 1000 char Usado para armazenar caracteres. Ex: a, M Em vez de usar Inicio e Fim, deve-se usar os caracteres para definição de blocos de dados ou funções. A linguagem C define um grande número de bibliotecas de funções. Algumas delas são: Nome da biblioteca math.h stdio.h string.h O que contém Funções matemáticas, como seno, cosseno, etc. Funções de leitura e impressão de dados Funções de manipulação de texto A existência destas funções reduz o tempo de criação de uma aplicação, e tornam o código mais compacto e legível. Cabe ressaltar que não existem funções complexas como por exemplo tomar água ou trocar uma lâmpada. No próximo capítulo a linguagem C será estudada em maior profundidade. A Linguagem C A linguagem C nasceu na década de 70, por Dennis Ritchie. O C é derivado de uma outra linguagem: o B, criado por Ken Thompson. O B, por sua vez, veio da linguagem BCPL, inventada por Martin Richards. Uma boa referência da linguagem por ser vista em [1]. Estrutura de um programa C Todo programa escrito em C é composto por funções. Uma função é um bloco de programa onde são descritas as operações que devem ser realizadas. Existe uma única função que deve estar presente em todos os programas, que é a função main( ), e é o ponto de partida de execução do programa. A sintaxe de uma função é a seguinte:

tipo_retorno nome_função( parametros ) O seguinte exemplo mostra a sintaxe de um programa simples, que somente imprime na tela o valor de uma expressão aritmética. Linha Comando C 1 #include <stdio.h> 2 int main( void ) 3 4 int dado1, dado2, resp; 5 dado1 = 20; 6 scanf( %d, &dado2 ); 7 /*Isto é um comentário*/ 8 resp = dado1*dado2; 9 printf( O valor da expressão é %d, resp); 10 return 0; 11 Na linha 1, a diretiva de compilação #include faz o compilador adicionar o arquivo stdio.h ao código do programa. Este arquivo adicionado contém protótipos de várias funções de entrada e saída. A inclusão é necessária pois na linha 6 é chamada a função scanf( ), que faz a leitura do teclado de um número inteiro e atribui a variável dado2; e na linha 9 é chamada a função printf( ), que faz a impressão do valor da expressão, calculada na linha 8, na tela do computador. Na linha 2 está declarada a função main( ). Para este exemplo, a função deve retornar um valor inteiro (int) e não recebe nenhum parâmetro (void). O corpo da função main é delimitado pelo bloco, que tem início na linha 4 e termina na linha 10. Qualquer código fora deste bloco não irá pertencer a função main( ). O uso de variáveis é necessário para fazer a manipulação dos dados do programa. Na linha 4 são declaradas 3 variáveis do tipo inteiro (variáveis que somente podem armazenar valores inteiros). A variável chamada dado1 é inicializada na linha seguinte com o valor 20. A variável dado2 é lida do teclado pela chamada da função scanf( ). O programa somente segue a execução para o próximo comando quando o usuário digitar algum valor e pressionar a tecla <Enter>. Na linha 7 é adicionado um comentário ao programa, que será ignorado pelo compilador na geração do código executável. Comentários são de grande importância na documentação do código fonte. Na linha 8 é avaliada uma expressão de multiplicação, que consiste em armazenar na variável resp o valor da multiplicação da variável dado1 com dado2. O valor da expressão é mostrado na tela pela chamada da função printf( ). Ao final, o programa retorna o valor 0 ao sistema operacional, indicando que a finalização do programa ocorreu de forma correta. Um programa pode ter qualquer número de funções. O uso de funções é uma boa forma de estruturação do programa e facilita a reutilização de código. Variáveis declaradas dentro de uma função somente são visíveis somente dentro da própria função. Variáveis podem ter qualquer nome, desde que iniciem com letras, como por exemplo: a, dado, v_13df, teste, tmp, etc. Não são permitidos caracteres especiais como -, +, *, etc, bem como acentuação. Aconselha-se dar nomes significativos as variáveis, pois tornam o código fonte mais legível, como por exemplo: media, temp, opcao, resp, etc. Observa-se que comandos e declarações de variáveis são terminadas com ponto-e-vírgula. Caso algum ; for esquecido (erro de sintaxe), será gerada uma mensagem de erro pelo compilador indicando a linha onde o erro ocorreu. Outra observação é que o C é "Case Sensitive", isto é, maiúsculas e minúsculas fazem diferença. Se for declarada uma variável com o nome soma ela será diferente de Soma, SOMA, SoMa ou soma. Da mesma maneira, os comandos do C if e for, por exemplo, só podem ser escritos em minúsculas pois senão o compilador não irá interpretá-los como sendo comandos, mas sim como variáveis. Este mesmo programa poderia ser escrito de forma mais estruturada, colocando a operação de multiplicação em uma função específica.

1 #include <stdio.h> 2 3 int produto(int n1, int n2); 4 5 int produto(int n1, int n2) 6 7 int resp; 8 resp = n1 * n2; 9 return resp; 10 11 12 int main( void ) 13 14 int dado1, dado2, resp; 15 dado1 = 20; 16 scanf( %d, &dado2 ); 17 /*chamada da funcao produto passando dado1 e dado2*/ 18 resp = produto(dado1, dado2); 19 printf( O valor da expressão é %d, resp); 20 return 0; 21 Neste exemplo, foi criada a função multiplica, que recebe dois parâmetros inteiros e retorna outro inteiro, representando o produto de n1 com n2. Esta função é chamada de dentro da função main( ), na linha 18. Quando a função é chamada, a execução do programa sai da função main e vai para a função produto e a variável dado1 é copiada na variável n1 e a variável dado2 é copiada na variável n2. Quando a função produto retorna (linha 9), o valor de retorno é atribuído a variável resp na linha 18. Cabe lembrar que as variáveis resp são locais à função onde foram declaradas, logo a variável resp da função produto( ) não é a mesma da função main( ). Quando a função produto( ) retorna, a execução continua na função main( ). Na linha 3 é declarado o protótipo da função produto( ), que é usada para indicar ao compilador da existência da função produto. A declaração do protótipo é obrigatória caso a função seja chamada antes de sua declaração, o que não ocorre neste exemplo. 3 Tipo de Dados 3.1 Tipos básicos A linguagem C oferece vários tipos básicos para definição de valores do tipo caractere, inteiro e de ponto flutuante. Deve-se usar o tipo mais adequado ao dado que se deseja representar. A tabela a seguir ilustra os tipos, com respectivos tamanhos e representatividades.

Tabela de tipos básicos Tipo Espaço ocupado Representatividade char 1 byte -128 a 127 unsigned char 1 byte 0 a 255 short int 2 bytes -32 768 a 32 767 unsigned short int 2 bytes 0 a 65 535 int 4 bytes -2 147 483 648 a 2 147 483 647 unsigned int 4 bytes 0 a 4 294 967295 float 4 bytes ± 10-38 a 10 38 double 8 bytes ± 10-308 a 10 308 A declaração de variáveis segue o mesmo modelo dos exemplos anteriores. A inicialização pode ocorrer juntamente com a declaração da variável. Variável não inicializada leva a erros na execução do programa. float a, b, c=10.4; char nome = 20, letra= m ; unsigned char byte; Deve-se ter os seguintes cuidados no uso de variáveis: -Deve-se garantir que não será atribuído valor superior ao da representatividade de cada tipo, o que pode levar ao truncamento e alteração da informação armazenada; -A conversão de números inteiros para flutuantes ocorre de forma automática e sem perda, porém o contrário não; -Variáveis não inicializadas contém lixo. int a, b, c; a = 2; c = a + b; /*b não foi inicializada e contém lixo*/ De forma complementar a definição de variáveis, pode-se também definir strings que serão substituídas pelos seus identificadores toda vez que encontrados no código fonte. Isso é feito pela diretiva #define. No seguinte exemplo, o identificador é o MAX_JOGADORES, e a string correspondente é 5. #define MAX_JOGADORES 5... /* antes de ser compilada, esta linha será transformada em if (cont<5)*/ if ( cont < MAX_JOGADORES ) /* comandos */ Este recurso deixa o código mais legível e é uma técnica muito usada em jogos. #define POWERUP_TYPE_HULL 1 #define POWERUP_TYPE_SHIELD 2 #define POWERUP_TYPE_QUAD 3 #define POWERUP_TYPE_INVISIBLE 4 #define POWERUP_TYPE_INVENSIBLE 5

Além dos tipos básicos, também existem os tipos estruturados, que permitem a definição de dados mais complexos. 3.2 Vetores e Strings Uma forma simples de implementar tipos de dados mais complexos é por meio de vetores. Eles permitem que conjuntos de dados do mesmo tipo sejam definidos por uma única variável, como no seguinte exemplo. float vet[5] = 1.2, 0.09, 34, 1.01, 50000; int tabela[2]; tabela[0] = 1000; tabela[1] = 88; Neste exemplo, vet é um vetor com 5 posições para números do tipo float. A inicialização de vetores também pode ocorrer juntamente com a declaração. Em C, a primeira posição do vetor é a de índice 0 e a última é a de índice N-1, como mostrado na inicialização do vetor de inteiros tabela. A atribuição tabela[2] = 90 causa invasão de memória pois a posição de índice 2 não está definida. Deve-se observar que o tamanho dos vetores é definido em tempo de compilação, ou seja, o compilador irá reservar espaço suficiente na memória para comportar os vetores vet e tabela. Caso não se saiba de antemão o espaço que será necessário para armazenar os dados, como por exemplo o número de jogadores que estarão conectados ao servidor, deve-se então usar uma estratégia de alocação de memória em tempo de execução (alocação dinâmica). Em C, isso pode ser feito com o uso de ponteiros, que são variáveis cujo conteúdo é um endereço de memória. Para o exemplo acima, a versão com alocação dinâmica se torna: float *vet; /* vet é um ponteiro para float */ int *tabela; /* tabela é um ponteiro para int */ vet = (float*)malloc(5*sizeof(float)); tabela = (int*) malloc(2*sizeof(int)); tabela[0] = 1000; tabela[1] = 88; Em termos de sintaxe, a diferença entre um ponteiro e uma variável normal é a presença do asterisco antes do nome da variável. O operador sizeof( tipo ) retorna o número de bytes ocupado pelo tipo (ver tabela de tipos básicos). A função malloc( size ) aloca size bytes e retorna o endereço inicial da região alocada. Este endereço retornado é atribuído ao ponteiro que passa a apontar para a região alocada. Ponteiros, além de apontar para regiões de memória alocadas, podem também apontar para outras variáveis, e são de grande importância na passagem de parâmetros por referência. float *pont; /*declara um ponteiro para float */ float var = 30; /*declara uma variável com o valor de 30.0 */ pont = &var; /*faz pont apontar para o endereço da variável var */ printf( %f, *pont); /*Imprime o conteúdo do ponteiro que vale 30 */ A representação de strings em C é feita por meio de vetores. C não possui um tipo básico específico. Outra particularidade do C, é que quando se aloca um string deve-se reservar um espaço a mais para guardar um caractere terminador de string, o \0. Sem ele, não se pode saber qual o tamanho da string.

char str[10] = oi ; Neste exemplo, str[0]= o, str[1]= i e str[2]= \0. C fornece diversas funções para manipulação de strings, como por exemplo strcat( ), que concatena duas strings, strcpy( ), que faz cópia de strings, strlen( ), que retorna o tamanho da string, gets (), que lê uma string do teclado. Todas estas funções e muitas outras estão na biblioteca string.h. Caso alguma destas funções for usada, deve-se adicionar no topo do programa a diretiva: #include <string.h> 3.3 Estruturas Para definir tipos de dados complexos de tipos variados, C define o tipo struct, que permite aglomerar em um único elemento diversos tipos básicos ou complexos. A sintaxe de definição é a seguinte: struct nome /* colocar aqui os tipos desejados */ /* colocar aqui os tipos desejados */ ; Um exemplo muito comum em jogos é a definição de primitivas geométricas. A definição de um ponto em 3D pode ser da seguinte maneira: struct ponto3d float x, y, z; ; Com esta definição, o tipo struct ponto3d pode ser usado para armazenar pontos do espaço 3D. O exemplo seguinte mostra a utilização de estruturas. struct ponto3d p1, p2; /*define duas variáveis do tipo struct ponto3d */ p1.x = 20; /* atribui 20 ao campo x de p1 */ p1.y = 1.002; p1.z = 70; p2.x = p1.x p1.z; Para acessar os elementos da estrutura deve-se usar ponto. Caso a estrutura for alocada dinamicamente, deve-se usa o operador seta (->). struct ponto3d *p1; p1 = (struct ponto3d *) malloc(sizeof(struct ponto3d)); p1->x = 20; Outra característica do C é permitir criar nomes de tipos. No seguinte exemplo: typedef struct

float x, y, z; ponto3d; define-se ponto3d como um tipo, o que facilita a futura utilização: ponto3d *p1; p1 = (ponto3d *) malloc(sizeof(ponto3d)); p1->x = 20; Estruturas podem conter outras estruturas bem como pode-se também definir vetores de estruturas: ponto3d vet[100]; /*vetor com 100 posições do tipo ponto3d */ /*definição da estrutura quadrado compostas por 4 ponto3d e mais uma string para conter o nome do elemento */ typedef struct char nome[100]; ponto3d pontos[4]; quadrado; A passagem de estruturas para funções é semelhante aos outros tipos de dados. Neste exemplo a variável quadro1 é passada por referência para a função imprime. A função imprime recebe somente o endereço da localização da variável quadro1. /* a definição da estrutura quadrado e ponto3d deve ser feita fora de main( ) pois a função imprime também usa esta estrutura */ void imprime(quadrado *q) int cont; printf("nome da variável: %s", q->nome ); for( cont=0; cont<4; cont++) printf("%f ", q->pontos[cont].x); printf("%f ", q->pontos[cont].y); printf("%f ", q->pontos[cont].z); int main(void) /*declaração da variável quadro1 */ quadrado quadro1; /* eh passado para a função imprime o endereço (&) da variável quadrado, que deve ser inicializada */ imprime( &quadro1 );

return 0; 4 Operadores Existem vários tipo de operadores em C, que podem ser classificados, segundo sua função, nos seguintes grupos: Tipo do Operador Exemplo Descrição Aritméticos +, -, *, /, f = a+b; Operações aritmética convencionais % (módulo) c = a%b; c recebe o resto da divisão inteira de a por b Atribuição = a = 10; Inicializa a com 10 Incremento ++ cont++; Incrementa cont em 1 -- cont--; Decrementa cont em 1 += cont+=5 Incrementa cont em 5 -= cont-=3 Decrementa cont em 3 Relacionais == a==b Testa se a é igual a b <, <= a<=b Testa se a é menor ou igual a b >, >= a>b Testa se b é menor que a!= a!=b Testa se a é diferente de b Lógicos && E (and) lógico Ou (or) lógico! Negação (not) Exemplos de operadores relacionais e lógicos serão apresentados na seção seguinte. 5 Controle de fluxo Para efetuar tomada de decisões, desvios condicionais e controle de laços de repetição, C fornece um amplo conjunto de construções para as mais diversas necessidades. O comando principal, que é a base para os outros é o if (se, em português). A sintaxe é a seguinte. if (expressão for verdadeira) /* bloco de comandos */ ou

if (expressão for verdadeira) /* bloco de comandos */ else /*senao */ /* bloco de comandos se expressão for falsa */ Em C, uma expressão é verdadeira se tiver valor diferente de 0 (zero) e falsa se for igual a 0. Suponha o seguinte exemplo: int a; scanf( %d, &a); if(a>5) printf( A eh maior que 5 ); else if(a<=5) printf( A eh menor ou igual a 5 ); Além de operadores relacionais, pode-se também usar operadores lógicos if( (a < 4 && b <=10) c!=6 ) d -= 30; Neste exemplo deve-se cuidar a precedência dos parênteses. A expressão é verdadeira em duas situações, devido ao OU lógico: 1) se (a menor 4 E b menor igual 10) 2) se (c diferente 6) Quando o encadeamento de if-else se tornar muito grande, pode-se usar a estrutura switch, que torna o código mais estruturado e legível. A sintaxe é a seguinte: switch ( expressao ) case opcao1: /* comandos executados se expressao == opcao1 */ break; case opcao2: /* comandos executados se expressao == opcao2 */ break; default: /* se expressao for diferente de todos as opções anteriores */ break;

O valor da expressão deve ser um número inteiro ou uma constante caractere. Caso expressão for igual a opcao1, serão executados todos os comandos até o comando break. A opção default é opcional. Para tratar laços de repetição, pode-se usar o for(;;), while() ou do-while(). O comando for e while tem funcionalidades semelhantes, porém o for é mais compacto: for(inicialização; condição; incremento ) for(int i=0; i<=20; i++) printf( %d, i); while (condição) int i=0; while( i<= 20 ) printf( %d, i); i++; Nos dois casos, inicialmente é testada a condição. Se ela for verdadeira, o laço executa e a variável i é incrementada, de forma iterativa. Deve-se usar preferencialmente o for quando se sabe com certeza quantas iterações vão ser executadas e o while quando não se tem esta informação. Deve-se ter cuidado para NÃO colocar ; após o for ou while, pois o bloco do laço não é mais executado (isso não causa erro de compilação). O comando do-while() é muito semelhante ao while, com a diferença que o laço primeiramente é executado para posterior teste condicional: int i=0; do printf( %d, i); while(i<20); 7 Referências Bibliográficas [1] Kernighan, B., Ritchie, D. C, A linguagem de Programação Padrão Ansi. Ed. Campus, 1990. [2] Schildt, H. C completo e total. Ed. Makron Books, 1991. 8 Apêndices Nesta seção são apresentados 5 programas exemplo que mostram as principais características da linguagem C. No cabeçalho de cada exemplo existe uma descrição dos assuntos apresentados. 8.1 Exemplo 1 /* TOPICOS - impressao de mensagens na tela - leitura de valores inteiros e reais

- definicao de vetores de inteiros e caracteres - manipulacao de vetores - passagem de vetores para funções - lacos de repeticao */ #include <stdio.h> void imprime_vetor(int v[]) int cont; printf("\nos numeros digitados foram: "); /*imprime os 4 valores lidos */ for(cont=0; cont<4; cont++) /* apos imprimir o numero, eh adicionado dois espacos em branco */ printf("%d ", v[cont] ); int main(void) int a; float b; char str[20]; /*define um vetor com 19 posicoes uteis */ int vet[4]; /*define um vetor de inteiros com 4 posicoes */ int cont; /* o caractere '\n' faz pular uma linha na tela*/ printf("\ndigite um numero inteiro e um float, separados por espaco e tecle <enter>:\n"); /*"%i" indica que a variavel a sera lida como inteira. */ /*"%f" indica que a variavel a sera lida como float. */ /* a funcao scanf recebe o endereco das variaveis a serem lidas */ scanf("%i %f", &a, &b); /* para formatar a saida do tipo float com 3 casas decimais, usar 0.3f */ printf("\nos numeros foram: \ninteiro: %i \nfloat: %0.3f\n", a, b); /* limpa o buffer de teclado */ fflush(stdin); printf("\ndigite uma string com no maximo 19 caracteres\n"); gets(str); /* %s indica que a variavel str sera lida como uma string */

printf("\na string digitada foi: %s\n", str); /* limpa o buffer de teclado */ fflush(stdin); printf("\n\ndigite 4 numeros inteiros: "); /*faz a leitura de um vetor com 4 posicoes de inteiro */ for(cont=0; cont<4; cont++) scanf("%d", &vet[cont] ); /* chama funcao para imprimir o vetor */ imprime_vetor(vet); return 0; 8.2 Exemplo 2 /* TOPICOS - utilizacao de #defines - leitura de valores char - uso do comando switch */ #define KEY_UP 72 #define KEY_DOWN 80 #define KEY_LEFT 75 #define KEY_RIGHT 77 #define KEY_EXIT 27 #include <stdio.h> #include <conio.h> int main(void) char opcao; /*define uma variavel char. */ /* inicializa a varival opcao */ opcao = 0; printf("\npressione alguma seta ou ESC para sair: "); while(opcao!= KEY_EXIT ) /* limpa o buffer de teclado */ fflush(stdin); /*le uma tecla */ opcao = getch();

//printf("%d ", opcao); switch(opcao) case KEY_UP: printf("\n Seta para cima"); break; case KEY_DOWN: break; printf("\n Seta para baixo"); case KEY_LEFT: break; printf("\n Seta para esquerda"); case KEY_RIGHT: printf("\n Seta para direita"); break; return 0; 8.3 Exemplo 3 /* TOPICOS - uso de funcoes da biblioteca string.h - representacao numerica de caracteres - conversao de caracteres para maiusculo - manipulacao de caracteres dentro de vetores (strings) */ #include <stdio.h> #include <string.h> /* Cada letra tem um numero decimal associado. Para descobrir o valor, pode-se usar printf("%d", variavel)*/ void valor_decimal(void) char letra1='a', letra2='a', letra3='5'; printf("\no valor da letra a eh: %d", letra1); printf("\no valor da letra A eh: %d", letra2); printf("\no valor da diferenca eh %d", letra1-letra2); printf("\no valor da letra 5 eh: %d", letra3);

void maiusculo(char *str) int i=0; /*enquanto nao encontrar o final da string, troca as letras para maiusculo. */ while( str[i]!= '\0' ) str[i] = str[i]-32; /* outra solucao eh str[i] = str[i]-('a'-'a');*/ i++; int main(void) int a, tam; char str[100]; /*copia a string "teste" em str */ strcpy(str, "teste"); /*verifica o tamanho de str */ tam = strlen(str); printf("\n O tamanho de str eh %d", tam); /*Varre a string e troca as letras 'e' por 'a' Observar a diferenca entre o operador de atribuicao e comparacao*/ for(a=0; a<tam; a++) if(str[a]=='e') /* "==" -> coparacao logica */ str[a] = 'a'; /* "=" -> atribuicao */ /*imprime a nova string alterada*/ printf("\na nova string eh %s", str); /*adiciona uma nova string ao final de str */ strcat(str, ".exe"); printf("\na nova string eh %s", str); /*trunca a string para 2 caracteres colocando o caractere '\0' na posicao 2*/ str[2]='\0'; printf("\na nova string truncada eh %s", str); /*imprime o valor decimal de algumas letras. Tambem vale para numeros */ valor_decimal();

/*chama a funcao maiusculo passando uma referencia da string. Nao precisa colocar o & antes de str pois somente str ja é igual ao endereco da primeira posicao do vetor = &str[0].*/ maiusculo(str); printf("\na nova string maiuscula eh %s", str); return 0; 8.4 Exemplo 4 /* TOPICOS - definicao de tipos de dados - passagem de tipos por valor - passagem de tipos por referencia - passgem de strings. - indexacao de estruturas por ponteiros - leitura de valores reais - ponteiros para tipos definidos */ #include <stdio.h> /*como a definicao da estrutura foi feita fora da funcao main, pode ser acessada de qualquer parte do programa */ typedef struct float x; float y; ponto2d; /*funcao que recebe uma referência de uma variavel do tipo ponto2d Como a passagem eh por referencia, qualquer alteracao nesta funcao ira alterar o valor de p1 na função main. p eh um ponteiro */ void altera_referencia(ponto2d *p) p->x = 10; p->y = 10; /*neste caso, p eh possado por valor. Para alterar p1 de main deve-se retornar o novo valor */ ponto2d altera_valor(ponto2d p) p.x = 1000; p.y = 1000; return p;

void imprime(ponto2d p, char *msg) /* o argumento %0.2f indica que a variavel sera impressa com duas casas decimais */ printf("%s = (%.2f, %.2f)\n", msg, p.x, p.y); int main (void) /*definicao de p1 do tipo struct ponto2d*/ ponto2d p1; printf("digite as coordenadas do ponto(x y): "); /* na funcao scanf, deve-se passar o endereco "&" das variaveis que serao lidas */ scanf("%f %f", &p1.x, &p1.y); /* chama a funcao imprime passando uma copia de p1 e uma mensagem*/ imprime(p1, "O ponto lido foi "); altera_referencia(&p1); /* eh passado o endereco da varival p1 */ imprime(p1, "O ponto alterado eh "); p1 = altera_valor(p1); /* eh passado uma copia da varival p1 */ imprime(p1, "O ponto alterado eh "); return 0; 8.5 Exemplo 5 /* TOPICOS - definicao de tipos de dados - alocacao dinamica - ponteiros para tipos definidos - vetores de ponteiros para estruturas - funcoes matematicas */ #include <stdio.h> /*funcao printf() */ #include <math.h> /*funcao seno e rand() */ #include <stdlib.h> /*funcao malloc() */ #define NUM_PONTOS 8

/*como a definicao da estrutura foi feita fora da funcao main, pode ser acessada de qualquer parte do programa */ typedef struct float x; float y; ponto2d; void imprime(ponto2d *p, int indice) /* o argumento %0.2f indica que a variavel sera impressa com duas casas decimais */ printf("\n Ponto %d = (%.2f, %.2f)\n", indice, p->x, p->y); int main (void) int i; /*definicao de um vetor de ponteiros para ponto2d*/ ponto2d *p1[num_pontos]; /*agora deve-se fazer a alocacao dos pontos */ for(i=0; i< NUM_PONTOS; i++) p1[i] = (ponto2d*)malloc(sizeof(ponto2d)); /*faz a inicializacao dos pontos com valores randomicos */ for(i=0; i< NUM_PONTOS; i++) p1[i]->x = (float)sin(i); p1[i]->y = (float)(rand()%100); /* valor randomico entre 0 e 100 */ /*faz a impressao dos pontos */ for(i=0; i< NUM_PONTOS; i++) imprime(p1[i], i); return 0;