facilita o trabalho em equipe, com diferentes grupos trabalhando em cada módulo independente.

(1)

Estruturac¸˜ao do Programa

Queremos organizar um programa de forma a:

dividi-lo em partes que realizem tarefas espec´ıficas, resumindo um problema complexo a v´arios problemas mais simples

❒ _{simplifica a elaboração e manutenção do código} ❒ _{erros são mais facilmente detetados}

❒ _{permite escrever funç ões genéricas que possam ser usadas por vários}

programas

❒ _{facilita o trabalho em equipe, com diferentes grupos trabalhando em}

cada m´odulo independente.

(2)

Func¸˜oes

Já utilizamos várias funç ões da biblioteca padrão: scanf, printf, cos, sqrt

Até agora só constru´ımos uma função - a main _{- todo programa precisa de}

uma e é por ela que começa a execução do programa. A sintaxe de uma função é:

tipo nome (tipo1 var1, tipo2 var2,...) {

linhas de c´odigo return valor;

}

(3)

❒ Ao chegar na chamada da função, a execução de main é interrompida.

❒ O valor de n é passado para a função fatorial, que executa suas linhas de comando até encontar um return

❒ Ao encontrar um return, a execução da função é interrompida e o valor de fat é retornado e atribu´ıdo à variável nfatorial

❒ Observe que pode haver mais de um return

❒ As funções podem aparecer em qualquer ordem dentro de um arquivo, mesmo antes de main, ou em arquivos separados. Mas não pode ser definida dentro de outra função

❒ Uma função, como qualquer identificador, s ó pode ser utilizada depois de ser declarada

(4)

Prot´

otipo

❒ Para toda função que criamos, devemos fazer uma declaração, mostrando o protótipo da funç ão, da seguinte forma:

tipo nome (tipo1 var1, tipo2 var2,...);

❒ Normalmente as declaraç ões ficam no começo do arquivo, antes de

main

❒ Os protótipos são necessários para o compilador conferir se o uso da função está correto. Ex: double sin( double x )

double x, y; y = sin(x);

❒ O nome das variáveis podem ser omitidos na declaração (não na definição da função). Mas isso não é uma boa prática.

(5)

Tipos de Func¸ ˜oes

❒ Funções em C podem retornar qualquer tipo de variáveis, menos arrays ou funç ões.

❒ A expressão que aparece em return valor deve ser do tipo da função.

❒ _{Podem também não retornar nada. Neste caso o tipo é} void

void imprime(int n); int main(){

int n;

printf("Entre com o valor de n\n"); scanf ("%d", &n);

imprime (n); return 0; }

void imprime(int n){

printf("O valor de n eh:%d\n", n); }

(6)

Lista de Argumentos

❒ _{Os nomes na lista da definição são independentes dos nomes na}

chamada da func¸˜ao.

int soma(int i, int j, int k); int main(){

int l, m, n, s;

printf("Entre com os valores a serem somados\n"); scanf ("%d %d %d", &l, &m, &n);

s = soma(l, m, n);

printf("A soma eh %d",s); return 0;

}

int soma(int o, int p, int q){ return o+p+q;

}

❒ i, j, k _ou o, p, q_{: argumentos formais} l, m, n_: _{argumentos reais}

(7)

Passagem por valor

Em C, não é a variável que é passada para a função, mas sim o seu valor.

#include <stdio.h>

double fatorial (int n); int main{

double fatorial; int n=5;

nfatorial = fatorial(n);

printf ("O fatorial de %d eh %lf\n",n, nfatorial); return 0;

}

double fatorial (int n){ double fat = 1.0;

for ( ; n > 1; n--) fat *= n; return fat;

}

(8)

Passagem de Array ´

e diferente

Fazer uma c´opia de um array seria muito custoso. O que passamos ´e o

endereço do in´ıcio do vetor e devemos passar também a dimensão do vetor.

