LINGUAGEM DE PROGRAMAÇÃO C - inf.ufg.breduardo/so/CURSO-C.pdf · UFPE - Departamento de...

UFPE - Departamento de Informática - Judith Kelner

1Introdução a linguagem de programação C

Introdução a

LINGUAGEM DE

PROGRAMAÇÃO C

Material cedido pela Profa. Judith Kelner do Centro de Informática da UFPE



HISTÓRICO 5

CARACTERÍSTICAS 6

CRÍTICAS 7

PROGRAMA EM C 8

TIPOS DE ARQUIVOS FONTES EM C 8

BIBLIOTECAS EM C 8

PALAVRAS CHAVES 9

VARIÁVEIS E CONSTANTES - TIPOS E DECLARAÇÕES 9

TIPOS DE DADOS 11

A NORMA ANSI C 11

IDENTIFICADORES 12

VARIÁVEIS 13

Onde declarar variáveis 13

PARÂMETROS FORMAIS 14

VARIÁVEIS GLOBAIS 15

ESPECIFICADORES DE TIPOS DE ARMAZENAMENTO DEVARIÁVEIS 16

CONSTANTES 18

COMANDOS DE CONTROLE 27



COMANDO DE ITERAÇÃO 29

COMANDO DE DESVIO 30

ARRANJOS 34

ESTRUTURAS 40

UNIÕES 41

EXEMPLOS: 41

F U N Ç Õ E S 46

USO DE FUNÇÕES 47

FUNÇÕES EM C 47

PASSAGEM DE ESTRUTURAS PARA FUNÇÕES 47

EXEMPLOS DO USO DE FUNÇÕES 49

UTILIZAÇÃO DE PARÂMETROS 50

FUNÇÕES DE ENTRADA E SAÍDA 51

A P O N T A D O R E S ( P O I N T E R S ) 56

APONTADORES 57

APONTADORES E ARGUMENTOS DE FUNÇÕES 58

APONTADORES E ARRANJOS 59

ARITMÉTICA COM ENDEREÇOS 59

APONTADORES DE CARACTERE E FUNÇÕES 60



APONTADORES PARA FUNÇÕES 61

APONTADORES PARA ESTRUTURAS 62

FUNÇÃO PARA ABRIR E FECHAR ARQUIVOS 63

LEITURA E GRAVAÇÃO EM ARQUIVOS 63

EXEMPLOS 64

O PREPROCESSADOR C 65



Histórico • BCPL → B → C

• Projetada por Dennis Ritchie para ser implementada no sistema operacional Unix

• Evolução: O Unix e os programas de aplicação implementados em C

• Linguagem de Implementação de vários sistemas operacionais, interpretadores, editores, compiladores, software de comunicação, etc.



Características

• Linguagem de programação de finalidade geral

• É uma linguagem que combina o “alto nível” com o “baixo nível” permite a manipulação direta de bits, bytes, palavras e apontadores

• Possui modernos fluxos de controle e estruturas de dados e, ainda, um rico conjunto de operadores

• Possui apenas 28 palavras-chaves (reservadas)

• Permite economia de expressão e gera códigos reduzidos

• Permite estruturar o software em módulos, arquivos fontes, bibliotecas

• É facilmente transportável (ANSI C)

• Alocação dinâmica de memória

• C permite recursividade

• O uso da recursividade torna-se inviável quando o tempo ou o espaço da

memória forem críticos



Críticas • Dá-se muita liberdade ao programador

Programas ininteligíveis, acesso direto a memória

• Não permite o aninhamento de funções

• Não há verificação de tipos e nem de limites de arranjos

Simplifica o “design” do compilador C

• O uso de apontadores pode se tornar muito confuso

• Mensagens de erro muito vagas ( limitação do compilador )

• Alguns comandos não podem ser definidos semanticamente

• Constatação: não possui muitas facilidades para tratamento de arquivos



Programa em C • Consiste de uma (main) ou mais funções

• Um programa começa a ser executado no início da função main ( ), que invocará as demais funções

• A comunicação entre as funções é feita através da passagem de argumentos

e/ou variáveis globais

Tipos de Arquivos Fontes em C

• Arquivos fonte *.c

• Arquivos fonte *.h (stdio.h, math.h)

Bibliotecas em C

• São utilizadas para facilitar o desenvolvimento de software

• Por exemplo, “stdlib.a” é sempre incluída em todos os programas C por

“default”



Palavras Chaves • São sempre escritas com letras minúsculas

auto break case char continue default do double else entry extern float for goto if int long register return short szeof satic struct switch typedef union unsigned while

Variáveis e Constantes - Tipos e Declarações

• Declaração deve vir antes do uso • Os nomes das variáveis são constituídos de letras e dígitos, onde o primeiro

caractere é uma letra • Há diferença entre letras maiúsculas e minúsculas