void inicio (double a[], int n); int main{

double r[3]; int i;

inicio(r, 3);

for (i = 0; i < 3; i++) printf("r[%d] = %lf \n", i, r[i]); return 0;

}

void inicio (double a[], int n){ int i;

for (i = 0; i < n; i++) a[i] = 0.0; }

(9)

Vari´

aveis Autom´

aticas e Est´

aticas

❒ Variáveis declaradas dentro de uma função são criadas e inicializadas a cada vez que a função é chamada

❒ _{Elas são armazenadas temporariamente em uma região de memória e}

deixam de existir ao término da execução da função.

❒ _{Essas variáveis são chamadas de automáticas.}

❒ _{Se quisermos preservar o valor de variáveis dentro de uma função}

devemos declar´a-las como est´aticas

❒ A criação de variáveis estáticas é feita em tempo de compilação e deve-se inicializá-la na hora da declaração

❒ _{Quando a função é executada, a variável estática tem o último valor}

(10)

void contar(int i);

int main{

const int n = 10; int i;

for (i=0; i < n; i++) contar(i);

return 0; }

void contar(int i){

static int contador = 1; int k = 0;

k++;

printf( "contador = %d k = %d\n", contador, k); contador++;

(11)

Escopo

❒ _{Escopo das variáveis: em que região do código uma variável é}

acess´ıvel.

❒ _{Quando uma variável é criada dentro de uma função ela só é vista em}

seu interior. S˜ao vari´aveis locais

❒ As automáticas até deixam de existir ao término da função

❒ As estáticas não deixam de existir, mas também só são vistas dentro da função.

❒ Mas podemos declarar variáveis fora das funç ões, antes de main ou entre as declaraç ões das funç ões. São chamadas de variáveis globais

❒ São acess´ıveis do ponto de declaração até o fim do arquivo

❒ São estáticas: permanecem na memória durante toda a execução do programa

(12)

❒ São vistas por todas as funç ões definidas fisicamente abaixo delas.

❒ _{E uma maneira prática de fazer com que funç ões diferentes}´ compartilhem a mesma variável.

❒ Porém deve ser usada com moderação, pois uma função pode alterar o valor de uma variável global por engano.

(13)

#include <stdio.h> int soma (int i); int j = 5;

int main(){ int i = 1;

printf ("j = %d\n", j);

printf ("k = %d\n", k); // Erro: k ainda nao declarada printf ("l = %d\n", l); // Erro: l e local em soma() printf ("i+j+k+l = %d\n", soma(i));

return 0; }

int k = 10;

int soma(int i){ int l = 4;

return i+j+k+l; }

(14)

$ gcc -Wall -o escopo escopo.c

escopo.c: In function ‘int main()’:

escopo.c:10: error: ‘k’ undeclared (first use this function)

escopo.c:10: error: (Each undeclared identifier is reported only once for each function it appears in.)

escopo.c:11: error: ‘l’ undeclared (first use this function) escopo.c: At global scope:

(15)

Constantes Simb ´

olicas

❒ Frequentemente usamos o mesmo valor em diversas partes do programa. ´E conveniente usarmos as constantes simb ´olicas Ex.:

#define VSOM 340.0

❒ _{Sempre que} VSOM _{for encontrado, ele ser´a substitu´ıdo por} 340.0 _pelo

pr´e-processador #define NDIM 3

void inicio (double a[], int n); int main{

double r[NDIM]; int i;

inicio(r, NDIM);

for (i = 0; i < NDIM; i++) printf("r[%d] = %lf \n", i, r[i]); return 0;

(16)

Macros

❒ Funções permitem que tarefas sejam separadas em regi ões bem determinadas, facilitando a organização e a verificação do código.

❒ Mas:

❍ _{as informac¸ ˜oes locais devem ser guardadas no ponto de chamada}

da func¸˜ao

❍ e novas variáveis devem ser criadas e inicializadas, consumindo tempo de execução

❒ Se a função puder ser escrita em uma só linha podemos usar MACROS

❒ #define SQR(x) ((x)*(x))

❒ x _{pode ser um número, uma variável ou uma expressão mais complexa.}

❒ _{Sempre que SQR(x) for encontrado, ele ser´a substitu´ıdo por}

(17)

#include <stdio.h>

#define SQR(x) ((x)*(x))

#define CUBE(x) ((x)*(x)*(x))

#define MAXIMO(x,y) (((x) > (y)) ? (x) : (y)) #define MINIMO(x,y) (((x) < (y)) ? (x) : (y))

#define SOMA(a,b) a+b // CUIDADO: Definicao inadequada int main(){ double x = -5.0, y = 10.0; printf("SQR(x) = %f\n", SQR(x)); printf("CUBE(x) = %f\n", CUBE(x)); printf("MAXIMO(x,y) = %f\n", MAXIMO(x,y)); printf("MINIMO(x,y) = %f\n", MINIMO(x,y));

printf("Dobro de x+y = %f\n", 2*SOMA(x,y));// Resposta errada return 0;

}

SQR(x) = 25.0 CUBE(x) = -125.0 MAXIMO(x,y) = 10.0

(18)

Divis˜ao em arquivos

Um programa pode ser dividido em v´arios arquivos.

❒ Arquivos de cabec¸alho (headers):

contém declaraç ões de funç ões e de variáveis globais, constantes simbólicas, macros, ...

❒ Arquivos de implementac¸˜ao:

Contém a implementação de uma ou mais funç ões. Podem ser adicionados na hora da compilação ou

podem ser pré-compilados separadamente ( arquivo objeto) e juntado aos outros na hora da compilação (linker)

(19)

Headers

❒ Um programa grande, com vários includes, protótipos de funç ões, macros e constantes simbólicas, torna-se rapidamente “sujo”, de dif´ıcil leitura, devido à grande quantidade de declaraç ões. Os headers são

´uteis para organizar e esconder tudo isso.

❒ _{podemos criar um arquivo chamado} my math.h _{com o seguinte}

conte´udo:

#include <math.h>

#define SQR(x) ((x)*(x))

#define CUBE(x) ((x)*(x)*(x))

#define MAXIMO(x,y) (((x) > (y)) ? (x) : (y)) #define MINIMO(x,y) (((x) < (y)) ? (x) : (y))

❒ E para utilizar esse header no programa .c inclu´ımos:

(20)

Exemplo de divis ˜ao em arquivos

Vejamos com separar o programa abaixo em v´arios arquivos

#include <stdio.h>

double fatorial (int n); int main{

double fatorial; int n=5;

nfatorial = fatorial(n);

}

(21)

❒ Arquivo fatorial.h:

double fatorial (int n);

Deve ser inclu´ıdo pelo pr´e-processador com

#include "fatorial.h"

❒ Arquivo fatorial.c:

}

Pode ser pr´e-compilado com o comando

gcc -c fatorial.c

O arquivo objeto fatorial.o ´e criado. ´

(22)

❒ Arquivo com o programa principal principal.c: #include <stdio.h> #include "fatorial.h" int main{ double fatorial; int n=5; nfatorial = fatorial(n);

}

Podemos criar um programa execut´avel completo com o comando

gcc -o principal principal.c fatorial.o

O pr´e-processador inclui os arquivos stdio.h e fatorial.h

O compilador compila o arquivo principal.c

O linker adiciona o arquivo fatorial.o

(23)

A separação do código em diferentes arquivos

❍ faz com que não seja necessário copiar cada função para dentro do seu programa

❍ Essa função não precisa ser recompilada cada vez que for usada

Bibliotecas:

Várias funç ões pré-compiladas podem ser agrupadas em um único arquivo binário: Uma biblioteca

Uma biblioteca _{pode ser adicionada a um programa com a opc¸˜ao} -l

do compilador seguido de um nome que indica a biblioteca. O comando

gcc -o calculo calculo.c -lm

cria o executável calculo incluindo a biblioteca de funç ões matemáticas do sistema.