• Uso de letras maiúsculas para constantes (convenção)



L I N G U A G E M C

T I P OS D E D A D O S



Tipos de Dados

→ char - tipo caractere (normalmente um byte)

→ int - tipo inteiro (tamanho natural de inteiro na máquina “2 bytes”)

→ float - tipo ponto flutuante de precisão simples (1e-37 até 1e+37)

→ double - tipo ponto flutuante de precisão dupla

→ void - tipo explicíto para funções ou ponteiros (será visto a posterior)

• Qualificadores para o tipo inteiro

→ short

→ long

→ unsigned

A Norma ANSI C

• Diferentes compiladores C para diferentes arquitetura de hardware define tamanhos diferentes para o armazenamento dos tipos de dados da Linguagem C

• Isto poderá gerar problemas de portabilidade dos fontes

• Definição da norma ANSI C



Tipo Tamanho em Bits Intervalo

char 8 -127 à 127 unsigned char 8 0 à 255 signed char 8 -127 à 127 int 16 -32.767 à 32.767 unsigned int 16 0 à 65.535 signed int 16 Igual a int short int 16 Igual a int unsigned short int 8 0 à 65.535 signed short int 8 Igual a short int long int 32 -2.147.483.647 à 2.147.483.647 unsigned long int 32 0 à 4.294.967.295 signed long int 32 Igual a long int float 32 Seis dígitos de precisão double 64 Dez dígitos de precisão long double 128 Dez dígitos de precisão

Todos os tipos de dados defenidos pelo padrão ANSI

Identificadores

• Usados para definir nomes de variáveis, funções, rótulos (labels), etc.

• Consiste de um ou mais caracteres, o primeiro caracter deve ser letra ou “_”, os demais devem ser letras, ou números ou “_”

• Pode ter qualquer tamanho , os 6 primeiros caracteres devem ser significativos para serem usados como nomes externos, e os 31 primeiros caracteres para nomes internos

Correto Incorreto contador 1contador test123 ola!turma

sala_de_aula sala-de-aula



Variáveis

• É uma posição da memória, identificada por um nome (identificador), usada para guardar um valor que poderá ser usado, modificado pelo programa

• Todas as variáveis em C devem ser declaradas

• Uma declaração consiste de um tipo (adcionado de algum qualificador) e de uma lista de variáveis (separadas por vírgula) que sejam deste tipo

Ex: int soma, total; double fact; char carac, ch; unsigned int idade;

short int valor;

• C não inicializa as variáveis

• Variáveis podem ser inicializadas quando declaradas

Ex: int eh_zero = 0, num_max = 5000;

float pi = 2.1416, eps = 1.0e-5;

Onde declarar variáveis

• dentro de funções → variáveis locais

• definição dos parâmetros das funções → parâmetros formais

• fora das funções → variáveis globais



• Variáveis Locais

• Só pode ser referenciada dentro do bloco na qual foi definida, são criadas após a sua definição e são destruídas após a saída do bloco

• Um bloco é identificado por um par de chaves “{“ no ínicio e “}” no fim, no máximo um bloco representa uma função

• Variáveis podem ser definidas em qualquer parte do bloco, normalmente as variáveis são definidas logo no início de uma função ( a variável local só pode ser referenciada depois de ter sido definida)

Parâmetros Formais

• São usados para definir os argumentos de uma função

• Comportamento igual ao de uma variável local

• Lista de identificadores, separados por vírgula, após o nome da função entre parenteses

• Deve-se definir os parâmetros e o tipo deles deve ser o mesmo definido para os argumentos usados na chamada da função ( o compilador não verifica isto)



Variáveis Globais

• Diferem das variáveis locais por poderem ser usadas em qualquer parte do código

• Existem durante todo o ciclo de vida do programa (ocupa memória)

• Normalmente são declaradas no ínicio do programa e/ou em arquivos do tipo header (*.h)

• Se uma variável local tem o mesmo nome de uma variável global, dentro do bloco no qual foi definido a variável local ela terá prioridade sobre a global

• Deve-se evitar o uso abusivo de variáveis globais para evitar problemas de limitação de memória e de tempo de execução

• As variáveis globais só podem ser declaradas uma só vez

• O Tipo const

• Variáveis do tipo const não podem ser modificadas pelo programa, entretanto elas “podem” ser inicializadas quando forem definidas

Ex: const int a = 10;



Especificadores de Tipos de Armazenamento deVariáveis

• extern

• static

• register

• auto

• extern

• Permite que dois ou mais arquivos compartilhem as mesmas variáveis globais

• As variáveis globais só podem ser declaradas uma só vez

• É um mecanismo para importar variáveis globais definidas em outros arquivos

• O escopo de uma variável extern vai do ponto em que ela é declarada no arquivo fonte até o fim do mesmo

• Para variáveis automáticas (locais) e argumentos, o escopo é a função em que o nome é definido

• Declaração extern é obrigatória em dois casos

• Declaração é diferente de definição

Ex:

Arquivo 1: Arquivo 2:

int ap = 0; /* apontador */ extern int ap; double val [MAXVAL]: extern double val[ ]; double empil (f) { ... }

double desempil ( ) { ... }



• static

• Quando usado em uma variável local: instrui o compilador a manter a variável local existente durante o tempo de vida do programa (ela só existe no bloco em que foi definida)

• Quando usado em uma variável global: instrui o compilador a limitar o uso desta variável ao arquivo onde ela foi definida

Ex: int contador ( x) char x; {

static int meucontador = 0; meucontador = meucontador + 1;

... }

• register

• usado em variáveis locais do tipo caractere ou inteiro, provê um acesso mais rápido a mesma (pode também ser usado nos parâmetros formais). Em algums implementações utiliza registradores ao invés de memória

Ex: register int aux; for (aux = 0; aux < 100; aux++) { ... }

• auto

• usado para declarar variáveis locais. É opcional e pouco usado porque é “default



Constantes

• São valores constantes fixos dentro do programa que não podem ser alterados

Tipo de Dado Exemplos

int 1 123 21000 -234 long int 35000L -34L short int 10 -12 90 unsigned int 10000U 987U 40000 float 123.23F 4.34e -3F double 123.23 12312333 -0.9876324 long double 1001.2L hexadecimal int hex = 0x80 (128) octal int oct = 012 (10) character ‘a’ string “este e um teste”

Código Significado

\b Espaço \f Alimenta formulário \n Pula linha \r “Carriage return” \t Tabulação horizontal \” Aspa dupla \’ Aspa simples \0 NULL \\ \ \v Tabulação vertical \a Alerta \N Constante octal \xN Constante hexadecimal



• O uso de constantes simbólicas torna o programa mais legível. Geralmente são escritas com letras maiúsculas. O comando define neste exemplo será processado pelo pré-processador do C (cpp)

Ex: #define INICIO 0 /* limite inferior da tabela */ → int #define GOS 0.1 /* grau de servico eh 10% */ → double #define FIM 123L /* limite inferior */ → long



• Operadores

• atribuição

• aritméticos

• relacionais

• lógicos

• manipulação de bits (bitwise)

• especiais

• Atribuição

• O operador de atribuição pode ser usado em qualquer expressão válida em C

Forma geral:

nome-da variavel = expressao ;

• O nome-da-variavel deve ser uma variável ou um pointer (para um endereço válido na memória)

• Múltiplas atribuições

• Ex: x = y = z = 0;



• Quando tipos diferentes de variáveis são usados ocorre uma conversão de tipos nas seguintes situações (este resultado depende da arquitetura do hardware)

Tipo da Variável Tipo da Expressão Possíveis Perdas signed char char Se valor > 127, valor final é negativo char short int 8 bits de mais alta ordem char int 8 bits de mais alta ordem char long int 24 bits de mais alta ordem int long int 16 bits de mais alta ordem int float parte fracionária e talvez mais info float double Precisão, resultado arredondado double long double Precisão, resultado arredondado

Conversão de alguns tipos (assumindo uma palavra de 16 bits)



• Operadores Aritméticos

Operador Prioridade Ação

- 3 (1) subtração ( unário ) + 3 adição * 2 multiplicação / 2 divisão

% 2 resto da divisão (só para int) -- 1 decrementa ++ 1 incrementa

Ex: x = x + 1; → ++x;

x = x -1; → x--;

x = 10; y = ++x; → y = 11

x = 10; y = x++; → y = 10

• Operadores Relacionais


> 4 maior que > = 4 maior ou igual que < 4 menor que

< = 4 menor ou igual que = = 5 igual ! = 5 diferente



• Operadores Lógicos


&& 6 e || 7 ou ! 1 não

• Operadores para Manipulação de Bits (só para int e char)

Operador Ação

& e | ou ^ ou exclusivo ~ complemento de 1

>> deslocamento à esquerda << deslocamento à direita

Ex: ch & 127 1 1 0 0 0 0 0 1 com paridade 0 1 1 1 1 1 1 1 & 0 1 0 0 0 0 0 1 sem paridade

128 | 3 1 0 0 0 0 0 0 0 127 ^ 120 0 1 1 1 1 1 1 1 0 0 0 0 0 0 1 1 0 1 1 1 1 0 0 0 | (ou) ^ (ou exclusivo)

1 0 0 0 0 0 1 1 0 0 0 0 0 1 1 1



char x x depois de cada comando valor de x x = 7; 0 0 0 0 0 1 1 1 7 x << 1; 0 0 0 0 1 1 1 0 14 x << 3; 0 1 1 1 0 0 0 0 112 x << 2; 1 1 0 0 0 0 0 0 192 x >> 1; 0 1 1 0 0 0 0 0 96 x >> 2; 0 0 0 1 1 0 0 0 24

Multiplicação e Divisão através do operador de deslocamento

Ex: complemento de 1 ~ 0 0 1 0 1 1 0 0 → 1 1 0 1 0 0 1 1

• Operadores Especiais

• O operador ? Forma geral: Exp1 ? Exp2 : Exp3 Ex: x = 10;

y = x > 9 ? 100 : 200; • Os operadores & e * para pointers (ponteiros)

- Um ponteiro é o endereço de uma variável na memória

- Uma variável do tipo ponteiro (pointer) pode ser declarada para um tipo específico de dado

- Ponteiros podem ser usados para: acesso rápido a elementos de arranjos; modificar os parâmetros de chamad de uma função; e acesso a estruturas dinâmicas

Ex: m = &contador; → m recebe o endereço de contador q = *m; → q recebe o valor que está armazenado no endereço m



• O operador , (vírgula)

-Usado para juntar várias expressões

Ex: x = ( y = 3, y + 1);

• Precedência e Ordem de Avaliação

• A tabela abaixo apresenta um resumo das regras de precedência e de`associatividade de todos os operadores vistos

Operador Associatividade ( ) [ ] -> . esquerda para direita

! ~ ++ - - - (tipo) * & sizeof direita para esquerda * / % esquerda para direita

+ - esquerda para direita << >> esquerda para direita

> = > < < = esquerda para direita = = ! = esquerda para direita

& esquerda para direita ^ esquerda para direita | esquerda para direita

&& esquerda para direita || esquerda para direita ?: direita para esquerda

++ = -= etc. direita para esquerda , esquerda para direita



L I N G U A G E M C

C O M A N D O S D E C O N T R O L E



Comandos de Controle

• O ponto-e-virgula (;) é usado como terminador de comandos

• seleção • iteração • desvio • rótulo (label) • expressão • bloco

• Comando de Seleção • if Forma Geral: if (expressão) comando;

else comando;

Num aninhamento, o else é associado ao mais recente if sem else



• switch

Forma Geral: switch (expressão) { case constante1: comando(s) break; case constante2: comando(s) break; . . . default: comando(s) }



Comando de Iteração

• for

for (expressao_1; expressao_2; expressao_3) inicialização condição de

parada incremento

comando; Loop infinito: for (; ;) comando; for sem corpo: for ( t=0; t < VALOR; t++);

• while

Forma Geral: while (condição) comando; • do-while Forma Geral: do { comando(s) ; } while (condição);



Comando de Desvio

• return Forma Geral: return expressão; → (opcional)

• goto Forma Geral: goto label; . . . label: comando;

• break Forma Geral: break;

• exit Forma Geral: void exit (int codigo-de-retorno);

• continue Forma Geral: continue;



• Expressões

• Qualquer expressão válida em C seguida de um “;”

Ex: func ( ); /* chamada de funcao */

a = b + c; /* comando de atribuicao */

; /* comando nulo */

• Bloco de Comandos

• Comandos agrupados que são tratados como uma unidade. Devem estar entre

{ }



• Exemplos

• main () { printf(“programa em C\n”);

}

• main ( ) /* copia entrada na saída */ main( ) { {

int c; int c; c = getchar( ) ; while ((c = getchar( )) != EOF)

while (c != EOF) putchar(c); { }

putchar (c); c = getchar( ); }

}

• main() /* teste da funcao de potencia */ { int j;

for ( j = 0; j < 10; j++) printf ( “%d %d %d\n”, j , pot(2,j), pot(-3,j));

} pot (x, n) int x, n; { int j, p; p = 1; for (j = 1; j <= n; ++j) p = p * x; return (p); }



L I G U A G E M C

A R R A N J O S



Arranjos

• Coleção de variáveis do mesmo tipo referenciadas por um só nome. Um elemento específico num arranjo é localizado por um índice ou mais

• Os arranjos em C podem ter de 1 a N dimensões

• Pode-se declarar arranjos em quaisquer dos tipos de dados descritos anteriormente

• Os índices de arranjos começam sempre de 0

• C não faz testes para os limites de um arranjo

• Arranjo Bi-dimensional

• Arranjos com várias dimensões são declarados colocando-se a dimensão adicional dentro de outro par de colchetes

Ex: float matriz [2] [2];



• Strings

• O uso mais comum para os arranjos uni-dimensionais é na declaração de strings (cadeia de caracteres)

• Em C um string é definido como uma cadeia de caracteres que termina por um caractere null (‘\0’). Portanto quando declarar o arranjo adicione 1 ao tamanho máximo

Ex: char s [11]; → s pode armazenar 10 caracteres

→ s [10] deve ser o caracter null (‘\0’)

• Em C não existe o tipo de dados string, porém existe a constante do tipo string

Ex: char mensagem = “ola a todos”;

• Funções para Manipulação de Strings

Nome Função

strcpy (s1, s2) copia s2 em s1 strcat (s1, s2) concatena s2 no fim de s1 strlen (s1) retorna o tamanho de s1 strcmp (s1, s2) retorna 0 se s1 e s2 forem do mesmo tamanho

retorna < 0 se s1 < s2 retorna > 0 se s1 > s2

strchr (s1, ch) retorna um ponteiro para o primeiro caracter de ch em s1

strstr (s1, s2) retorna um ponteiro para a primeira ocorrência de s2 em s1

• Estas funções operam sobre strings terminados com o caractere null (‘\0’)



• Arranjos de strings

• É só utilizar o bi-dimensional arranjo de caracteres

Ex: char str-array [30] [80];

• Inicialização de Arranjos

Ex: int j[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9};

char str [14] = “Eu gosto de C”;

char str [14] = {‘E’, ‘u’, ‘ ‘, ‘g’, ‘o’, ‘s’, ‘t’, ‘o’, ‘ ‘, ‘d’, ‘e’, ‘ ‘, ‘C’, ‘\0’};

Ex: main ( ) int nbranco = 0; { int noutro = 0;

int c, j, nbranco, noutro; int ndigito[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0} int ndigito[10]; main ( ) nbranco = noutro = 0; { for (j = 0; j < 10; j ++) int c, j; ndigito[j] = 0; . . . . . . } }



Exemplos

• main () /* conta carac. na entrada */ main () { { long int nc; double int nc; nc = 0; for (nc = 0; getchar() != EOF; ++nc) while (getchar () != EOF) ; ++nc; printf (“%.0f\n”, nc); printf (“%ld\n”, nc); } }

• main () /* conta digitos, espaco em branco, outros caracteres */ { int c, j, nbranco, noutro; int ndigito [10]; nbranco = noutro = 0; for (j = 0; j < 10; ++j) ndigito [j] = 0; while ((c = getchar()) != EOF) if (c >= ‘0’ && c <= ‘9’) ++ndigito [c - ‘0’]; else if (c == ‘ ‘ || c== ‘\n’ || c == ‘\t’) ++nbranco; else ++noutro; printf (“digitos =“); for (j = 0; j < 10; j++) printf (“%d”, ndigito [j]); printf(“\nespacos em branco = %d, outros = %d\n”, nbranco, noutro);

}



Exemplos (continuação)

• /* exemplo do uso do continue */

for (j = 0; j < N; j++)

{ if (a[j] < 0) /* elementos negativos saltados */ continue; . . . /* elementos positivos processados */ }

• /* exemplo do uso do goto */

for (j = 0; j < N; j++)

for (k = 0; k < M; k++) if (v[j][k] < 0) goto achei; /* nao achei */ . . . achei:

/* achei na posicao j, k */



L I N G U A G E M C

E S T R U T U R A S E U N I Õ E S



Estruturas

• Pode-se criar combinações de tipos de dados básicos, utilizando struct e union

• Uma estrutura é uma coleção de uma ou mais variáveis que podem ser de tipos diferentes e que passam a ser referenciadas por um único nome

Forma Geral: struct tag { tipo nome-da variavel; tipo nome-da variavel; tipo nome-da variavel; . . . } variaveis-estruturas;

Ex: struct func struct func { { int matr; int matr; char nome [40]; char nome [40]; int setor; int setor; float salario; float salario; } serv1, serv2; }; struct func serv1, serv2;

• O operador ponto (.) é usado quando se quer referenciar um elemento individual de uma estrutura

Ex: serv1.setor = 2112;

serv1.salario = 2190000.21 • Estruturas admitem aninhamento



Uniões

• Uma union é definida quando duas ou mais variáveis compartilham a mesma área de memória

Ex: union qualq { char ch; int x; } aux1;

x

byte 1 byte 2

ch

Exemplos: struct data static int tab_dia[2][13] = { { {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31} int dia; {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31} int mes; }; int ano; int dia_ano; char nome_mes[4]; }; dia_do_ano(ad) /* acha o dia do ano a partir do dia do mes */ struct data *ad; { int j, dia, bissexto; dia = ad -> dia; bissexto = ad -> ano % 4 = = 0 && ad -> ano % 100 ! = 0 || ad -> ano % 400 = = 0; for ( j = 1; j < ad -> mes; j++) dia = dia + tab_dia[bissexto][j]; return(dia); }



• Exemplos (continuação)

• #define SIM 1 #define NAO 0 main( ) /* conta linhas, palavras, caracteres na entrada */ { int c, nl, np, nc, empalavra; empalavra = NAO; nl = np = nc = 0; while ((c = getchar( ) ) != EOF) { nc++; if (c = = ‘\n’) nl++; if (c = = ‘ ‘ || c = = ‘\n’ || c = = ‘\t’) empalavra = NAO; else if (empalavra = = NAO) { empalavra = SIM; np++; } } }

• atoi (s) /* funcao que converte um string de números s em um inteiro */

{ int j, n = 0; for ( j = 0; s[j] >= ‘0’ && s[j] <= ‘9’; ++j) n = 10 * n + s[j] - ‘0’; return (n);

}




• comprime (s, c) /* remove todos os c de s */ char s[ ]; int c; { int j, k; for (j = k = 0; s[j] != ‘\0’; j++) if (s[j] != c) s[k++] = s[j]; s[k] = ‘\0’; }

• contabits (n) /* conta os bits ligados em n */ unsigned n; { int b; for (b = 0; n != 0; n >>= 1) if (n & 01) b++; return (b); }




• pesq-binaria(x, v, n) /* acha x em v[0] ... v[n-1] */ int x, v[ ], n;

{ int inicio, fim, meio; inicio = 0; fim = n -1; while (inicio <= fim) { meio = (inicio + fim) / 2; if (x < v[meio]) fim = meio - 1; else if (x > v[meio]) inicio = meio + 1; else /* achou */ return(meio); } return (-1); }



• Exemplos (continuação) /* imprimir a tabela de conversão Fahrenheit-Celsius para f = 0, 20, ..., 300 */

• main( ) { int inicio = 0, /* limite inferior da tabela */ fim = 300, /* limite superior */ incr = 20; /* incremento */ float fahr, celsius; fahr = inicio; while (fahr <= fim) { celsius = (5.0 / 9.0) * (fahr - 32.0); printf(“%4.0f %6.1f\n”, fahr, celsius); fahr = fahr + incr; } }

• /* imprimir a tabela de conversão Fahrenheit-Celsius para f = 0, 20, ..., 300 */

#define INICIO 0 /* limite inferior da tabela */

#define FIM 300 /* limite superior */ #define INCR 20 /* incremento */ main( ) { int fahr; for (fahr = INICIO; fahr <= FIM; fahr += INCR) printf(“%4.0f %6.1f\n”, fahr, (5.0 / 9.0) * (fahr - 32)); }



L I N G U A G E M C

F U N Ç Õ E S



Uso de Funções • Funções dividem grandes tarefas de computação em partes menores e simples

• Um programa é estruturado em C como um conjunto de definições individuais

de funções

• O programa fonte pode ser dividido em arquivos múltiplos

Funções em C • Comunicação feita por argumentos e valores retornados

• O return define um mecanismo para retornar um valor de uma função

chamada para a sua chamadora

• As funções podem ocorrer em qualquer ordem no arquivo fonte

• C permite que declaremos o tipo que uma função irá retornar

• A rotina chamadora deve estabelecer que a função chamada retorna um valor

não inteiro

• Por “default”, o tipo de uma função é int

Passagem de Estruturas para Funções • Pode se pssar um elemento de uma estrutura por valor

Ex: struct exemplo {

char x;

int y;

} ex;

func1 (ex.x);



• Passagem do endereço de um componente

Ex: func2 (&ex.x);

• Passagem de uma Estrutura por referência

func3 (&ex);



Exemplos do uso de Funções

• double fatorial (num) int num; /* Retorna o fatorial de um numero. Se um erro ocorre, ela retorna o valor -1 e emite uma mensagem */ { double aux, fact; if (num < 0) { printf (“\n Erro: fatorial de um numero negativo!”); fact = -1.0; } else { fact = 1.0; for (aux = num; aux > 0: aux --) fact *= aux; } return (fact); }

• atoi (s) /* converte um string num inteiro */ char s[ ];

{ int j, n, sinal; for (j = 0; s[j] == ‘ ‘ || s[j] == ‘\n’ || s[j] == ‘\t’; j++) ; /* pula espacos em branco */ sinal = 1; if (s[j] == ‘+’ || s[j] == ‘-’) /* sinal */ sinal = (s[j++] == ‘+’) ?1:-1; for (n = 0; s[j] >= ‘0’ && s[j] <= ‘9’; j++) n = 10 * n + s[j] - ‘0’; return(sinal * n); }



Utilização de Parâmetros

• A passagem de argumentos pode ser feita por:

• valor

• referência (endereço), por exemplo, o endereço de um arranjo

• As funções em C aceitam um número variável de argumentos (não

transportável)

• As variáveis externas (globais) são definidas fora de qualquer função e ficam

disponíveis para qualquer função

• As funções são sempre externas (não há aninhamento)

• Deve-se usar variáveis externas quando há um grnde número de funções que

fazem uso das mesmas

• O escopo de um nome é a parte do programa para o qual o nome é definido

• Para variáveis automáticas (locais) e argumentos, o escopo é a função em que o

nome é definido

• Num programa C deve ter pelo menos a função main ( ) onde começa a

execução

• A função main ( ) tem dois argumentos:

• argc

• argv [ ]



Funções de Entrada e Saída As funções de entrada e saída estão definidas no arquivo header “stdio.h”

• A Função Printf

Permite a impressão de quantidades numéricas, strings, caracteres, etc.

Forma Geral:

printf (controle, arg1, arg2, ... )

caracteres ordinários e especificações de conversão ( % )

• Entre o % e o caractere de conversão pode haver:

⇒ sinal de menos ⇒ cadeia de dígitos (tamanho mínimo) ⇒ um ponto ⇒ cadeia de dígitos ⇒ modificador de tamanho (l)

• Caracteres de conversão: d, o, x, u, c, s, e, f e g Ex:

printf(“fatorial de %d = %g\n”, num, fatorial(num));

• Por “default” todos os tipos são ajustados à direita, para ajustar à esquerda inclua o caractere ‘-’



Formato Significado

%c caracter %d inteiro decimal com sinal %i inteiro decimal com sinal %e notação científica com e %E notação científica com E %f ponto flutuante decimal %g escolhe %e ou %f ,o menor dos dois formatos %G escolhe %E ou %f ,o menor dos dois formatos %o octal %p imprime o endereço de um ponteiro %s cadeia de caracteres %u inteiro decimal sem sinal %x hexadecimal sem sinal (letras minúsculas) %X hexadecimal sem sinal (letras maiúsculas) %% imprime o caracter ‘%’

Formatos para o comando printf



• Exemplo

main ( ) {

int num; double fatorial; printf (“\n Entre com um numero:”); scanf (“%d”, &num);

printf (“\n Fatorial de %d %f\n”, num, fatorial(num)); } double fatorial (x) int x; /* Calcula o fatorial de um numero recursivamente. Retorna um valor negativo se recebe como parametro um numero negativo */ { if (x < 0) { printf (“\n Erro: fatorial de um numero negativo!!!); return (-1); } else if (x == 0) return (1); else return (x * fatorial (x - 1));

}



• A função Scanf

Usada para a entrada (leitura) de dados, para string ler até o primeiro espaço em branco, ou o return, ou o tab. Forma Geral:

scanf ( controle, arg1, arg2, . . .)

Devem ser apontadores Análogo ao printf A cadeia de controle pode conter

⇒ Espaços em branco ⇒ Caracteres ordinários ⇒ Especificações de conversão ⇒ Um número (opcional) especificando o tamanho do campo ⇒ Caracteres de conversão

• Caracteres de conversão aceitos: d, o, x, h, c, s e f Ex: Note que a função scanf está usando passagem de parâmetros por referência #include <stdio.h> main ( ) /* calculadora elementar */ { double soma, v; soma = 0; while (scanf (“%lf”, &v) != EOF) printf (“\t%.2f\n”, soma += v); }



• Os caracacteres d, o, x e f podem ser precedidos por l

Formato Significado %c lê um caracter %d lê um inteiro decimal com sinal %i lê um inteiro decimal com sinal %e lê um número ponto flutuante %f lê um número ponto flutuante %g lê um número ponto flutuante %o lê um octal %p lê o endereço de um ponteiro %s lê uma cadeia de caracteres %u lê um inteiro sem sinal %x lê um hexadecimal sem sinal

Formatos para o comando scanf



L I N G U A G E M C

A P O N T A D O R E S ( P O I N T E R S )



Apontadores

• Um apontador é uma variável que contém o endereço de outra variável

• Levam a um código mais compacto e eficiente (disciplina) • É aplicado apenas a variáveis, elementos de arranjos e elementos de estruturas • O operador unário & fornece o endereço de um objeto

Ex: px = &x;

• O operador unário * trata seu operando como endereço Ex: y = *px;

• É necessário haver declaração de tais variáveis

Ex: int x, y; int *px; • Podem ocorrer em expressões (os operadores * e & têm precedência sobre

os demais operadores) Ex: y = *px + 1; ≠ * ( px + 1 )

*px = 0; (*px) ++;



Apontadores e Argumentos de Funções

• Apontadores são utilizados quando se quer passar valores por referência • O programa chamador passa apontadores para as variáveis que se quer

atualizar

Ex: troca (ax, ay) /* permuta *ax e *ay */ int *ax, *ay; { int temp; temp = *ax; *ax = *ay; *ay = temp; }

• Uso comum quando uma função deve retornar mais de um valor Ex: leint (an) /* le proximo caracter da entrada */

int *an; { int c, sinal; while (( c = getch( )) = = ‘ ‘ || c = = ‘\n’ || c = = ‘\t’) ; /* pula espaco em branco */ sinal = 1; if (( c = = ‘+’ || c = = ‘-’) /* guarda o sinal */ { sinal = (c = = ‘+’) ? 1 : -1; c = getch ( ); } for (*an = 0; c >= ‘0’ && c <=‘9’; c = getch ( )) *an = 10 ** an + c - ‘0’; *an *= sinal; if (c != EOF) ungetch ( c); return (c); }



Apontadores e Arranjos

• Existe um relacionamento muito estreito entre arranjos e apontadores

Ex: int a[10]; int *pa; pa = &a[0]; /* pa = a */ x = *(pa + 1) /* refere-se ao conteudo de a[1] */

• Obs: a[j] é idêntico a *( a + j ) • Qualquer arranjo e expressão indexada podem ser escritos como um

apontador e deslocamento ( vice-versa ) • É possível passar parte de um arranjo para uma função

Aritmética com Endereços

• Se p é um apontador, então p++ faz p apontar para o próximo elemento, independente do tipo para o qual p aponta

Ex: strlen (s) /* retorna o tamanho da cadeia s */ char *s; { char *ap = s; while (*ap != ‘\0’) ap++; return (ap - s); }



• Operações permitidas com apontadores: adição/subtração com inteiro; adição/subtração/comparação de dois apontadores NULL e p < q

Apontadores de Caractere e Funções

• Quando uma cadeia de caracteres aparece num programa, o acesso a mesma é feito através de um apontador de caractere

Ex: char *mensagem; mensagem = “sou uma cadeia”; strcpy (s, t) /* copia t em s */ strcpy (s, t) /* copia t em s*/ char s[ ], t[ ]; char *s, *t; { { int j; while ((*s++ = *t++) != ‘\0’) ; j = 0; } while ((s[j] = t[j] != ‘\0’) j++; }

Note que: *++p ≠ *p++

• É possível criar apontadores para apontadores Ex: int *tab_dia[13]; arranjo de apontadores



• Arranjos de apontadores podem ser incializados

Ex: char *nome_mes (n) /* retorna o nome do n-esimo mes */ int n; { static char *nome[ ] = { “mes ilegal”, “janeiro”, “fevereiro”, . . . “dezembro” }; return ((n < 1 || n > 12) ? nome[0] : nome[n]); }

Apontadores para Funções

• É possível definir um apontador para uma função • Tal apontador pode ser manipulado, passado como argumento, colocado em

arranjos, etc.

• Note que: int (*comp) ( ) != int *comp( )



Apontadores para Estruturas

Ex: struct addr *addr-pointer;

• A referência para um elemento de uma estrutura através de um apontador para esta estrutura é feita usando o operador “->“

Ex: struct exemplo {

float numero; char nome [80]; } pessoa; struct exemplo *ptr; ptr = &pessoa; ptr -> nome = “Luis”; • Argumentos da Linha de Comando

• Os únicos argumentos permitidos para a função main são argc e argv

apontador para os argumentos passados

número de argumentos da linha de comando Ex: main (argc, argv) int argc; char *argv[ ]; { if (argc < 2) printf (“Entre com seu nome na linha de comando\n”); else printf(“Ola’ %s\n”, argv[1]); }



• argv[0] é o nome do programa e argv[1] é o primeiro argumento

Função para abrir e fechar arquivos

• Existência de um apontador de arquivo Ex: FILE *fp, *fopen ( ); fp = fopen (nome, modo);

• Os modos de abertura podem ser os seguintes: “r” - leitura “w” - gravação “a” - adição

• O apontador nulo, NULL, é retornado se há um erro

• fclose ( ) para fechar arquivos

Leitura e Gravação em Arquivos

• Para ler ou gravar num arquivo, pode-se usar: getc ( ), putc ( ), fscanf ( ), fprintf ( )

Ex: c = getc (fp); putc (c, fp);



Exemplos

#include <stdio.h>

main (argc, argv) /* cat: concatena arquivos */ int argc; char *argv[ ]; { FILE *fp, *fopen ( );

if (argc = = 1) /* nao tem argumentos; copia entrada padrao */ copia_arq (stdin); else while (--argc > 0) if ((fp = fopen (*++argv, “r”)) = = NULL) { fprintf (stderr, “Erro: cat nao pode abrir %s\n”, *argv); exit (1); } else

{ copia_arq (fp); fclose (fp); }

exit (0); } copia_arq (fp) /* copia arquivo fp na saida padrao */ FILE *fp; { int c; while ((c = getc (fp) != EOF) putc (c, stdout); }



O Preprocessador C

• Uma linha do tipo #include “nome_arquivo”

é substituída pelo conteúdo de nome_arquivo

• Substituição de macros: #define TRUE 1

• Exemplo: #define max (A, B) ((A) > (B) ? (A) : (B))

LINGUAGEM DE PROGRAMAÇÃO C - inf.ufg.breduardo/so/CURSO-C.pdf · UFPE - Departamento de...

Documents

Transcript of LINGUAGEM DE PROGRAMAÇÃO C - inf.ufg.breduardo/so/CURSO-C.pdf · UFPE - Departamento de...