MANUAL DE C - Clientes Netvisaoclientes.netvisao.pt/paraujob/menu/informatica/c/manualc.pdf · C if e for , por exemplo, só podem ser escritos em minúscula, caso contrário o compilador

Manual de Linguagem C

ECB - PAULO VALENTIM 1

MANUAL DE C

PAULO VALENTIM



ÍNDICEPrimeiros Programas ..............................................................................................................................7

Funcionamento do programa......................................................................................................... 10Introdução Básica às Entradas e Saídas................................................................................................. 11

Caracteres ........................................................................................................................................ 11Funções de leitura da caracteres ........................................................................................................ 12Strings.............................................................................................................................................. 12

TabelA ASCII .............................................................................................................................. 15Códigos de Retorno de Teclas....................................................................................................... 16printf ............................................................................................................................................ 17scanf............................................................................................................................................. 18

VARIÁVEIS, CONSTANTES, OPERADORES E EXPRESSÕES....................................................... 19Nomes de Variáveis.......................................................................................................................... 19Os Tipos do C .................................................................................................................................. 20

Tipos de variáveis em C :.............................................................................................................. 20Declaração e Inicialização de Variáveis ............................................................................................ 22Varáveis Globais e Locais ................................................................................................................ 22

Identificadores de Variáveis.......................................................................................................... 24Constantes........................................................................................................................................ 24

Constantes dos tipos básicos ......................................................................................................... 24Constantes strings......................................................................................................................... 24Constantes de barra invertida ........................................................................................................ 25

Funções para o ecrã.............................................................................................................................. 28A função clrcscr ............................................................................................................................... 28A função clreol................................................................................................................................. 28A função gotoxy ............................................................................................................................... 29As funções wherex\wherey ............................................................................................................... 29A função window ............................................................................................................................. 29A função delline ............................................................................................................................... 29A função insline ............................................................................................................................... 29

Operadores Aritméticos e de Atribuição................................................................................................ 30Operador de Atribuição .................................................................................................................... 32

Operadores Relacionais e Lógicos ........................................................................................................ 33Expressões ........................................................................................................................................... 34

Expressões que Podem ser Abreviadas.............................................................................................. 34Modeladores (Casts)......................................................................................................................... 35

Comandos de Controle de Fluxo........................................................................................................... 39O comando if.................................................................................................................................... 39

Operadores de comparação ........................................................................................................... 40O comando else ................................................................................................................................ 40

O if-else-if .................................................................................................................................... 41A expressão condicional ................................................................................................................... 42O Operador Ternário ?...................................................................................................................... 42O Comando switch ........................................................................................................................... 44O comando for ................................................................................................................................. 47

O ciclo infinito ............................................................................................................................. 47O ciclo sem conteúdo.................................................................................................................... 49

O Comando while............................................................................................................................. 50O Comando do-while ....................................................................................................................... 52Comando break ................................................................................................................................ 53O Comando continue........................................................................................................................ 53

MATRIZES ......................................................................................................................................... 58VECTORES..................................................................................................................................... 58Strings.............................................................................................................................................. 60Funções básicas para manipulação de strings .................................................................................... 61

strcpy ........................................................................................................................................... 61strcat ............................................................................................................................................ 61strlen ............................................................................................................................................ 62strcmp .......................................................................................................................................... 62



Matrizes bidimensionais ................................................................................................................... 62Matrizes de strings ........................................................................................................................... 63Matrizes multidimensionais .............................................................................................................. 64Inicialização ..................................................................................................................................... 65

Inicialização sem especificação de tamanho .................................................................................. 65A Função ............................................................................................................................................. 68

Protótipos de Funções....................................................................................................................... 68O Comando return............................................................................................................................ 68O Tipo void...................................................................................................................................... 70Arquivos-Cabeçalhos........................................................................................................................ 72Passagem de parâmetros por valor e passagem por referência............................................................ 74Vectores como Argumentos de Funções............................................................................................ 76

Os Argumentos argc e argv................................................................................................................... 77Argumentos de funções para main .................................................................................................... 77

Recursividade ...................................................................................................................................... 80As Directivas de Compilação................................................................................................................ 81

A Directiva include .......................................................................................................................... 81As Directivas define e undef ............................................................................................................. 82As Directivas ifdef e endif ................................................................................................................ 83A Directiva ifndef............................................................................................................................. 84A Directiva if ................................................................................................................................... 85A Directiva else................................................................................................................................ 85A Directiva elif................................................................................................................................. 86

PONTEIROS ....................................................................................................................................... 87Como Funcionam os Ponteiros.......................................................................................................... 87Declarando e Utilizando Ponteiros .................................................................................................... 87

Ponteiros e Vectores............................................................................................................................. 91Vectores como ponteiros................................................................................................................... 91

Estruturas............................................................................................................................................. 95O que é uma estrutura? ..................................................................................................................... 95Criar uma estrutura utilizando a linguagem C.................................................................................... 96Declarar variáveis do tipo struct ....................................................................................................... 97

Variáveis globais .......................................................................................................................... 97Variáveis locais ............................................................................................................................ 98

Aceder aos campos de um tipo struct ................................................................................................ 98Inserir dados nos campos de uma estrutura .................................................................................... 99Visualizar dados dos campos de uma estrutura ............................................................................ 100

Vectores do tipo struct.................................................................................................................... 101O Comando typedef............................................................................................................................ 104O comando sizeof............................................................................................................................... 105Alocação Dinâmica – o comando malloc ............................................................................................ 106

malloc ............................................................................................................................................ 106O comando free.................................................................................................................................. 108Passando variáveis do tipo struct para funções .................................................................................... 109

Passagem por valor..................................................................................................................... 109Passagem por referência.............................................................................................................. 110

Apontadores para estruturas e estruturas dentro de estruturas............................................................... 112Apontadores para estruturas............................................................................................................ 112Estruturas dentro de estruturas ........................................................................................................ 112

Uniões................................................................................................................................................ 114arquivos ............................................................................................................................................. 116

Abrir e Fechar um Arquivo ............................................................................................................. 116fopen .......................................................................................................................................... 116exit ............................................................................................................................................. 118fclose.......................................................................................................................................... 118

Lendo e Escrevendo Caracteres em Arquivos .................................................................................. 119putc ou fputc............................................................................................................................... 119getc ou fgetc ............................................................................................................................... 119feof............................................................................................................................................. 120fgets ........................................................................................................................................... 121



fputs ........................................................................................................................................... 121ferror e perror ............................................................................................................................. 122fread........................................................................................................................................... 122fwrite.......................................................................................................................................... 123fseek........................................................................................................................................... 123rewind ........................................................................................................................................ 124remove ....................................................................................................................................... 124

Fluxos Padrão................................................................................................................................. 125fprintf ......................................................................................................................................... 125fscanf ......................................................................................................................................... 125

ESTRUTURAS E FICHEIROS.......................................................................................................... 126



INTRODUÇÃO AO C

Uma das grandes vantagens do C é que ele possui tanto características de "alto nível" quanto de "baixo

nível".

O C nasceu na década de 70. O seu inventor, Dennis Ritchie, implementou-o pela primeira vez usando

um DEC PDP-11 correndo o sistema operacional UNIX. 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.

O C é uma linguagem de programação genérica que é utilizada para a criação de programas diversos

como processadores de texto, sistemas operativos, programas de comunicação, programas para a

automação industrial, gestores de base de dados, programas de projecto assistido por computador,

programas para a solução de problemas da Engenharia, Física, Química e outras Ciências, etc ...

Este manual aborda a estrutura do ANSI C, o C padronizado pela ANSI e ainda algumas funções comuns

em compiladores para alguns sistemas operativos.



PRINCIPAIS CARACTERÍSTICAS

Como principais características da linguagem «C», temos:

Alto grau de portabilidade, que permite que os seus programas fonte sejam transportados entre máquinas

sem grandes problemas

É de uso geral, sendo eficiente tanto para programação de utilitários, como para sistemas operativos,

processadores de texto, bases de dados e sistemas aplicativos em geral.

Gera código executável (objecto) compacto e rápido em relação à maioria das outras linguagens

compiladas, tornando a sua aplicação eficiente para micro-computadores de memória reduzida.

Permite total interacção com o sistema operativo e inserção de código «assembly» no programa fonte,

sendo assim ilimitada por software.

Possui uma sintaxe de poucos comandos e um grande número de operadores aritméticos e lógicos.

É uma linguagem estruturada e modular, o que permite a simplificação do uso das mais modernas

técnicas de programação.

Permite estruturas de dados compostos na forma de registos e campos.

O C É "CASE SENSITIVE"

O C é "Case Sensitive", isto é, maiúsculas e minúsculas fazem diferença. Se se declarar 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úscula, caso contrário o compilador não irá

interpretá-los como comandos, mas sim como variáveis.



PRIMEIROS PROGRAMAS

Compilando e executando este programa dará como resultado a mensagem Olá! Eu

estou vivo! no ecrã.

Análise do programa por partes:

A linha #include <stdio.h> diz ao compilador que ele deve incluir o arquivo-cabeçalho

(biblioteca) stdio.h.

O C possui diversos arquivos-cabeçalhos (bibliotecas).

Quando se faz um programa, uma boa ideia é usar comentários que ajudem a elucidar o

funcionamento do mesmo. No caso acima tem-se um comentário: /* Um Primeiro

Programa */.

Neste arquivo existem declarações de funções úteis para entrada e saída dedados (std = standard, padrão em inglês; io = Input/Output, entrada e saída==> stdio = Entrada e saída padronizadas).

O compilador C desconsidera qualquer coisa que esteja começando com /* eterminando com */. Um comentário pode, inclusive, ter mais de uma linha.

Outra forma aceite pelo C para utilizar comentários é utilizar os

caraceteres //. O C neste caso não considera a linha que tem como inícioos caracteres //. Este tipo de comentário só pode ter uma linha.

Veja-se um primeiro programa emC:

#include <stdio.h>void main () /* Um Primeiro Programa */

printf ("Olá! Eu estou vivo!\n");

O mesmo programa em Pascal:

program primeiro;uses crt;begin

Um Primeiro Programawriteln ("Olá! Eu estou vivo!");

end.



A linha void main() define uma função de nome main. Todos os programas em C têm

que ter uma função main, pois é esta função que será chamada quando o programa for

executado.

O conteúdo da função é delimitado por chavetas .

O código que estiver dentro das chavetas será executado sequencialmente quando a

função for chamada. A palavra void indica que esta função não retorna nada, isto é seu

retorno é vazio. Posteriormente, ver-se-á que as funções em C podem retornar valores.

A única coisa que o programa realmente faz é chamar a função printf(), passando a

string (uma string é uma sequência de caracteres, como se verá brevemente) "Olá! Eu

estou vivo!\n" como argumento.

É por causa do uso da função printf() pelo programa que se deve incluir o arquivo-

cabeçalho stdio.h . A função printf() neste caso irá apenas colocar a string no ecrã do

computador.

O \n é uma constante chamada de constante barra invertida. No caso, o \n é a

constante barra invertida de "nova linha" e ela é interpretada como um comando de

mudança de linha, isto é, após imprimir Olá! Eu estou vivo! o cursor passará para a

próxima linha.

É importante observar também que os comandos do C terminam com ; .

Exemplo de um programa um pouco mais complicado:

#include <stdio.h> void main () int Dias; // Declaração deVariáveis float Anos; printf ("Entre com o número de dias: "); /* Entrada deDados */ scanf ("%d",&Dias);



Anos=Dias/365.25; /* Conversão Dias->Anos */ printf ("\n\n%d dias equivalem a %f anos.\n",Dias,Anos);



Funcionamento do programa

São declaradas duas variáveis chamadas Dias e Anos. A primeira é um int (inteiro) e a segunda um float

(ponto flutuante, real). É feita então uma chamada à função printf(), que coloca uma mensagem no ecrã.

É necessário ler um dado que será fornecido pelo utilizador e colocá-lo na variável Dias.

Para isso utiliza-se a função scanf(). A string "%d" diz à função que se irá ler um inteiro. O segundo

parâmetro passado à função diz que o dado lido deverá ser armazenado na variável Dias.

É importante colocar um & antes do nome da variável a ser lida quando se usa a função scanf(). O motivo

disto só ficará claro mais tarde.

Observe-se que, no C, quando se tem mais de um parâmetro para uma função, eles serão separados por

vírgula.

Fica-se então com uma expressão matemática simples que atribui a Anos o valor de Dias dividido por

365.25. Como Anos é uma variável float o compilador fará uma conversão automática entre os tipos das

variáveis (mais detalhes num outro capítulo).

A segunda chamada à função printf() tem três argumentos.

A string "\n\n%d dias equivalem a %f anos\n” diz à função para dar dois enter (passar para a próxima

linha e depois para a subsequente), colocar um inteiro no ecrã, colocar a mensagem " dias equivalem a ",

colocar um valor float no ecrã, colocar a mensagem " anos." e dar mais um enter.

Os outros parâmetros são as variáveis das quais devem ser lidos os valores do inteiro e do float,

respectivamente.

ExercícioO que faz o seguinte programa?

#include <stdio.h> main() int x; scanf("%d",&x); printf("%d",x);



INTRODUÇÃO BÁSICA ÀS ENTRADAS E SAÍDAS

CARACTERES

Os caracteres são um tipo de dados: o char e o C trata os caracteres como sendo

variáveis de um byte (8 bits), ou seja ocupa um byte de memória.

Um bit é a menor unidade de armazenamento de informações num computador.

Na linguagem C, também se pode usar um char para armazenar valoresnuméricos inteiros, além de usá-lo para armazenar caracteres detexto. Para indicar um caracter de texto usa-se apóstrofes.

Exemplo de programa que usa caracteres:

#include <stdio.h>int main ()

char Ch;Ch='D';printf ("%c",Ch);return(0);

No programa acima, %c indica que printf() deve colocar um caracter no ecrã. Um char

também é usado para armazenar um número inteiro. Este número é conhecido como o

código ASCII correspondente ao caracter.


char Ch;Ch='D';printf ("%d",Ch); /* Imprime o caracter como inteiro */return(0);

Este programa vai imprimir o número 68 no ecrã, que é o código ASCII (ver tabela

ASCII) correspondente ao caracter 'D' (d maiúsculo).



FUNÇÕES DE LEITURA DA CARACTERES

Função Forma Geral Explicação

scanf scanf (“%c”, &variável); Coloca o caracter inserido no identificador variável

imprimindo-o no ecrã. O sistema só lê o caracter

depois de pressionada a tecla enter.

getch variável = getch( ); Retorna um caracter para o identificador variável sem

o imprimir no ecrã sem ser necessário premir a tecla

enter (pode ser encontrada na biblioteca conio.h).

getche variável = getche( ); Retorna um caracter para o identificador variável

imprimindo-o no ecrã sem ser necessário premir a tecla

enter (pode ser encontrada na biblioteca conio.h).

Eis um exemplo que usa a função getch(), e seu correspondente scanf():

STRINGS

No C uma string é um vector de caracteres terminado com um caracter nulo. O caracter

nulo é um caracter com valor inteiro igual a zero (código ASCII igual a 0). O

terminador nulo também pode ser escrito usando a convenção de barra invertida do C

como sendo '\0'. Embora o assunto vectores seja discutido posteriormente, são

apresentados aqui os fundamentos necessários para se poder utilizar as strings.

#include <stdio.h>#include <conio.h>int main () char Ch; Ch=getch(); printf ("Você pressionou a tecla %c",Ch); return(0);

#include <stdio.h>int main () char Ch; scanf("%c", &Ch); printf ("Você pressionou a tecla %c",Ch); return(0);



Para declarar uma string usa-se o seguinte formato geral:

char nome_da_string[tamanho];

Isto declara um vector de caracteres (uma string) com número de posições igual atamanho.

Tem que se reservar um caracter para ser o terminador nulo (\0), tem que se declararo comprimento da string como sendo, no mínimo, um caracter maior que a maiorstring que pretendemos armazenar.

Suponha-se que declara uma string de 6 posições e se coloca a palavra João nela.Teremos:

J o ã o \0 ...

No caso acima, a célula não usada tem um valor indeterminado. Isto acontece porque o

C não inicializa variáveis, cabendo ao programador esta tarefa. Se for necessário ler

uma string fornecida pelo utilizador pode-se usar a função gets(). Um exemplo do uso

desta função é apresentado abaixo. A função gets() coloca o terminador nulo (\0) na

string, quando se prime a tecla "Enter".

#include <stdio.h>int main () char string[100]; printf ("Digite uma string: "); gets (string); printf ("\n\nVoçê digitou %s",string); return(0);

Neste programa, o tamanho máximo da string que pode ser lida é uma string de 99

caracteres. Caso se insira uma string de comprimento maior, o programa irá aceitar, mas

os resultados podem ser desastrosos.

Como as strings são vectores de caracteres, para se aceder a um determinado caracter de

uma string, basta "indexar", ou seja, usa-se um índice para aceder ao caracter desejado

dentro da string.



Exemplo para aceder à segunda letra de str.

printf(“%c”, str[1] );

Por quê se está a aceder à segunda letra e não à primeira?

Na linguagem C, o índice começa em zero. Assim, a primeira letra da string sempre

estará na posição 0. A segunda letra sempre estará na posição 1 e assim sucessivamente.

Exemplo que imprimirá a segunda letra da string "João" apresentada acima. De seguida,

ele mudará esta letra e apresentará a string no final.

#include <stdio.h>int main() char str[10] = "João"; printf("\n\nString: %s", str); printf("\nSegunda letra: %c", str[1]); str[1] = 'U'; printf("\nAgora a segunda letra é: %c", str[1]); printf("\n\nString resultante: %s", str); return(0);

Nesta string, o terminador nulo está na posição 4. Das posições 0 a 4, sabe-se que

existem caracteres válidos, e portanto pode-se escrevê-los.

No programa acima, %s indica que printf() deve colocar uma string no ecrã.



TabelA ASCIIValor ASCII Caracter Valor ASCII Caracter Valor ASCII Caracter Valor ASCII Caracter Valor ASCII Caracter

000 NUL 054 6 108 l 162 ó 216

001 055 7 109 m 163 ú 217

002 056 8 110 n 164 ñ 218

003 ♥ 057 9 111 o 165 Ñ 219

004 ♦ 058 : 112 p 166 ª 220

005 ♣ 059 ; 113 q 167 º 221

006 ♠ 060 < 114 r 168 ¿ 222

007 (BEL) 061 = 115 s 169 Ò 223

008 (BS) 062 > 116 t 170 224 α009 (HT) 063 ? 117 u 171 ½ 225 β010 (LF) 064 @ 118 v 172 ¼ 226 Γ011 (VT) 065 A 119 w 173 i 227 π012 (FF) 066 B 120 x 174 « 228 ∑013 (CR) 067 C 121 y 175 » 229 σ014 068 D 122 z 176 230 µ015 069 E 123 177 231 τ016 Ø 070 F 124 | 178 232 Φ017 × 071 G 125 179 233 θ018 × 072 H 126 ~ 180 234 Ω019 !! 073 I 127 181 235 δ020 ¶ 074 J 128 Ç 182 236 ∞021 § 075 K 129 ü 183 237 ∅022 076 L 130 é 184 238 ∈023 077 M 131 â 185 239 ∩024 á 078 N 132 ã 186 240 ≡025 â 079 O 133 à 187 241 ±026 à 080 P 134 Á 188 242 ≥027 (ESC) 081 Q 135 ç 189 243 ≤028 (FS) 082 R 136 ê 190 244 ⌠029 (GS) 083 S 137 Ê 191 245 ⌡030 (RS) 084 T 138 è 192 246 ÷031 (US) 085 U 139 Ì 193 247 ≈032 (ESPAÇ) 086 V 140 Ô 194 248 °033 ! 087 W 141 ì 195 249 •034 " 088 X 142 Ã 196 250 .035 # 089 Y 143 Â 197 251 √036 $ 090 Z 144 É 198 252 η037 % 091 [ 145 À 199 253 2038 & 092 \ 146 È 200 254

039 ' 093 ] 147 ô 201 255

040 ( 094 ^ 148 õ 202

041 ) 095 - 149 ò 203

042 * 096 ` 150 Ú 204

043 + 097 a 151 ù 205

044 ´ 098 b 152 Ì 206

045 - 099 c 153 Õ 207

046 . 100 d 154 Ü 208

047 / 101 e 155 ¢ 209

048 0 102 f 156 £ 210

049 1 103 g 157 Ù 211

050 2 104 h 158 Pt 212

051 3 105 i 159 Ó 213

052 4 106 j 160 á 214

053 5 107 k 161 í 215



Códigos de Retorno de TeclasTecla S/shift C/shift Ctrl Alt Tecla S/shift C/shift Ctrl Alt

A 97 65 1 030 5 53 37 024

B 98 66 2 048 6 54 94 025

C 99 67 3 046 7 55 38 026

D 100 68 4 032 8 56 42 027

E 101 69 5 018 9 57 40 028

F 102 70 6 033 PrtsC 42 0114

G 103 71 7 034 Esc 27 27 27

H 104 72 8 035 F1 059 084 094 0104

I 105 73 9 023 F2 060 085 095 0105

J 106 74 10 036 F3 061 086 096 0106

K 107 75 11 037 F4 062 087 097 0107

L 108 76 12 038 F5 063 088 098 0108

M 109 77 13 050 F6 064 089 099 0109

N 110 78 14 049 F7 065 090 0100 0110

O 111 79 15 024 F8 06 091 0101 0111

P 112 80 16 025 F9 067 092 0102 0112

Q 113 81 17 016 F10 068 093 0103 0113

R 114 82 18 019 S/Esq 075 52 0115 0178

S 115 83 19 031 S/Dir 077 54 0116 0180

T 116 84 20 020 S/Cim 072 56 0160 0175

U 117 85 21 022 S/Bx 080 50 0164 0183

V 118 86 22 047 Home 071 55 0174

W 119 87 23 017 End 079 49 0117 0182

X 120 88 24 045 PgUp 073 57 0132 0176

Y 121 89 25 021 PgDn 081 51 0118 0184

Z 122 90 26 044 Ins 082 48 0165 0185

0 48 41 029 Del 083 46 0166 0186

1 49 43 020 Bksp 8 8

2 50 64 021 Tab 9 015

3 51 35 022 Enter 13 13 10

4 52 36 023

Os códigos de teclas iniciados por 0 (zero) devolvem dois valores em tempos distintos (o número 0 eo seguinte). São chamados de caracteres especiais.



printf

A função printf() tem a seguinte forma geral:

printf (string_de_controle,lista_de_argumentos);

Tem-se, na string_de_controle, uma descrição de tudo que a função vai colocar no ecrã.

A string de controle mostra não apenas os caracteres que devem ser colocados no ecrã,

mas também quais as variáveis e suas respectivas posições. Isto é feito usando-se os

códigos de controle, que usam a notação %. Na string de controle indica-se quais, de

qual tipo e em que posição estão as variáveis a serem apresentadas. É muito importante

que, para cada código de controle, se tenha um argumento na lista de argumentos.

Alguns dos códigos %:

Código Significado%d, %i Inteiro

%f Real

%c Caracter

%s String

%% Coloca % no ecrã

Alguns exemplos de printf() e o que eles exibem:

Código Output

printf ("Teste %% %%") "Teste % %"

printf ("%f",40.345) "40.345"

printf ("Um caracter %c e um inteiro %d",'D',120) "Um caracter D e um inteiro 120"

printf ("%s e um exemplo","Este") "Este e um exemplo"

printf ("%s%d%%","Juros de ",10) "Juros de 10%"



scanf

O formato geral da função scanf() é:

scanf (string-de-controle, lista-de-argumentos);

Usando a função scanf() pode-se pedir dados ao utilizador. Um exemplo de uso, pode

ser visto acima. É importante colocar o mesmo número de argumentos que o de códigos

de controle na string de controle, assim como colocar o & antes das variáveis da lista de

argumentos.

Exercícios

Escreva um programa que leia um caracter digitado pelo utilizador, imprima o caracterdigitado e o código ASCII correspondente a este caracter.

Escreva um programa que leia duas strings e as coloque no ecrã. Imprima também asegunda letra de cada string.



VARIÁVEIS, CONSTANTES, OPERADORES EEXPRESSÕES

NOMES DE VARIÁVEIS

As variáveis no C podem ter qualquer nome se duas condições forem satisfeitas:

o nome deve começar com uma letra ou sublinhado (_)

os caracteres subsequentes devem ser letras, números ou sublinhado (_).

Há apenas mais duas restrições:

o nome de uma variável não pode ser igual a uma palavra reservada

O nome não pode ser igual ao nome de uma função declarada pelo programador, ou pelas bibliotecas

do C.

Variáveis de até 32 caracteres são aceitas. Mais uma coisa: é bom sempre lembrar que o C é "case

sensitive" e portanto deve-se prestar atenção às maiúsculas e minúsculas.

Quanto aos nomes de variáveis...

É uma prática tradicional do C, usar letras minúsculas para nomes de variáveis e maiúsculas para

nomes de constantes. Isto facilita a leitura do código;

Quando se escreve código usando nomes de variáveis em português, evita-se possíveis conflitos com

nomes de rotinas encontrados nas diversas bibliotecas, que são em sua maioria absoluta, palavras

em inglês.



OS TIPOS DO C

O C tem 9 tipos de dados básicos: char, int, short, long, double, float, void, double, unsigned.

Os dados são a base da informação, constituindo termos genéricos para informações destinadas a seremtratadas pelo computador.

Podem apresentar uma forma numérica como as idades dos alunos ou de uma forma alfanumérica comoum nome.

Dados alfanuméricos Dados numéricosJosé 2abcd -45Azul 32.2232475 Benedita 6.(3)11º Ano 4.34545E+5“2#$%&/() = 0.33

A programação em C exige a declaração do tipo das variáveis antes da sua utilização. A sua declaraçãopossui a seguinte sintaxe:

<tipo> <lista de variáveis> ;

Tipos de variáveis em C :

char é um caracter ASCII (0 a 255) que ocupa um byte ,

‘a’, ‘A’, ‘*’, …‘\0’ - caracter nulo (fim de uma cadeia de caracteres)‘\n’ - mudança de linha‘\t’ – avança 8 espaços‘\b’ - o cursor recua um caracter‘\r’ - posiciona o cursor na 1º coluna‘\f’ - limpa a página

int representa valores numéricos inteiros positivos e negativos

de - 32768 a 32767

shortsão valores inteiros “curtos” podendo ser representados por ½, 1 ou 2 bytes. longsão valores inteiros “longos” armazenados em 4 bytes armazena números entre -2 147 483 648 e 2 147483 647 floatrepresenta números reais com virgula flutuante, representados por 4 bytes doublesão valores numéricos reais como float, porém armazenados em 8 bytes



unsignedsão números inteiros sem sinal, tem como limite 0 e 65535 e podem ser definidos como :

unsigned int a ;

A seguir estão listados os tipos de dados permitidos e seu valores máximos e mínimos num compiladortípico para um hardware de 16 bits:

IntervaloTipo Num de bits

Inicio Fim

char 8 -128 127

unsigned char 8 0 255

signed char 8 -128 127

int 16 -32.768 32.767

unsigned int 16 0 65.535

signed int 16 -32.768 32.767

short int 16 -32.768 32.767

unsigned short int 16 0 65.535

signed short int 16 -32.768 32.767

long int 32 -2.147.483.648 2.147.483.647

signed long int 32 -2.147.483.648 2.147.483.647

unsigned long int 32 0 4.294.967.295

float 32 3,4E-38 3.4E+38

double 64 1,7E-308 1,7E+308

long double 80 3,4E-4932 3,4E+4932

O tipo long double é o tipo de ponto flutuante com maior precisão. É importante observar que osintervalos de ponto flutuante, na tabela acima, estão indicados em faixa de expoente, mas os númerospodem assumir valores tanto positivos quanto negativos.



DECLARAÇÃO E INICIALIZAÇÃO DE VARIÁVEIS

As variáveis no C devem ser declaradas antes de serem usadas.

A forma geral da declaração de variáveis é:

tipo_da_variável variável;

ou

tipo_das_variáveis variável1, variável2, ..... ;

Por exemplo, as declarações

char ch, letra;

int count;

float pi;

declaram duas variáveis do tipo char (ch e letra), uma variável int (count) e um float pi.

VARÁVEIS GLOBAIS E LOCAIS

Há três lugares em que se pode declarar variáveis.

O primeiro é fora de todas as funções do programa. Estas variáveis são chamadas variáveis

globais e podem ser usadas a partir de qualquer lugar no programa. Pode-se dizer que, como elas estão

fora de todas as funções, todas as funções as vêem e as podem utilizar.

O segundo lugar no qual se pode declarar variáveis é no início de um bloco de código. Estas variáveis são

chamadas locais e só têm validade dentro do bloco no qual são declaradas, isto é, só a função à qual ela

pertence sabe da existência desta variável, dentro do bloco no qual foram declaradas.

O terceiro lugar onde se pode declarar variáveis é na lista de parâmetros de uma função. Mais uma vez,

apesar de estas variáveis receberem valores externos, estas variáveis são conhecidas apenas pela função

onde são declaradas.



Exemplo #include <stdio.h> int func1(int j); int contador; int main()

char condicao; int i; for (i=0; ...) /* Bloco do for */

float f2; ... func1(i);

return(0);

int func1(int j) ...

As regras que regem onde uma variável é válida chamam-se regras de escopo da variável.

Duas variáveis globais não podem ter o mesmo nome. O mesmo vale para duas variáveis locais deuma mesma função. Já duas variáveis locais, de funções diferentes, podem ter o mesmo nome semperigo algum de conflito

Pode-se inicializar variáveis no momento de sua declaração. Para fazer isto pode-se usar a forma geral

tipo_da_variável nome_da_variável = constante;

Isto é importante pois quando o C cria uma variável ele não a inicializa. Isto significa que até queum primeiro valor seja atribuído à nova variável ela tem num valor indefinido e que não pode serutilizado para nada.

Nunca se presuma que uma variável declarada vale zero ou qualquer outro valor.

Exemplos de inicialização são dados abaixo: char ch='D'; int count=0; float pi=3.141;

O caracter igual (=) é o operador de atribuição.

Variável global

Variável local à main

Variável local ao bloco

Variável local à função func1declarada na lista de parâmetros



Identificadores de Variáveis Identificadores são os nomes atribuídos às variáveis e podem ser de qualquer tamanho.

Os identificadores não podem ter o mesmo nome das seguintes palavras chave:

auto default extern int sizeof unionbreak do float static unsigned longcase double for register struct whilechar else goto return switch voidcontinue entry if short typdef

Os identificadores devem ter nomes sugestivos para compreender melhor e reduzir o numero decomentários

Exercício

Escreva um programa que declare uma variável inteira global e atribua o valor 10 a ela. Declare outras 5

variáveis inteiras locais ao programa principal e atribua os valores 20, 30, ..., 60 a elas. Declare 6

variáveis caracteres e atribua a elas as letras c, o, e, l, h, o.

CONSTANTES

Constantes são valores que são mantidos fixos pelo compilador. São consideradas constantes, por

exemplo, os números e caracteres como 45.65 ou 'n', etc...

Constantes dos tipos básicos

Abaixo vê-se as constantes relativas aos tipos básicos do C:

Tipo de Dado char int

long int short int

unsigned int float

double

Exemplos de Constantes 'b' '\n' '\0'

2 32000 -130 100000 -467

100 -30 50000 35678

0.0 23.7 -12.3e-10 12546354334.0 -0.0000034236556

Constantes strings



Uma string "João" é na realidade uma constante string. Isto implica, por exemplo, no facto de que 't' édiferente de "t", pois 't' é um char enquanto que "t" é uma constante string com dois chars onde oprimeiro é 't' e o segundo é '\0'.

Constantes de barra invertida

O C utiliza, para facilitar a tarefa de programar, vários códigos chamados códigos de barra invertida.Estes são caracteres que podem ser usados como qualquer outro. A lista completa dos códigos de barrainvertida é dada a seguir:

Código \b \f \n \r \t \" \' \0 \\ \v \a \N \xN

Significado Retrocesso ("back")

Alimentação de formulário ("form feed") Nova linha ("new line")

Retorno de carro ("carriage return") Tabulação horizontal ("tab")

Aspas Apóstrofo

Nulo (0 em decimal) Barra invertida

Tabulação vertical Sinal sonoro ("beep")

Constante octal (N é o valor da constante) Constante hexadecimal (N é o valor da constante)



Exercícios

Em C, variáveis com nomes abc e Abc representam a mesma variável .

a. Verdadeiro

b. Falso

O programa#include <stdio.h>main() int x; scanf("%d",&x); printf("%d",x);

Lê uma variável pelo teclado e a imprime no ecrã

a. Verdadeiro

b. Falso

A instrução #include <stdio.h> no programa anterior é colocada para que possamos utilizar asfunções scanf e printf

a. Verdadeiro

b. Falso

Os comentários na linguagem C só podem ter uma linha de comprimento

a. Verdadeiro

b. Falso

Sendo i uma variável inteira, a seguinte chamada a scanf é válida: scanf("%d", i);

a. Verdadeiro

b. Falso

O que faz o seguinte programa em C?#include <stdio.h>main() int i =2; printf ("\n O valor de i = %d ", i);

a. Nada

b. Imprime: O valor de i = 2

c. Imprime: \n O valor de i = %d

d. Pula para a próxima linha e imprime: O valor de i = 2



O que é uma função em C?

a. Parte de um programa

b. Um bloco de código que pode ser utilizado diversas vezes na execução de um programa

c. Uma estrutura da linguagem C que pode ser utilizada para que um programa fique mais organizado

d. Um bloco de código que pode receber parâmetros, processá-los e retornar alguma coisa

e. Todas opções acima

O comando printf ("%s%d%%","Juros de ",10); imprime:

a. Juros de 10%

b. %s%d%% Juros de 10

c. % Juros de 10

d. 10 Juros de

e. Nenhuma das anteriores

Uma string, é uma sequência de caracteres terminada com um '\0'. Uma string pode ser armazenada numvector de caracteres

a. Verdadeiro

b. Falso



FUNÇÕES PARA O ECRÃ

A linguagem C trabalha com o ecrã através de 80 colunas por 25 linhas.

1 2 3 4 5 77 78 79 80

2

3

23

24

25

A FUNÇÃO CLRCSCR

Esta função tem a particularidade de limpar o ecrã e necessita da biblioteca conio.h.

A sua forma geral é:

clrscr( );

A FUNÇÃO CLREOL

Esta função tem limpa a partir do local onde está o cursor até ao fim da linha do ecrã e necessita da

biblioteca conio.h.


clreol( );



A FUNÇÃO GOTOXY

Esta função posiciona o cursor num determinado local no ecrã e necessita da biblioteca conio.h.


gotoxy ( coluna , linha );

AS FUNÇÕES WHEREX\WHEREY

Estas funções devolvem a posição do x/coluna e do y/linha do ecrã e necessitam da biblioteca conio.h.


x= wherex ( );y = wherey ( ) ;

A FUNÇÃO WINDOW

A função window define uma janela activa no ecrã. e necessita da biblioteca conio.h.


window( esquerda, cima, direita, baixo );

A FUNÇÃO DELLINE

A função delline apaga a linha onde o cursor está situado puxando as linhas abaixo para cima e necessita

da biblioteca conio.h.


delline( );

A FUNÇÃO INSLINE

A função insline insere uma linha onde o cursor está situado e necessita da biblioteca conio.h.


insline( );



OPERADORES ARITMÉTICOS E DE ATRIBUIÇÃO

Os operadores aritméticos são usados para desenvolver operações matemáticas. A seguir apresenta-se a

lista dos operadores aritméticos do C:

Operador + - * /

% ++ --

Acção Soma (inteira e ponto flutuante) Subtracção ou Troca de sinal (inteira e ponto flutuante) Multiplicação (inteira e ponto flutuante) Divisão (inteira e ponto flutuante) Resto de divisão (de inteiros) Incremento (inteiro e ponto flutuante) Decremento (inteiro e ponto flutuante)

O C possui operadores unários e binários.

Os unários agem sobre uma variável apenas, modificando ou não o seu valor, e retornam o valor final da

variável.

Os binários usam duas variáveis e retornam um terceiro valor, sem alterar as variáveis originais.

Operadores Binários Operadores Unários

+

*

/

%

-

++

--

Exercício

Porque razão o operador – é um operador unário?



Os operadores de incremento e decremento são unários que alteram a variável sobre a qual estão

aplicados. O que eles fazem é incrementar ou decrementar, a variável sobre a qual estão aplicados, de 1.

Então são equivalentes a

x++; x=x+1;

x--; x=x-1;

Estes operadores podem ser pré-fixados ou pós- fixados. A diferença é que quando são pré-fixados eles

incrementam e retornam o valor da variável já incrementada. Quando são pós-fixados eles retornam o

valor da variável sem o incremento e depois incrementam a variável.

x ++ incrementa, devolvendo o valor não actualizado

++ x incrementa devolvendo o valor actualizado

x - - decrementa, devolvendo o valor não actualizado

- - x decrementa, devolvendo o valor actualizado

Exemplo :main()

int x ,b ;x = 1 ;b = x ++ ;printf (“x = %d, b = %d \n”, x,b);

Exemplo: x=23; y=x++;

Em x=23; y=++x;

Resultadoo valor de b = 1 ;o valor de x = 2 ;

teremos, no final, y=23 e x=24.

teremos, no final, y=24 e x=24.



OPERADOR DE ATRIBUIÇÃO

O operador de atribuição do C é o =.

O que ele faz é pegar o valor à direita e atribuir à variável da esquerda. Além disto ele retorna o valor que

ele atribuiu. Isto faz com que as seguintes expressões sejam válidas:

x=y=z=1.5; /* Expressão 1 */if (k=w) /* Expressão 2 */

A expressão um é válida, pois quando se faz z=1.5 ela retorna 1.5, que é passado adiante. A expressão

dois será verdadeira se w for diferente de zero, pois este será o valor retornado por k=w.

Exercício

Diga o resultado das variáveis x, y e z depois da seguinte sequência de operações:

x y zint x,y,z;x=y=10;z=++x;x=-x;y++;x=x+y-(z--);

Exercícios

Considere as expressões que se seguem e transforme-as em expressões lineares para poderem sercompreendidas pelo compilador de «C».

Nota. A função sqrt ( ) devolve a raiz quadrada deum número passado como parâmetro.



OPERADORES RELACIONAIS E LÓGICOS

Os operadores relacionais do C realizam comparações entre variáveis. São eles:

Operador >

>= <

<= == !=

Acção Maior do que

Maior ou igual a Menor do que

Menor ou igual a Igual a

Diferente de

Os operadores relacionais retornam verdadeiro (1) ou falso (0). Para fazer operações com valores lógicos

(verdadeiro e falso) temos os operadores lógicos:

Operador &&

|| !

Acção AND (E) OR (OU)

NOT (NÃO)

Usando os operadores relacionais e lógicos pode-se realizar uma grande gama de testes. A tabela-verdade

destes operadores é dada a seguir:

p falso falso

verdadeiro verdadeiro

q falso

verdadeiro falso

verdadeiro

p AND q falso falso falso

verdadeiro

p OR q falso

verdadeiro verdadeiro verdadeiro

Exemplo: No trecho de programa abaixo o if será executado, pois o resultado da expressão lógica éverdadeiro:

int i = 5, j =7;

if ( (i > 3) && ( j <= 7) && ( i != j) ) j++;

Resolução è V AND V AND V = V



EXPRESSÕES

Expressões são combinações de variáveis, constantes e operadores. Quando se escreve expressões tem

que se levar em consideração a ordem com que os operadores são executados, conforme a tabela de

precedências da linguagem C.

Exemplos de expressões:

Anos=Dias/365.25;

i = i+3;

c= a*b + d/e;

c= a*(b+d)/e;

EXPRESSÕES QUE PODEM SER ABREVIADAS

O C admite as seguintes equivalências, que podem ser usadas para simplificar expressões ou para facilitar

o entendimento de um programa:

Expressão Original Expressão Equivalente

x=x+k; x+=k;

x=x-k; x-=k;

x=x*k; x*=k;

x=x/k; x/=k;

etc...



MODELADORES (CASTS)

Um modelador é aplicado a uma expressão. Ele força a mesma a ser de um tipo especificado.

A sua forma geral é:(tipo)expressão

Exemplo: #include <stdio.h> int main () int num; float f; num=10; f=(float)num/7; printf ("%f",f);

return(0);

Se não se tivesse usado o modelador no exemplo acima o C faria uma divisão inteira entre 10 e 7. O

resultado seria 1 (um) e este seria depois convertido para float mas continuaria a ser 1.0. Com o

modelador tem-se o resultado correcto.

Exercício

Compile o exemplo acima sem usar o modelador, e verifique os resultados. Compile-o novamente usando

o modelador e compare a saída com os resultados anteriores.



Exercícios

Escolha a opção que inclui somente nomes válidos para variáveis na linguagem C.

a. If, a_b_2, H789, _yes

b. j, int, obs, A5

c. 9xy, a36, x*y, --j

d. 2_ou_1, \fim, *h, j

e. Nenhuma das opções anteriores

Qual das instruções abaixo está errada?

a. int i;

b. long float x;

c. long double y;

d. long ijk;

e. short int a;

f. unsigned b;

Num compilador para um hardware de 16 bits (típico) uma variável double ocupa o mesmo espaço que

_____ variáveis do tipo char

a. Uma

b. Duas

c. Quatro

d. Oito

e. Dezasseis

O trecho de programa a seguir é main() char condicao; condicao = 'D'; int i = 1;

a. Válido na linguagem C

b. Não válido na linguagem C



Em C, "t" e 't' representam a mesma constante.

a. Verdadeiro

b. Falso

6- Diga o resultado das variáveis x, y e z depois da seguinte sequência de operações: int x,y,z; x=y=10; z=++x; x=-x; y++; x=x+y-(z--);

a. x = 11, y = 11, z = 11

b. x = -11, y = 11, z = 10

c. x = -10, y = 11, z = 10

d. x = -10, y = 10, z = 10


7- Diga o resultado das variáveis x, y e z depois da seguinte sequência de operações:

int x,y; int a = 14, b = 3; float z; x = a/b; y = a%b; z = y/x;

a. x = 4.66666, y = 2, z = 0.4286

b. x = 5, y =2, z= 0.4

c. x = 5, y = 2, z = 0.

d. x = 4, y = 2, z = 0.5

e. x = 4, y =2, z = 0.

f. Nenhuma das opções anteriores

8- A operação lógica (-5 || 0)&&(3 >= 2)&&(1 != 0)||(3 < 0) é:

a. Verdadeira

b. Falsa

c. Inválida, pois sua sintaxe está errada.

d. Nem Verdadeira nem Falsa




9- Qual o valor das variáveis v, x, y e z após a execução do seguinte trecho de código

int v = 0, x = 1, y = 2, z = 3; v += x+y; x *= y = z + 1; z %= v + v + v; v += x += y += 2;

a. v=11, x=8, y=6, z=3

b. v=0, x=1, y=2, z=3

c. v=10, x=7, y=6, z=3

d. v=13, x=10, y=6, z=3




COMANDOS DE CONTROLE DE FLUXO

Os comandos de controle de fluxo são aqueles que permitem ao programador alterar a sequência de

execução do programa.

O COMANDO IF

O comando if representa uma tomada de decisão do tipo "SE isto ENTÃO aquilo". A sua forma geral é:

if (condição) declaração;

A condição do comando if é uma expressão que será avaliada. Se o resultado for zero a declaração não

será executada. Se o resultado for qualquer coisa diferente de zero a declaração será executada.

A declaração pode ser um bloco de código ou apenas um comando.

No caso da declaração ser um bloco de código, não é necessário (e nem permitido) o uso do ; no final

do bloco. Isto é uma regra geral para blocos de código.

Exemplo:


int num;printf ("Digite um número: ");scanf ("%d",&num);if (num>10)

printf ("\n\nO número é maior que 10");if (num==10)

printf ("\n\nAcertou!\n"); printf ("O número é igual a 10.");

if (num<10) printf ("\n\nO número é menor que 10");return (0);

No programa acima a expressão num>10 é avaliada e retorna um valor diferente de zero, se verdadeira, ezero, se falsa.

Quando se pretende testar igualdades usa-se o operador = = e não =.

Isto é porque o operador = representa apenas uma atribuição.

Nota: Este problema gera erros frequentes entre iniciantes e, portanto, muita atenção deve ser tomada.



Operadores de comparação

= = IGUAL!= DIFERENTE> MAIOR< MENOR

>= MAIOR OU IGUAL<= MENOR OU IGUAL

O COMANDO ELSE

Pode-se pensar no comando else como sendo um complemento do comando if. O comando if completo

tem a seguinte forma geral:

if (condição) declaração_1;else declaração_2;

A expressão da condição será avaliada. Se ela for diferente de zero a declaração 1 será executada. Se for

zero a declaração 2 será executada. É importante nunca esquecer que, quando se usa a estrutura if-else,

está-se a garantir que uma das duas declarações será executada. Nunca serão executadas as duas ou

nenhuma delas.



Exemplo:


int num;printf ("Digite um número: ");scanf ("%d",&num);if (num==10)

printf ("\n\nVoçê acertou!\n"); printf ("O número é igual a 10.\n");

else

printf ("\n\nVoçê errou!\n"); printf ("O número é diferente de 10.\n");

return(0);

O if-else-if

A estrutura if-else-if é apenas uma extensão da estrutura if. Sua forma geral pode ser escrita como sendo:

if (condição_1) declaração_1;else



....

....if (condição_n) declaração_n;else

declaração_default;



Exemplo: #include <stdio.h>

int main ()

int num;printf ("Digite um número: ");scanf ("%d",&num);if (num>10)

printf ("\n\nO número é maior que 10");else

if (num==10)

printf ("\n\nVoçê acertou!\n"); printf ("O número é igual a 10.");

else if (num<10) printf ("\n\nO número é menor que 10");

return(0);

A EXPRESSÃO CONDICIONAL

Quando o compilador avalia uma condição, ele quer um valor de retorno para poder tomar a decisão. Mas

esta expressão não necessita ser uma expressão no sentido convencional. Uma variável sozinha pode ser

uma "expressão" e esta retorna o seu próprio valor.

Estas expressões ..... equivalem a ...if (num!=0) ....if (num==0) ....for (i = 0; string[i] = = '\0'; i++)

if (num) ....if (!num) ....for (i = 0; string[i]; i++)

O OPERADOR TERNÁRIO ?

Uma expressão como:

if (a>0) b=-150;else b=150;

Pode ser simplificada usando-se o operador ? da seguinte maneira:

b = a>0 ? –150 : 150;



De uma maneira geral expressões do tipo:

if (condição)expressão_1;

elseexpressão_2;

Podem ser substituídas por:

condição ? expressão_1:expressão_2;

O operador ? é limitado (não atende a uma gama muito grande de casos) mas pode ser usado para

simplificar expressões complicadas. Uma aplicação interessante é a do contador circular.

Exemplo:

#include <stdio.h>int main() int index = 0, contador; char letras[5] = "João"; for (contador=0; contador < 1000; contador++)

printf("\n%c",letras[index]);index = (index = =4 ) ? index=0: ++index;

O nome João é escrito no ecrã verticalmente até a variável contador determinar o término do programa.

Enquanto isto a variável index assume os valores 0, 1, 2, 3, 4, 0, 1, ... progressivamente.

Exercício

Altere o último exemplo para que ele escreva cada letra 5 vezes seguidas. Para isto, use um 'if' para testar

se o contador é divisível por cinco (utilize o operador %) e só então realizar a actualização em index.



O COMANDO SWITCH

O comando switch e o comando case são os dois comandos de tomada de decisão.

O comando switch é próprio para se testar uma variável em relação a diversos valores pré-estabelecidos.

Sua forma geral é:

switch (variável)

case constante_1:declaração_1;break;

case constante_2:declaração_2;break;...

case constante_n:declaração_n;break;

defaul : //opcionaldeclaração_default;

Pode-se fazer uma analogia entre o switch e a estrutura if apresentada anteriormente. A diferençafundamental é que a estrutura switch não aceita expressões. Aceita apenas constantes.

O switch testa a variável e executa a declaração cujo case corresponda ao valor actual da variável.

A declaração default é opcional e será executada apenas se a variável, que está sendo testada, não for

igual a nenhuma das constantes.

O comando break, faz com que o switch seja interrompido assim que uma das declarações seja executada.

Mas ele não é essencial ao comando switch. Se após a execução da declaração não existir umbreak, o

programa continuará a ser executado dentro do switch. Isto pode ser útil em algumas situações, mas

recomenda-se cuidado.



Exemplo: #include <stdio.h>int main ()

int num;printf ("Digite um número: ");scanf ("%d",&num);switch (num)

case 9: printf ("\n\nO número é igual a 9.\n"); break; case 10: printf ("\n\nO número é igual a 10.\n"); break; case 11: printf ("\n\nO número é igual a 11.\n"); break; default: printf ("\n\nO número não é nem 9 nem 10 nem 11.\n");

return(0);

Exercícios

Elabore um programa em que o utilizador digita um caracter se esse caracter for «*» deve surgir umamensagem no ecrã - “Digitou o caracter *” - caso contrário surgirá uma outra - “Digitou o caracter<caracter que o utilizador digitou>.”. Utilize a função «if».

Refaça o programa anterior utilizando o operador ternário.

Elabore um programa em que o utilizador digita um caracter se esse caracter for ‘n’ ou ‘N’ deve surgiruma mensagem no ecrã - “Escolheu a opção Não.” - caso contrário surgirá uma outra - “Escolheuoutra opção.”

Elabore um programa que informe se um número inserido pelo utilizador é par ou é impar.

Refaça o programa anterior utilizando o operador «switch».

Elabore um programa que ordene por ordem crescente 2 números inseridos pelo utilizador (todosdiferentes).

Elabore um programa que ordene por ordem decrescente 3 números inseridos pelo utilizador (todosdiferentes).



O COMANDO FOR

O loop (ciclo) for é usado para repetir um comando, ou bloco de comandos, diversas vezes, de maneira que se possa

ter um bom controle sobre o ciclo. A sua forma geral é:

for (inicialização ; condição ; incremento) declaração;

A declaração no comando for também pode ser um bloco ( ) e neste caso o ; é omitido.

O ciclo for executa a inicialização incondicionalmente e testa a condição. Se a condição for falsa elenão faz mais nada. Se a condição for verdadeira ele executa a declaração, faz o incremento e volta atestar a condição. Ele fica repetindo estas operações até que a condição seja falsa.

Um ponto importante é que se pode omitir qualquer um dos elementos do for, isto é, se não se quiseruma inicialização pode-se omiti-la.

Exemplo de programa que coloca os primeiros 100 números no ecrã:


int count;for (count=1;count<=100;count=count+1) printf ("%d ",count);

Outro exemplo interessante é mostrado a seguir: o programa lê uma string e conta quantos dos caracteres desta string

são iguais à letra 'c'

#include <stdio.h>int main () char string[100]; /* String, ate' 99 caracteres */ int i, cont; printf("\n\nDigite uma frase: "); gets(string); /* Lê a string */ printf("\n\nFrase digitada:\n%s", string); cont = 0; for (i=0; string[i] != '\0'; i=i+1) if ( string[i] == 'c' ) /* Se for a letra 'c' */ cont = cont +1; /* Incrementa o contador de caracteres */ printf("\nNúmero de caracteres c = %d", cont);

Note que o teste que está a ser feito no for: o caracter armazenado em string[i] é comparado com '\0' (caracter final

da string). Caso o caracter seja diferente de '\0', a condição é verdadeira e o bloco do for é executado. Dentro do

bloco existe um if que testa se o caracter é igual a 'c'. Caso seja, o contador de caracteres c é incrementado.

O ciclo infinito

O ciclo infinito tem a forma

for (inicialização; ;incremento) declaração;



Este ciclo chama-se ciclo infinito porque será executado para sempre (não existindo a condição, ela será sempre

considerada verdadeira), a não ser que ele seja interrompido.

Para interromper um ciclo usa-se o comando break.

O comando break vai quebrar o ciclo infinito e o programa continuará sua execução normalmente.

Exemplo

Programa que faz a leitura de uma tecla e sua impressão no ecrã, até que o utilizador aperte uma tecla sinalizadora

de final (um FLAG). O nosso FLAG será a letra 'X'.

#include <stdio.h>#include <conio.h>int main ()

int Count;char ch;for (Count=1;;Count++)

ch = getch(); if (ch == 'X') break; printf("\nLetra: %c",ch);

return(0);



O ciclo sem conteúdo

Ciclo sem conteúdo é aquele no qual se omite a declaração. A sua forma geral é (atenção ao ponto e vírgula!):

for (inicialização;condição;incremento);

Uma das aplicações desta estrutura é gerar tempos de espera.


long int i;printf("\a"); /* Imprime o caracter de alerta (um beep) */for (i=0; i<10000000; i++); /* Espera 10.000.000 de iterações */printf("\a"); /* Imprime outro caracter de alerta */return(0);

Exercícios

a) Explique porque está errado fazer

if (num=10) ...

O que irá acontecer?

b) if(num) ...; é equivalente a if(num!=0) ...;

a. Verdadeiro

b. Falso

c) Qual o valor de x após a seguinte sequência de comandos: a = 10; b = 20; x = 0; x = (b > a) ? b : a;

a. 0

b. 2

c. 10

d. 20

e. 40

f. Nenhuma das opções anteriores

d) Qual o valor de x após a sequência de comandos:

a = 1; b = 2; c = 3; x = 0;



Partindo do princípio que o programanão tem erros, elabore o seu Outputconstruindo uma grelha quesimbolizará o ecrã .

x = a < b ? a < c ? a : c : b < c ? b : c;

DICA: antes de tentar resolver, coloque parênteses na expressão acima,indicando a ordem de precedência dos operadores

a. 0

b. 1

c. 2

d. 3


Escreva um programa que coloque os números de 1 a 100 no ecrã na ordem inversa (começando em 100 eterminando em 1).

Escreva um programa que leia uma string, conte quantos caracteres desta string são iguais a 'a' e substitua os queforem iguais a 'a' por 'b'. O programa deve imprimir o número de caracteres modificados e a string modificada.

Escreva um programa que imprima no ecrã todos os números pares entre 1 e 100.

Escreva um programa que imprima no ecrã todos os números entre 1 e 100 divisíveis por 4.

Faça um programa que inverta uma string: leia a string com gets e armazena-a invertida numa outra string. Use ociclo for para percorrer a string até o seu final.

j) Considere o seguinte programa:

#include <stdio.h>#include <conio.h>main( )

int a, b, c ;clrscr( ) ;a = 12 ;b = c = 3;gotoxy(1,1);printf ( “O Valor de a é %4d“, a);b = c++ ;printf ( “\n %d”, c) ;printf (“%d”, ++a) ;c = c + ( a) ;for ( a = 1 ; a < c ; a++) printf ( “\n %d”, a+1); b++;printf (“Valor de b %d”,b);

O COMANDO WHILE

O comando while tem a seguinte forma geral:

while (condição) declaração;

O while seria equivalente a:



if (condição)

declaração;"Volte para o comando if"

A estrutura while testa uma condição. Se esta for verdadeira a declaração é executada e faz o teste novamente, e

assim por diante. Assim como no caso do for, pode-se fazer um ciclo infinito. Para tanto basta colocar uma

expressão eternamente verdadeira na condição. Pode-se também omitir a declaração e fazer um ciclo sem conteúdo.

Exemplo do uso do while. O programa abaixo espera que o utilizador digite a tecla 'q' e só depois finaliza:


char Ch;Ch='\0';while (Ch!='q')

Ch = getch();

return(0);



O COMANDO DO-WHILE

A terceira estrutura de repetição que veremos é o do-while de forma geral:

do

declaração; while (condição);

Importante: O ponto-e-vírgula final é obrigatório.

Mesmo que a declaração seja apenas um comando pode-se, também, deixar as chavetas.

Funcionamento da estrutura do-while "por dentro":

declaração;if (condição) "Volta para a declaração"

A estrutura do-while executa a declaração, testa a condição e, se esta for verdadeira, volta para a declaração.

O comando do-while , ao contrário do for e do while, garante que a declaração será executada pelomenos uma vez.

Um dos usos da estrutura do-while é em menus, nos quais se quer garantir que o valor digitado pelo utilizador seja

válido, conforme apresentado abaixo:


int i;do

printf ("\n\nEscolha a fruta pelo número:\n\n"); printf ("\t(1)...Banana\n"); printf ("\t(2)...Maçã\n"); scanf("%d", &i);

while ((i<1)||(i>2));switch (i)

case 1: printf ("\t\tEscolheu Banana.\n"); break; case 2: printf ("\t\tEscolheu Maçã.\n"); break;

return(0);



Exercício

Refaça o exercício anterior utilizando while do para controlar o fluxo.

COMANDO BREAK

O comando break pode quebrar a execução de um comando (como no caso do switch) ou interromper a execução

de qualquer ciclo (como no caso do for, do while ou do do while). O break faz com que a execução do programa

continue na primeira linha seguinte ao loop ou bloco que está sendo interrompido.

O COMANDO CONTINUE

O comando continue pode ser visto como sendo o oposto do break. Ele só funciona dentro de um ciclo. Quando o

comando continue é encontrado, o ciclo pula para a próxima execução, sem o abandono do ciclo, ao contrário do

que acontecia no comando break.

O programa abaixo exemplifica o uso do continue:

#include <stdio.h>int main()

int opcao;while (opcao != 3)

printf("\n\n Escolha uma opção entre 1 e 3: "); scanf("%d", &opcao); if ((opcao > 3)||(opcao <1)) continue; /* Opção inválida: volta ao inicio do ciclo */ switch (opcao) case 1: printf("\n --> Primeira opção.."); break; case 2: printf("\n --> Segunda opção.."); break; case 3: printf("\n --> Abandono.."); break; return(0);



Exercícios

1- Os trechos de programa a seguir são equivalentes entre si, sob o ponto de vista do que é impresso:

for (i = 0 ; i < 10; i++) printf("%d", i); e for (i = 0 ; i < 10; ++i) printf("%d", i);

a. Verdadeiro

b. Falso

2- O trecho de programa a seguir é

switch(num) case 1; printf("O número é 1 "); break; case 2; printf("O número é 2 "); break; default; printf("O número é diferente de 1 e 2"); break;

a. Válido na linguagem C

b. Não válido na linguagem C

3- Sendo num uma variável inteira, o que imprime o trecho de código a seguir? num = 1; switch(num) case 1: printf("O número é 1 "); case 2: printf("O número é 2 "); default: printf("O número é diferente de 1 e 2");

a. O número é 1

b. O número é 2

c. O número é diferente de 1 e 2

d. O número é 1 O número é 2

e. O número é 1 O número é 2 O número é diferente de 1 e 2

4- Os dois blocos de código a seguir produzem o mesmo resultado: for( i = 0 ; i < 3 ; i++) for ( j =0 ; j < 3; j++) printf("i+j = %d \n", i+j);



e for( i = 0 , j=0 ; i < 3 ; i++) for ( ; j < 3 ; j++) printf("i+j = %d \n", i+j);

a. Verdadeiro

b. Falso

5- Qual o output produzido pelo extracto de código a seguir:

int x; for ( x = 35 ; x > 0 ; x/=3) printf("%d " , x) ;

a. 35 11 3 1

b. 11 3 1

c. 11 3 1 0

d. 35 11 3


6- Os extractos de código a seguir são equivalentes entre si: int x = 10; while (--x > 9) printf("%d", x); e int x = 10; do printf("%d", x); while(--x > 9);

a. Verdadeiro

b. Falso



7- Sendo i declarado e inicializado como:

int i = 0;

os seguintes extractos de código: while (i = 5) printf("%d %d %d \n", i, i+2, i+4); i = 0; e if (i = 5) printf ("%d %d %d \n", i, i+2, i+4);

a. São idênticos sob o ponto de vista do que imprimem no ecrã

b. Não imprimem nada no ecrã

c. Têm sintaxe errada

d. Um deles imprime 5, 7 e 9 uma única vez e o outro entra em loop, imprimindo estes valoresindefinidamente


11- A estrutura do switch abaixo é:

switch (t) case t < 10: printf("Hoje está muito frio"); break; case t < 25: printf("A temperatura está agradável"); break; default: printf("Hoje está quente");

a. Válida na linguagem C

b. Não válida na linguagem C

12- O ciclo for a seguir

int i; for ( i = 0 ; i <= 5; i++ , printf("%d ", i));

a. Imprime 0 1 2 3 4 5

b. Não funciona, pois tem sintaxe errada

c. Imprime 1 2 3 4 5 6

d. Imprime 1 2 3 4 5




O ciclo for de uma única instrução termina com:

a. Virgula

b. Chaveta de abertura

c. Chaveta de fecho

d. Ponto e virgula

A expressão de inicialização de um ciclo for

a. Nunca é executada;

b. É executada uma única vez a cada iteração

c. É executada enquanto o ciclo não Termina

d. É executada uma vez antes do ciclo ser iniciado

Elabore um programa que escreva no ecrã o caracter «*» 80 vezes, utilizando apenas um printf - ciclowhile.

Refaça o programa anterior com o ciclo do.. while e o ciclo for.

Elabore um programa que faça a média de 3 números inseridos pelo utilizador utilizando um ciclo.

Elabore um programa que faça a média de N números inseridos pelo utilizador utilizando um ciclo. Outilizador dirá quantos números pretende inserir.

Elabore um programa que desenho no ecrã um menu com três opções : Clientes, Fornecedores e Sair.Cada ao opção terá um número e o utilizador terá de escolher uma opção. Sobre a opção que outilizador escolheu deve surgir uma mensagem no ecrã dizendo - “Voçê escolheu a opção Clientes”,ou “Voçê escolheu a opção Fornecedores” ou .... Utilize o operador «if».

Elabore um programa que peça ao utilizador para digitar um caracter. Se este digitar um caracter diferentede ‘N’, ‘n’, ‘s’ ou ‘S’ é lhe sempre pedido para digitar um novo caracter. Utilize o ciclo «while»

Elabore um programa em que o utilizador digita o seu nome. Este é escrito 20 vezes sempre na coluna 5mas em linhas diferentes (inicie na coluna 5 e linha ). Utilize o ciclo «while» e a função «gotoxy».

Menu

1. ClientesFornecedoresSaída

Escolha uma opção : _



MATRIZES

VECTORES

Vectores nada mais são que matrizes unidimensionais.

É importante notar que vectores, matrizes bidimensionais e matrizes de qualquer dimensão sãocaracterizadas por terem todos os elementos pertencentes ao mesmo tipo de dados.

Lembre-se das strings que nada mais são que cadeias de caracteres, ou seja vectores do tipo caracter.

Para se declarar um vector utiliza-se a seguinte forma geral:

tipo_da_variável nome_da_variável [tamanho];

Por exemplo: int exemplo [20];

Na linguagem C a numeração começa sempre em zero. Isto significa que, no exemplo acima, os dadosserão indexados de 0 a 19.

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

Para aceder-lhe: exemplo[0] exemplo[1] ..... exemplo[19]

Nunca ultrapasse o limite do índice que colocou na declaração do vector, caso o faça corre sériosriscos de o programa não funcionar correctamente.



Exemplo: #include <stdio.h>int main ()

int num[100]; /* Declara um vector de inteiros de 100posições */

int count=0; int totalnums;do

printf ("\nDigite um número (999 p/ terminar): "); scanf ("%d",&num[count]); count++; while (num[count-1]!=999);

totalnums=count-1;printf ("\n\n\n\t Os números que você digitou foram:\n\n");for (count=0;count<totalnums;count++)

printf (" %d",num[count]); return(0);

ExercícioRescreva o exemplo acima, realizando a cada leitura um teste para ver se a dimensão do vector não foiultrapassada. Caso o utilizador entre com 100 números, o programa deverá abortar o ciclo de leituraautomaticamente. O uso do Flag (999) não deve ser retirado.



STRINGS

Strings são vectores de chars. As strings são o uso mais comum para os vectores.

Não se esqueça que as strings têm o seu último elemento como um '\0'.

A declaração geral para uma string é:

char nome_da_string [tamanho];

A biblioteca padrão do C possui diversas funções que manipulam strings. Estas funções são úteis pois nãose pode, por exemplo, igualar duas strings: string1=string2; /* Não faça isto */

Fazer isto é um desastre. As strings devem ser igualadas elemento a elemento.Quando se faz programas que tratam de string, muitas vezes pode-se fazer bom proveito do facto de umastring terminar com '\0' .

Exemplo:

O programa abaixo que serve para igualar duas strings (isto é, copia os caracteres de uma string para ovector da outra): #include <stdio.h>int main ()

int count;char str1[100],str2[100];printf(“Insira uma string”);scanf(“%s”,str1);for (count=0;str1[count]!=’\0’;count++)

str2[count]=str1[count]; str2[count]='\0';

printf(“A string str2 %s”, str2);

Uma string, quando inserido através do comando scanf não necessita do endereço -& - uma vez queo próprio identificador da string já inclui o endereço de memória.



FUNÇÕES BÁSICAS PARA MANIPULAÇÃO DE STRINGS

As funções apresentadas nesta secção estão no arquivo cabeçalho string.h.

strcpy

A função strcpy() copia a string-origem para a string-destino.

A sua forma geral é:strcpy (string_destino,string_origem);

Exemplo de uso da função strcpy(): #include <stdio.h>#include <string.h>int main ()

char str1[100],str2[100],str3[100];printf ("Insira uma string: ");gets (str1);strcpy (str2,str1); /* Copia str1 em str2 */strcpy (str3,"Voçê digitou a string ");/* Copia "Você digitou a string" para a variável str3 */printf ("\n\n%s%s",str3,str2);return(0);

strcat

A função strcat() junta duas strings numa só.

A função strcat() tem a seguinte forma geral:strcat (string_destino,string_origem);

A string de origem permanecerá inalterada e será anexada ao fim dastring de destino.

Exemplo:

#include <stdio.h>#include <string.h>int main ()

char str1[100],str2[100];printf ("Digite uma string: ");gets (str1);strcpy (str2,"Voçê digitou a string ");strcat (str2,str1);/* str2 armazenara' Você digitou a string + o conteúdo de str1

*/printf ("\n\n%s",str2);return(0);



strlen

A função strlen() retorna o comprimento da string fornecida. O terminador nulo não é contado. Isto querdizer que, de facto, o comprimento do vector da string deve ser um a mais que o inteiro retornado porstrlen().

Forma geral é:strlen (string);

Um exemplo do seu uso: #include <stdio.h>#include <string.h>int main ()

int size;char str[100];printf ("Digite uma string: ");gets (str);size=strlen (str);printf ("\n\nA string que você digitou tem %d caracteres

",size);return(0);

strcmp

A função strcmp() compara a string 1 com a string 2. Se as duas forem idênticas a função retorna zero.Se elas forem diferentes a função retorna não-zero.

A sua forma geral é:strcmp (string1,string2);

Um exemplo da sua utilização:

#include <stdio.h>#include <string.h>int main ()

char str1[100],str2[100];printf ("Digite uma string: ");gets (str1);printf ("\n\nDigite outra string: ");gets (str2);if (strcmp(str1,str2))

printf ("\n\nAs duas strings são diferentes.");else printf ("\n\nAs duas strings são iguais.");return(0);

ExercícioFaça um programa que leia quatro palavras pelo teclado, e armazene cada palavra numa string. Depois,concatene todas as strings lidas numa única string. Por fim apresente esta como resultado ao final doprograma.

MATRIZES BIDIMENSIONAIS



Já foi visto como se declararam matrizes unidimensionais (vectores). A forma geral da declaração de umamatriz bidimensional é muito parecida com a declaração de um vector:

tipo_da_variável nome_da_variável [linhas][colunas];

Coluna 1 Coluna 2 Coluna 3 Coluna 4Linha 1Linha 2Linha 3

Não se esqueça que, na linguagem C, os índices variam de zero ao valor declarado, menos um.

Exemplo do uso de uma matriz:#include <stdio.h>int main ()int mtrx [10][20];int i,j,count;count=1;for (i=0;i<10;i++) for (j=0;j<20;j++) mtrx[i][j]=count; count++; return(0);

Preenchimento da matriz depois de executado o programa.

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 190 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 201 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 402 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 603 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 804 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 1005 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 1206 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 1407 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 1608 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 1809 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200

MATRIZES DE STRINGS

Matrizes de strings são matrizes bidimensionais porque uma string é um vector.

Forma geral de uma matriz de strings como sendo:

char nome_da_variável [num_de_strings][compr_das_strings];



Exemplo de um programa que lê 5 strings e as exibe no ecrã:


char strings [5][100];int count;for (count=0;count<5;count++)

printf ("\n\nDigite uma string: "); gets (strings[count]);

printf ("\n\n\nAs strings digitadas foram:\n\n");for (count=0;count<5;count++)

printf ("%s\n",strings[count]); return(0);

MATRIZES MULTIDIMENSIONAIS

O uso de matrizes multidimensionais na linguagem C é simples. A sua forma geral é: tipo_da_variável nome_da_variável [tam1][tam2] ... [tamN];

Uma matriz N-dimensional funciona basicamente como outros tipos de matrizes.



INICIALIZAÇÃO

Pode-se inicializar matrizes, assim como se inicializa variáveis

A lista de valores é composta por valores (do mesmo tipo da variável) separados por vírgula. Os valoresdevem ser dados na ordem em que serão colocados na matriz.

Exemplos de inicializações de matrizes:

float vect [6] = 1.3, 4.5, 2.7, 4.1, 0.0, 100.1 ;int matrx [3][4] = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ;char str [10] = 'J', 'o', 'a', 'o', '\0' ;char str [10] = "João";char str_vect [3][10] = "João", "Maria", "José" ;

O primeiro demonstra inicialização de vectores. O segundo exemplo demonstra a inicialização dematrizes multidimensionais, onde matrx é inicializada com 1, 2, 3 e 4 na sua primeira linha, 5, 6, 7 e 8 nasegunda linha e 9, 10, 11 e 12 na última linha. No terceiro exemplo inicializa uma string e, no quartoexemplo, um modo mais compacto de inicializar uma string. O quinto exemplo combina as duas técnicaspara inicializar um vector de strings.

Inicialização sem especificação de tamanho

Pode-se, em alguns casos, inicializar matrizes das quais não sabemos o tamanho a priori.É muito útil, por exemplo, quando se inicializa uma string e não se pretende contar quantos caracteresserão necessários.

Alguns exemplos: char mess [] = "Linguagem C: flexibilidade e poder."; int matrx [][2] = 1,2,2,4,3,6,4,8,5,10 ;

No primeiro exemplo, a string mess terá tamanho 36. No segundo exemplo o valor não especificado será5.



Exercícios

1- Seja um vector declarado porint vet[10];

Qual elemento deste vector é acedido quando se escreve vet[2] ?a. Primeiro elemento

b. Segundo elemento

c. Terceiro elemento

d. Quarto elemento


2- Se declararmos um vector como: int vet[30]

a instrução abaixo acede correctamente aos elementos deste vector? for (j=0; j <= 30; j++) vet[j] = j*j;

a. Sim

b. Não

3- Seja a matriz matrx declarada e inicializada por: int matrx[][4] = 1,2,3,4,5,6,7,8,9,10,11,12;

O que conterá o elemento matrx[1][2] ?

a. 2

b. 5

c. 6

d. 7


4. Se uma string for declarada como: char str[20];

o número máximo de caracteres que poderão ser lidos e armazenados nela é: a. 18

b. 19

c. 20

d. 21

5- Qual função pode ser usada para determinar o comprimento de uma string?a. gets

b. strcpy

c. strcat

d. strlen

e. strcmp

6. O que imprime o programa a seguir? Tente entendê-lo e responder. A seguir, execute-o e comprove oresultado.



int main() int t, i, M[3][4]; for (t=0; t<3; ++t)

for (i=0; i<4; ++i) M[t][i] = (t*4)+i+1;

for (t=0; t<3; ++t)

for (i=0; i<4; ++i) printf ("%3d ", M[t][i]);

printf ("\n"); return(0);



A FUNÇÃO

Funções são as estruturas que permitem ao utilizador separar os seus programas em blocos. Se nãoexistissem, os programas teriam que ser curtos e de pequena complexidade. Uma função no C tem a seguinte forma geral:

tipo_de_retorno nome_da_função (declaração_de_parâmetros)

corpo_da_função

O tipo-de-retorno é o tipo de variável que a função vai retornar.

Uma função para qual não se declara o tipo de retorno é considerada como retornando um inteiro.

A declaração de parâmetros é uma lista com a seguinte forma geral: tipo nome1, tipo nome2, ... , tipo nomeN

O tipo deve ser especificado para cada uma das N variáveis de entrada. É na declaração deparâmetros que se informa ao compilador quais serão as entradas da função (assim como se informa asaída no tipo-de-retorno). O corpo da função é a sua alma. É nele que as entradas são processadas, saídas são geradas ou outrascoisas são feitas.

PROTÓTIPOS DE FUNÇÕES

Protótipos são nada mais, nada menos, que declarações de funções

Um protótipo tem o seguinte formato: tipo_de_retorno nome_da_função (declaração_de_parâmetros);

onde o tipo-de-retorno, o nome-da-função e a declaração-de-parâmetros são os mesmosque se pretendem usar quando realmente se escrever a função.

Os protótipos têm uma nítida semelhança com as declarações de variáveis.Usando protótipos pode-se construir funções que retornam quaisquer tipos de variáveis.

O COMANDO RETURN

O comando return tem a seguinte forma geral: return valor_de_retorno; ou return;

Imagine-se que uma função está a ser executada. Quando se chega a uma declaração return a função éencerrada imediatamente e, se o valor de retorno é informado, a função retorna este valor.



O valor de retorno fornecido tem que ser o mesmo que o tipo de retorno declarado para a função.

Uma função pode ter mais de uma declaração return.Exemplo 1:

#include <stdio.h>int Quadrado (int a);int main ()

int num;printf ("Digite um número: ");scanf ("%d",&num);num=Raiz(num);printf ("\n\nO seu quadrado é: %d\n",num);return 0;

int Quadrado (int a)

return (a*a);

Exemplo 2:#include <stdio.h>int EPar (int a);int main ()

int num;printf ("Digite um número: ");scanf ("%d",&num);if (EPar(num))

printf ("\n\nO número é par.\n");else

printf ("\n\nO número é impar.\n");return 0;

int EPar (int a)

if (a%2) /* Verifica se a e divisível por dois */ return 0; /* Retorna 0 se não for divisível */

else return 1; /* Retorna 1 se for divisível */

É importante notar que, como as funções retornam valores, podem-se aproveitá-los para fazer atribuições,ou mesmo para que estes valores participem de expressões. Mas não se pode fazer: func(a,b)=x; /* Errado! */

Se uma função retorna um valor não é preciso aproveitar este valor. Se não se fizer nada com o valorde retorno de uma função ele será descartado. Por exemplo, a função printf() retorna um inteiro quenunca se usa para nada. Ele é descartado

ExercícioEscreva a função "EDivisivel(int a, int b)" (tome como base EPar(int a)). A função deverá retornar 1 se oresto da divisão de a por b for zero. Caso contrário, a função deverá retornar zero.



O TIPO VOID

Em inglês, void quer dizer vazio e é isto mesmo que o void é. Ele permite fazer funções que não retornamnada e funções que não têm parâmetros!

Protótipo de uma função que não retorna nada:void nome_da_função (declaração_de_parâmetros);

Numa função, como a acima, não existe valor de retorno na declaração return. Aliás, neste caso, ocomando return não é necessário na função.

Pode-se, também, fazer funções que não têm parâmetros: tipo_de_retorno nome_da_função (void);

ou, ainda, que não tem parâmetros e não retornam nada: void nome_da_função (void);

Um exemplo de funções que usam o tipo void:

#include <stdio.h>void Mensagem (void);int main ()

Mensagem();printf ("\tDiga de novo:\n");Mensagem();return 0;

void Mensagem (void)

printf ("Olá! Eu estou vivo.\n");



Caso se pretenda que a função retorne algo, deve-se usar a declaração return. Se não se quiser, bastadeclarar a função como tendo tipo-de-retorno void.

A função main() é uma função e como tal deve ser tratada. O compilador acha que a função main()deve retornar um inteiro. Isto pode ser interessante se quer que o sistema operativo (Dos, porexemplo) receba um valor de retorno da função main(). Se assim se quiser, deve-se lembrar daseguinte convenção: se o programa retornar zero, significa que ele terminou normalmente, e, se oprograma retornar um valor diferente de zero, significa que o programa teve um término anormal. Seisto não interessar, basta declarar a função main como retornando void.

As duas funções main() abaixo são válidas:main (void)

....return 0;

void main (void)

....



ARQUIVOS-CABEÇALHOS

Arquivos-cabeçalhos são aqueles que se tem mandado o compilador incluir no início dos exemplos e quesempre terminam em .h.A extensão .h vem de header (cabeçalho em inglês). Já se viu exemplos como stdio.h, conio.h, string.h.Estes arquivos, na verdade, não possuem os códigos completos das funções. Eles só contêm protótipos defunções. É o que basta. O compilador lê estes protótipos e, baseado nas informações lá contidas, gera ocódigo correcto. O corpo das funções cujos protótipos estão no arquivo-cabeçalho, no caso das funções dopróprio C, já estão compiladas e normalmente são incluídas no programa no instante da "linkagem".Para se criar algumas funções que aproveitáveis em vários programas futuros, ou módulos de programas,pode-se escrever arquivos-cabeçalhos e incluí-los também.Suponha-se que a função 'int EPar(int a)', vista anteriormente, seja importante em vários programas, eassim deseja-se declará-la num módulo separado. No arquivo de cabeçalho chamado por exemplo de'funcao.h' tem-se a seguinte declaração:int EPar(int a);

O código da função será escrito num arquivo a parte. Vamos chamá-lo de 'funcao.c'.Neste arquivo teremos a definição da função:

int EPar (int a)

if (a%2) /* Verifica se a e divisível por dois */ return 0;else return 1;

Por fim, no arquivo do programa principal tem-se o programa principal ( 'princip.c').#include <stdio.h>#include "funcao.h" void main ()

int num;printf ("Entre com número: ");scanf ("%d",&num);if (EPar(num))

printf ("\n\nO número e par.\n");else

printf ("\n\nO número e impar.\n");

Exercícios

1. Escreva um programa que faça uso da função EDivisivel(int a, int b), criadaanteriormente. Organize o seu programa em três arquivos: o arquivo prog.c , conterá oprograma principal; o arquivo func.c conterá a função; o arquivo func.h conterá oprotótipo da função. Compile os arquivos e gere o executável a partir deles.



2. Estude o seguinte programa e diga o valor de cada variável sempre que solicitado:

#include <stdio.h>int num;int func(int a, int b);main()

int first = 0, sec = 50;num = 10;num += func(first, sec); /* Qual é o valor de num, first e sec */

/* antes e depois da atribuição? */printf("\n\nConfira! num = %d\tfirst = %d\tsec = %d",num, first, sec);

int func(int a, int b)

a = (a+b)/2; /* Qual e o valor de a após a atribuição? */num -= a;return a;



PASSAGEM DE PARÂMETROS POR VALOR E PASSAGEM PORREFERÊNCIA

Já se viu que, na linguagem C, quando se chama uma função os parâmetros formais dafunção copiam os valores dos parâmetros que são passados para a função. Isto querdizer que não são alterados os valores que os parâmetros têm fora da função.

Este tipo de chamada de função é denominado chamada por valor, ou seja, passagemde parâmetros por valor. Isto ocorre porque são passados para a função apenas osvalores dos parâmetros e não os próprios parâmetros.

Exemplo:

#include <stdio.h>float sqr (float num);void main ()

float num,sq;printf ("Digite um número: ");scanf ("%f",&num);sq=sqr(num);printf ("\n\nO número original é: %f\n",num);printf ("O seu quadrado é: %f\n",sq);

float sqr (float num)

num=num*num;return num;

No exemplo acima o parâmetro formal num da função sqr() sofre alterações dentro da função, mas avariável num da função main() permanece inalterada: é a passagem por valor.

Outro tipo de passagem de parâmetros para uma função ocorre quando há alterações nos parâmetrosformais, dentro da função, alteram os valores dos parâmetros que foram passados para a função. Este tipo

de chamada de função tem o nome de passagem de parâmetros por referência. Este nomevem do facto de que, neste tipo de chamada, não se passa para a função os valores das variáveis, mas simas suas referências (a função usa as referências para alterar os valores das variáveis fora da função).



Variável num1 num2 a b tempValor lixo lixo lixo lixo lixo

Endereço 100 102 104 106 108

Variável num1 num2 a b tempValor 1000 2000 lixo lixo lixo

Endereço 100 102 104 106 108Variável num1 num2 a b temp

Valor 1000 2000 100 102 lixoEndereço 100 102 104 106 108

Variável num1 num2 a b tempValor 2000 1000 100 102 1000

Endereço 100 102 104 106 108

Quando queremos alterar as variáveis que são passadas para uma função, pode-se declarar os seusparâmetros formais como sendo ponteiros. Os ponteiros são a "referência" que é necessária para poderalterar a variável fora da função.Nota: Quando se chama a função, tem de se colocar um & na frente das variáveis que estivermospassando para a função.Exemplo: #include <stdio.h>

void Swap (int *a,int *b);void main (void)

int num1,num2;num1=1000;num2=2000;

Swap (&num1,&num2);printf ("\n\nNovos valores %d %d\n",num1,num2);

void Swap (int *a,int *b)

int temp;

temp=*a;*a=*b;*b=temp;

Suponhamos que as variáveisutilizadas têm os endereçosrepresentados na figura.

Quando é feita a atribuição a tabelaapresentará os seguintes valores.

Depois de feita a chamada da funçãoswap a variável a fica com oendereço da num1 e a variável b ficacom o endereço de num2.Dentro da função swap quando setrabalha com *a está se a trabalharcom o valor da variável do endereço100, ou seja 1000.Depois de executada a função swap atabela ficaria do seguinte modo:

Exercício

Escreva uma função que receba duas variáveis inteiras e "zere" (coloque a zero) o valordas variáveis. Use o que aprendeu nesta página para fazer a implementação



VECTORES COMO ARGUMENTOS DE FUNÇÕES

Quando se passa um vector como argumento de uma função, pode-se declarar a função de três maneirasequivalentes. Seja o vector: int matrx [50];e que se pretende passá-la como argumento de uma função func(). Pode-se declarar func() das trêsmaneiras seguintes: void func (int matrx[50]); void func (int matrx[]); void func (int *matrx);

Nos três casos, tem-se dentro de func() um int* chamado matrx. Ao se passar um vector para umafunção, na realidade está-se a passar um ponteiro. Neste ponteiro é armazenado o endereço do primeiroelemento do vector. Isto significa que não é feita uma cópia, elemento a elemento do vector. Isto faz comque se possa alterar o valor dos elementos do vector dentro da função.Um exemplo disto já foi visto quando se implementou a função StrCpy().

Exercícios

1. Elabore uma função que retorne e calcule o maior de dois números passados comoparâmetros.

2. Elabore um programa que desenhe um rectângulo numa posição aleatória e com umtamanho aleatório. Utilize uma função com passagem de 4 parâmetros.

Exemplo da chamada da função na main:

rectangulo( 10, 2, 70, 23);

3. Escreva um programa que leia uma frase pelo teclado e o apresente no ecrã o seunúmero de palavras. Crie uma função.

4. Elabore um programa que leia uma letra maiúscula e o converta para minúsculaimprimindo-a no ecrã. Utilize uma função com passagem de valores por referência ecertifique-se que o utilizador insere de facto uma letra maiúscula.



OS ARGUMENTOS ARGC E ARGV

Quando se elabora um programa em "C" é normal, por parte do utilizador, criar também oexecutável do programa para este poder ser executado em qualquer computador (mesmo que estenão tenha o "C" instalado).

Ao criar um ficheiro executável surge um ficheiro com a extensão exe que será utilizado paracorrer o programa.

Por exemplo:

Existe um ficheiro Teste.exe, e para executarmos este programa é necessário digitar apenas Testena linha de comandos do Dos.

Suponha por exemplo o ficheiro "dir" do sistema operativo "Dos".

Para executarmos este ficheiro digitamos na linha de comandos :dir

oudir/p

oudir/w

É precisamente no /p e /w que entram os argumentos.

ARGUMENTOS DE FUNÇÕES PARA MAIN

O "C" pode aceitar argumentos da linha de comando. Os argumentos da linha de comando sãopassados quando o programa é chamado pelo Dos.

Por exemplo :

C:\ Teste Externato Cooperativo da Benedita

Neste exemplo, quatro valores são passados da linha de comando para Teste. Na verdade é mainque recebe as informações específicas.



A função main() pode ter parâmetros formais. Mas o programador não pode escolher quais serão. A declaração maiscompleta que se pode ter para a função main() é: int main (int argc,char *argv[]);

Os parâmetros argc e argv permitem ao programador passar parâmetros na linha de comandos.O argc (argument count) é um inteiro e possui o número de argumentos com os quais a função main() foi chamadana linha de comando. Ele é, no mínimo 1, pois o nome do programa é contado como sendo o primeiro argumento.O argv (argument values) é um ponteiro para uma matriz de strings. Cada string desta matriz é um dos parâmetrosda linha de comando. O argv[0] sempre aponta para o nome do programa (que, como já foi dito, é considerado oprimeiro argumento). É para saber quantos elementos se tem em argv que se temos argc.

Exemplo 1

Programa que faz uso dos parâmetros argv e argc. O programa receber da linha de comando o dia, mês e anocorrentes, e imprime a data em formato apropriado.

Exemplo, supondo que o executável se chame data:data 19 04 99

O programa deverá imprimir:19 de abril de 1999

#include <stdio.h>#include <stdlib.h>void main(int argc, char *argv[])int mes;char *nomemes [] = "Janeiro", "Fevereiro", "Março", "Abril", "Maio", "Junho", "Julho", "Agosto", "Setembro", "Outubro", "Novembro", "Dezembro";if(argc == 4)/* Testa se o número de parâmetros fornecidos está correcto, o primeiroparâmetro é o nome do programa, o segundo o dia o terceiro o mês e o quarto osdois últimos algarismos do ano */ mes = atoi(argv[2]); /* argv contem strings. A string referente ao mês deve ser transformada numnúmero inteiro. A função atoi esta a ser usada para transformar a string nointeiro equivalente */ if (mes<1 || mes>12) /* Testa se o mês é válido */ printf("Erro!\nUso: data dia mês ano, todos inteiros"); else printf("\n%s de %s de 19%s", argv[1], nomemes[mes-1], argv[3]);else printf("Erro!\nUso: data dia mês ano, todos inteiros");



Exemplo 2

// escreve no ecrã todos os nomes passados como argumento.#include <stdio.h>#include <stdlib.h>

main (int argc, char *argv[ ] )

int i;if ( argc <2 )

printf("\n Não tem argumentos, tente outra vez");else

for ( i =1; i< argc; i++ )printf ( "\n O nome %d é %s ", i , argv[ i ] ) ;

Exemplo 3.

// calcula o quadrado de um número passado como argumento.#include <stdio.h>#include <stdlib.h>

main (int argc, char *argv[ ] )

int quadrado ;if ( argc <2 )

printf("\n Não tem argumentos, tente outra vez");else

quadrado = atoi (argv[1]) * atoi (argv[1]) ;printf ("%d",quadrado);

Exercício

Elaborar um programa para calcular a raiz quadrada de um número passado como argumento e mostrar o resultadono ecrã..



RECURSIVIDADE

Na linguagem C, assim como em muitas outras linguagens de programação, uma função pode chamar a siprópria. Uma função assim é chamada função recursiva.A primeira coisa a ter em conta é um critério de paragem. Este vai determinar quando a função deveráparar de chamar a si mesma. Isto impede que a função se chame infinitas vezes.Uma função que calcule o factorial de um número inteiro n é um bom exemplo de uma função recursiva:

#include <stdio.h>int fat(int n);int main()

int n;printf("\n\nDigite um valor para n: ");scanf("%d", &n);printf("\nO factorial de %d e' %d", n, fat(n));return 0;

int fat(int n)

if (n) //se n diferente de 0 return ( n*fat(n-1) )

else return (1);

Enquanto n for diferente de 0, a função fat chama a si mesma, cada vez com um valor menor. n=0 écritério de paragem para esta função.Há certos algoritmos que são mais eficientes quando feitos de maneira recursiva, mas a recursividade éalgo a ser evitado sempre que possível, pois, se usada incorrectamente, tende a consumir muita memória eser lenta.Nota: A memória é consumida cada vez que o computador faz uma chamada a uma função. Com funçõesrecursivas a memória do computador pode se esgotar rapidamente.



AS DIRECTIVAS DE COMPILAÇÃOO pré-processador C é um programa que examina o programa fonte escrito em C e executa certasmodificações nele, baseado nas Directivas de Compilação. As directivas de compilação são comandosque não são compilados, sendo dirigidos ao pré-processador, que é executado pelo compilador antes daexecução do processo de compilação propriamente dito.

Portanto, o pré-processador modifica o programa fonte, entregando para o compilador um programamodificado. Todas as directivas de compilação são iniciadas pelo caracter #. As directivas podem sercolocadas em qualquer parte do programa. Já se usou muito, a directiva #include. Sabemos que ela nãogera código mas diz ao compilador que ele deve incluir um arquivo externo na altura da compilação. Asdirectivas do C são identificadas por começarem por #. As directivas que se vão apresentar são definidaspelo padrão ANSI:

#if #else #include

#fdef #elif #define

#ifndef #endif #undef

A DIRECTIVA INCLUDE

A directiva #include já foi usada diversas vezes. Ela diz ao compilador para incluir, na altura dacompilação, um arquivo especificado.A sua forma geral é: #include "nome_do_arquivo" ou#include <nome_do_arquivo>A diferença entre se usar " " e < > é somente a ordem de procura nos directórios pelo arquivoespecificado. Quando se quiser informar o nome do arquivo com o caminho completo, ou se o arquivoestiver no diretório de trabalho, usa-se " " (ex: "c:\progr\edi.h"). Se o arquivo estiver nos caminhos deprocura pré-especificados do compilador, isto é, se ele for um arquivo do próprio sistema (como é o casode arquivos como stdio.h, string.h, etc...) usa-se< >.

Não há ponto e vírgula após a directiva de compilação. Esta é uma característica importante de todasas directivas de compilação e não somente da directiva #include.



AS DIRECTIVAS DEFINE E UNDEF

A directiva #define tem a seguinte forma geral:#define nome_da_macro sequência_de_caracteres

Quando se usa esta directiva, está-se a informar o compilador para que, todas as vezes que ele encontrar onome_da_macro no programa a ser compilado, ele deve substituí-lo pela sequência_de_caracteresfornecida. Isto é muito útil para deixar o programa mais geral.

Exemplo:

#include <stdio.h>#define PI 3.1416#define VERSAO "2.02"int main ()

printf ("Programa versao %s",VERSAO);printf ("O número pi vale: %f",PI);return 0;

Quando se pretender mudar o valor de PI, ou da VERSAO, no programa acima, basta mexer no início doprograma. Isto torna o programa mais flexível.

É uma convenção de programação (que deve ser seguida, pois torna o programa mais legível) nalinguagem C que as macros declaradas em #defines devem ser todas em maiúsculas.

Um outro uso da directiva #define é o de simplesmente definir uma macro. Neste caso usa-se a seguinteforma geral:

#define nome_da_macro

Neste caso o obcjetivo não é usar a macro no programa (pois ela seria substituída por nada), mas, sim,definir uma macro para ser usada como uma espécie de flag. Isto quer dizer que se define um valor comosendo "verdadeiro" para depois se testar.Também é possível definir macros com argumentos.

Exemplo:

#define max(A,B) ((A>B) ? (A):(B))#define min(A,B) ((A<B) ? (A):(B))...x = max(i,j);y = min(4,5);

Embora pareça uma chamada de função, o uso de max (ou min) simplesmente substitui, em tempo decompilação, o código especificado. Cada ocorrência de um parâmetro formal (A ou B, na definição) serásubstituído pelo argumento real correspondente.

Assim, a linha de código:x = max(i,j);

será substituída pela linha:x = ((i)>(j) ? (i):(j));

A linha de código:x = max(p+q,r+s);

será substituída pela linha:x = ((p+q)>(r+s) ? (p+q):(r+s));



Caso as macros max e min não possuam especificação de tipo. Logo, elas trabalham correctamente paraqualquer tipo de dado, enquanto os argumentos passados forem coerentes. Mas isto pode trazer tambémalgumas armadilhas.

x = max(p++,r++);

será substituída pelo códigox = ((p++)>(r++) ? (p++):(r++));

e em consequência, incrementará o maior valor duas vezes.

Outra armadilha em macros está relacionada com o uso de parênteses. Seja a macro:#define SQR(X) X*X

Imagine-se que se utilize esta macro na expressão abaixo:y = SQR(A+B);

Ao fazer isto, a substituição que será efectuada não estará correcta. A expressão gerada será:y = A+B*A+B;

que obviamente é diferente de (A+B)*(A+B) !

A solução para este problema é incluir parênteses na definição da macro:#define SQR(X)(X)*(X)

Quando se utiliza a directiva #define nunca deve haver espaços em branco no identificador. Por exemplo,a macro:

#define PRINT (i) printf(" %d \n", i)não funcionará correctamente porque existe um espaço em branco entre PRINT e (i). Ao tirar o espaço, amacro funcionará correctamente e poderá ser utilizada para imprimir o número inteiro i, saltando emseguida para a próxima linha.

A directiva #undef tem a seguinte forma geral: #undef nome_da_macro

Ela faz com que a macro que a segue seja apagada da tabela interna queguarda as macros. O compilador passa a partir deste ponto a nãoconhecer mais esta macro.

Exercício

Escreva uma macro que retorne 1 se o seu argumento for um número ímpar e 0 se forum número par.

AS DIRECTIVAS IFDEF E ENDIF

Nesta secção serão tratadas as directivas de compilação condicional. Elas são muito parecidas com oscomandos de execução condicional do C. As duas primeiras directivas que são as #ifdef e #endif.

A suas formas gerais são:

#ifdef nome_da_macrosequência_de_declarações

#endif

A sequência de declarações será compilada apenas se o nome da macro estiver definido. A directiva decompilação #endif é útil para definir o fim de uma sequência de declarações para todas as directivas decompilação condicional. As linhas

#define PORT_0 0x378



.../* Linhas de codigo qualquer... */...#ifdef PORT_0 #define PORTA PORT_0 #include "../sys/port.h"#endif

demonstram como estas directivas podem ser utilizadas. Caso PORT_0 tenha sido previamente definido, amacro PORTA é definida e o ficheiro cabeçalho port.h é incluído.

A DIRECTIVA IFNDEF

A directiva #ifndef funciona ao contrário da directiva #ifdef.


#ifndef nome_da_macro

sequência_de_declarações

#endif

A sequência de declarações será compilada se o nome da macro não tiver sido definido.



A DIRECTIVA IF

A directiva #if tem a seguinte forma geral:

#if expressão_constante


#endif

A sequência de declarações será compilada se a expressão-constante for verdadeira. É muito importanderessaltar que a expressão fornecida deve ser constante, ou seja, não deve ter nenhuma variável.

A DIRECTIVA ELSEA directiva #else tem a seguinte forma geral:

#if expressão_constante


#else


#endif

Ela funciona como seu correspondente, o comando else.

Exemplo:Imagine que se está a trabalhar num sistema, e deseja-se que todo o código possa ser compilado em duasdiferentes plataformas (i.e. Unix e Dos). Para obter isto, será "encapsulada" toda a parte de entrada e saídaem arquivos separados, que serão carregados de acordo com o cabeçalho carregado. Isto pode serfacilmente implementado da seguinte forma:

#define SISTEMA DOS.../*linhas de codigo..*/...#if SISTEMA == DOS #define CABECALHO "dos_io.h"#else #define CABECALHO "unix_io.h"#endif#include CABECALHO



A DIRECTIVA ELIF

A directiva #elif serve para implementar a estrutura if-else-if.


#if expressão_constante_1

sequência_de_declarações_1

#elif expressão_constante_2


#elif expressão_constante_3


.

.

#elif expressão_constante_n

sequência_de_declarações_n

#endif

O funcionamento desta estrutura é idêntico ao funcionamento apresentado anteriormente.



PONTEIROS

O C é altamente dependente dos ponteiros. Para se ser um bom programador em C é fundamental que setenha um bom domínio deles.

Ponteiros são tão importantes na linguagem C que já foram utilizados e ainda não se falaram neles, poismesmo para se fazer um introdução básica à linguagem C precisa-se deles.

COMO FUNCIONAM OS PONTEIROS

Os ints guardam inteiros. Os floats guardam números de ponto flutuante. Os char guardam caracteres.Ponteiros guardam endereços de memória.

Quando se escreve uma morada de um colega, por exemplo, está se a utilizar um ponteiro. O ponteiro é opapel que tem escrito um endereço.

Qual é o sentido disto?

Quando se escreve o endereço de um colega vai-se usar este endereço para achá-lo. O C funciona assim.Anota-se o endereço de algo numa variável ponteiro para depois usar.Um ponteiro também tem tipo. Um ponteiro int, por exemplo, aponta para um inteiro, isto é, guarda oendereço de um inteiro.

DECLARANDO E UTILIZANDO PONTEIROS

Para declarar um ponteiro temos a seguinte forma geral: tipo_do_ponteiro *nome_da_variável;

É o asterisco (*) que faz o compilador saber que aquela variável não vai guardar um valor mas sim umendereço para aquele tipo especificado.

Exemplos de declarações: int *pt; char *temp,*pt2;

O primeiro exemplo declara um ponteiro para um inteiro. O segundo declara dois ponteiros paracaracteres. Eles ainda não foram inicializados (como todas as variáveis do C que são apenas declaradas).Isto significa que eles apontam para um lugar indefinido.



Para saber o endereço de uma variável basta usar o operador &. Veja o exemplo:

int count=10;int *pt;pt=&count;

Nota: A tabela utiliza endereços fictícios

Criou-se um inteiro count com o valor 10 e um apontador para um inteiro pt. A expressão &count dá oendereço de count, o qual armazenamos em pt.Caso a variável count estivesse no endereço 100 o valor de pt era 100.Assim o valor de pt é o valor da variável do endereço 100, ou seja, o valor da variável count, ou seja10 (*pt é igual a 10).

Importante: apesar do símbolo ser o mesmo, o operador * (multiplicação) não é o mesmo operadorque o * (referência de ponteiros).

Dois exemplos de usos simples de ponteiros: #include <stdio.h>int main ()

int num,valor;int *p;num=55;p=&num; /* endereço de num */valor=*p; /* Valor é igualado a num de uma maneira indirecta */printf ("\n\n%d\n",valor);printf ("Endereço para onde o ponteiro aponta: %p\n",p);printf ("Valor da variável apontada: %d\n",*p);return(0);


int num,*p;num=55;p=&num; /* endereço de num */printf ("\nValor inicial: %d\n",num);*p=100; /* Muda o valor de num de uma maneira indirecta */printf ("\nValor final: %d\n",num);return(0);

Nos exemplos acima há um primeiro exemplo do funcionamento dos ponteiros. No primeiro exemplo, ocódigo %p usado na função printf() indica à função que ela deve imprimir um endereço.

Variável count ptValor 10 100

Endereço 100 102



Variável count1 count2 pt1 pt2Valor 10 20 102 100

Endereço 100 102 104 106


Endereço 100 102 104 106

Pode-se fazer algumas operações aritméticas com ponteiros.

Primeira: igualar dois ponteiros. Se há dois ponteiros p1 e p2 pode-se igualá-los fazendo p1=p2. p1 vaiapontar para o mesmo lugar que p2.

Segunda: quando se quer que a variável apontada por p1 tenha o mesmo conteúdo da variável apontadapor p2 deve-se fazer *p1=*p2.

Incremento e decremento

Exemploint count1=10;int count2 = 20int *pt1, *pt2;pt1=&count1;pt2=&count2;

Nota: A Figura utiliza endereços fictíciosQuando se incrementa o ponteiro pt1, por exemplo, ele passa a apontar para o próximo valor do mesmotipo para o qual o ponteiro aponta, ou seja:Isto é, se temos um ponteiro para um inteiro e este é incrementado ele passa a apontar para o próximointeiro, ou seja, incrementa dois bytes.Se se tem um ponteiro para um char e este é incrementado char* ele anda 1 byte na memória e se éincrementa um ponteiro double* ele anda 8 bytes na memória. O decremento funciona semelhantemente.Supondo que p é um ponteiro, as operações são escritas como:

pt1++;pt2--;

(*pt1)++; (*pt2)--;

Importante: Está-se a falar de operações com ponteiros e não de operações com o conteúdo dasvariáveis para as quais eles apontam. Por exemplo, para incrementar o conteúdo da variável apontadapelo ponteiro p, faz-se:

Outras operações aritméticas úteis são a soma e subtracção de inteiros com ponteiros. Suponha-se que sepretende incrementar um ponteiro com 15. Basta fazer: p=p+15; ou p+=15;

Para usar o conteúdo do ponteiro 15 posições adiante:

*(p+15);

A subtracção funciona da mesma maneira.Uma outra operação, às vezes útil, é a comparação entre dois ponteiros.


Endereço 100 102 104 106



Mas que informação se recebe quando comparamos dois ponteiros?

Bem, em primeiro lugar, pode-se saber se dois ponteiros são iguais ou diferentes (== e !=). No caso deoperações do tipo >, <, >= e <= está-se a comparar qual ponteiro aponta para uma posição mais alta namemória.

A comparação entre ponteiros pode dizer qual dos dois está "mais adiante" na memória. p1>p2

Exercícios

a) Explique a diferença entre p++; (*p)++; *(p++);

O que quer dizer *(p+10);?

Explique o que entende por comparação entre ponteiros

b) Qual o valor de y no final do seguinte programa? Tente primeiro descobrir e depois verifique nocomputador o resultado. A seguir, escreva um /* comentário */ em cada comando de atribuiçãoexplicando o que ele faz e o valor da variável à esquerda do '=' após sua execução.

int main() int y, *p, x; y = 0; p = &y; x = *p; x = 4; (*p)++; x--; (*p) += x; printf ("y = %d\n", y); return(0);

Nota: Não se pode dividir ou multiplicar ponteiros, adicionar dois ponteiros, adicionar ou subtrair floats oudoubles de ponteiros.



PONTEIROS E VECTORES

VECTORES COMO PONTEIROS

Quando se declara uma matriz da seguinte forma:

tipo_da_variável nome_da_variável [tam1][tam2] ... [tamN];

O compilador C calcula o tamanho, em bytes, necessário para armazenar esta matriz. Este tamanho é:

tam1 x tam2 x tam3 x ... x tamN x tamanho_do_tipo

O compilador então aloca este número de bytes num espaço livre de memória.

O nome da variável que se declarou é na verdade um ponteiro para o tipo da variável da matriz. (Esteconceito é fundamental. )

Eis porque: Tendo alocado na memória o espaço para a matriz, o nome da variável (que é um ponteiro)passa a apontar para o primeiro elemento da matriz.

Mas aí surge a pergunta: então como é que podemos usar a seguinte notação? nome_da_variável[índice]

é absolutamente equivalente a se fazer:

*(nome_da_variável+índice)

e o *nome_da_variável é equivalente a nome_da_variável[0]

Quando se tem que percorrer todos os elementos de uma matriz de uma forma sequencial, pode-se usarum ponteiro, o qual vai sendo incrementado. Qual a vantagem?Considere o seguinte programa para zerar uma matriz:void main ()

float matrx [50][50];int i,j;for (i=0;i<50;i++)

for (j=0;j<50;j++) matrx[i][j]=0.0;Pode-se reescrevê-lo usando ponteiros: void main ()

float matrx [50][50];float *p; int count;p=matrx[0];for (count=0;count<2500;count++)

*p=0.0; p++;

No primeiro programa, cada vez que se faz matrx[i][j] o programa tem que calcular o deslocamento paradar ao ponteiro. Ou seja, o programa tem que calcular 2500 deslocamentos. No segundo programa o únicocálculo que deve ser feito é o de um incremento de ponteiro. Fazer 2500 incrementos num ponteiro émuito mais rápido que calcular 2500 deslocamentos completos.Há uma diferença entre o nome de um vector e um ponteiro que deve ser frisada: um ponteiro é umavariável, mas o nome de um vector não é uma variável. Isto significa, que não se consegue alterar oendereço que é apontado pelo "nome do vector". Seja:



int vector[10]; int *ponteiro, i; ponteiro = &i;

/* as operações a seguir são inválidas */

vector = vector + 2; /* ERRADO: vector não é variável */ r++; /* ERRADO: vector não é variável */ vector = ponteiro; /* ERRADO: vector não é variável */

/* as operações abaixo são válidas */

ponteiro = vector; /* CERTO: ponteiro é variável */ ponteiro = vector+2; /* CERTO: ponteiro é variável */



Exercícios

1. Qual das instruções abaixo é correcta para declarar um ponteiro para inteiro?

a. *int pti;

b. *pti;

c. &i;

d. int_pti pti;

e. int *pti;

2. Seja a seguinte sequência de instruções num programa C:

int *pti; int i = 10; pti = &i;

Qual afirmativa é falsa?

a. pti armazena o endereço de i

b. *pti é igual a 10

c. ao se executar *pti = 20; i passará a ter o valor 20

d. ao se alterar o valor de i, *pti será modificado

e. pti é igual a 10

Se i e j são variáveis inteiras e pi e pj são ponteiros para inteiro, qual atribuição é ilegal?

a. pi = &i;

b. *pj = &j;

c. pj = pi

d. pj=pi;

e. i = (*pi)+++*q;

Seja a seguinte sequência de instruções num programa C:

int *pti; int veti[]=10,7,2,6,3; pti = veti;

Qual afirmativa é falsa?

a. *pti é igual a 10

b. *(pti+2) é igual a 2

c. pti[4] é igual a 3

d. pti[1] é igual a 10

Na sequência de instruções abaixo:

float f; float *pf;



pf = &f; scanf("%f", pf);

a. Efectuamos a leitura de f

b. Não efectuamos a leitura de f

c. Temos um erro de sintaxe

d. Deveríamos estar usando &pf no scanf


11- Seja a seguinte sequência de instruções

int i=10, j=20; int *pti, *ptj; pti = &i; ptj = &j;

Qual expressão não é válida?

a. j = pti = = ptj;

b. pti += ptj;

c. pti++;

d. i = pti || ptj;



ESTRUTURAS

O QUE É UMA ESTRUTURA?

Uma estrutura agrupa várias variáveis numa só. Funciona como uma ficha pessoal que pode ter nome,telefone e endereço. A ficha seria uma estrutura.

Ao contrário dos vectores (ver unidade 6) as estruturas podem armazenar vários dados de diferentestipos. Pode-se definir uma estrutura com um tipo de dados.

Pode-se pensar numa estrutura como uma base de dados (entidade)composta por diferentes elementos (atributosou campos).

Imagine por exemplo uma entidade Felinos emque as suas principais características(atributos) são o número, o nome, a raça, opaís e a data de nascimento.

Cada registo da base de dados seria felino.

Entidade: FelinosAtributos Felino ...(registo ..) Felino 11 (registo 11) Felino 12 (registo 12)Número ................. 1100 1200Nome ................. Tareco Gato das BotasRaça ................. Tigre LincePaís ................. Mongólia PortugalData de Nascimento ................. 01-01-1990 23-06-1985

Consulte a sebenta da disciplina de Aplicações Informáticas para se recordar das bases de dados, dasentidades, dos atributos e das ocorrências. Veja como se cria uma base de dados.

Nome: Tareco

Data Nascimento: 01-01-1990

Número: 1100

Raça: TigrePaís: Mongólia



CRIAR UMA ESTRUTURA UTILIZANDO A LINGUAGEM C

Ao criar-se uma estrutura, está-se a criar também um novo tipo de dados, tipo esse que é específico aoprograma.

Para se criar uma estrutura em C usa-se o comando struct que deverá surgir logo seguido dos includes. Asua forma geral é:

struct nome_do_tipo_da_estrutura

tipo_1 nome_1;

tipo_2 nome_2;

...

tipo_n nome_n;

variáveis_da_estrutura ;

O nome_do_tipo_da_estrutura é o nome da estrutura, ou seja, é o nome do tipo dedados que se vai criar. As variáveis_da_estrutura (poderá ser opcional) são variáveisque terão de ser declaradas e que serão do tipo nome_do_tipo_da_estrutura.

Tendo ou não declaradas as variáveis da estruturas a seguir à chaveta de fecho - -deverá surgir sempre um ; (ponto e vírgula)

Lembre-se, por exemplo, dos tipos de dados int, float e char. Lembre-se também de como sedeclaram variáveis.

Exercício resolvido

Crie uma estrutura (tipo de dado) que permita guardar o número, o nome, a raça, o país e a data denascimento de um felino (veja exemplo anterior).

Resolução

struct felino

int numero;char nome[20];char raca[20];char pais[20];char data_nascimento[10];

f ;

felino: nome da estrutura (tipo de dado)

f: variável do tipo struct felino

dados/campos que se pretendem guardar



DECLARAR VARIÁVEIS DO TIPO STRUCT

Variáveis globais

Existem duas formas de declarar uma variável do tipo struct global.

Como já foi referido anteriormente, uma variável do tipo struct declara-se logo a seguir à declaração daestrutura e antes do ; (ponto e vírgula).

Exemplo 1struct Estrutura

int a, int b;E;

Assim, e analisando o exemplo acima, a variável E é do tipo struct Estrutura e é uma variável globaluma vez que é declarada antes da função main.

A outra forma utilizada é semelhante à declaração de uma variável do tipo inteiro. Bastaidentificar o tipo seguido do nome da variável igualmente antes da função main (verexemplo 2).


int a, int b;;struct Estrutura E;

Uma variável global é válida em qualquer parte do programa (ver as unidades 2 e 3)



Variáveis locais

A declaração de variáveis locais para um tipo struct não diferem das outras.


int a, int b;;void main ( )

struct Estrutura E;

No exemplo 3 a variável E é apenas válida no interior da função main.

Exercício proposto

Crie uma estrutura que permita guardar o número, o nome, a turma, e o ano de dois alunos.

ACEDER AOS CAMPOS DE UM TIPO STRUCT

Imagine a zona de memória do computador preenchida com o seguinte programa:

void main ( )

int a = 5;float b = 1,2;char c = ‘X’;

Supondo que o armazenamento dos dados começa no endereço 100, poder-se-á então planificar amemória do seguinte modo:

Variáveis a b c

Dados 5 1,2 XEndereços 100 102 104

No caso das estruturas, para a estrutura:

struct cidadao

int num;char nome[40];

;



void main ( )

struct cidadao E, D;

ter-se-ia a seguinte planificação:

Variáveis E DCampos num nome num nomeDados ? ? ? ?

Endereços 100 100 + tamanho da estrutura

Inserir dados nos campos de uma estrutura

Para aceder aos campos da estrutura, utiliza-se o operador • (ponto) que separa a variável do tipo structdos campos (ver exemplo).

Exemplo#include <stdio.h>struct cidadao


;void main ( )

struct cidadao E, D;E.num = 1;D.num = 2;printf ( “Indique o nome do 1º- “) ;gets (E.nome ) ; // a entrada poderia ser Manuelprintf ( “Indique o nome do 2º- “) ;gets (D.nome ) ; // a entrada poderia ser Maria

Com a inserção de dados a memória ficaria ocupada do seguinte modo

Variáveis E DCampos num nome num nomeDados 1 Manuel 2 Maria

Endereços 100 100 + tamanho da estrutura

Nota: Os endereços de memória são fictícios.


ECB - PAULO VALENTIM100

Visualizar dados dos campos de uma estrutura

Para visualizar os dados que se encontram nos campos da estrutura também se utiliza o operador •(ponto).

Exemplo#include <stdio.h>struct cidadao


;void main ( )

struct cidadao E, D;E.num = 1;D.num = 2;strcpy(E.nome, “Manuel”) ;strcpy (D.nome, Maria) ;printf(“ Conteúdo da variável E %d, %s “, E.num, E.nome);printf(“ Conteúdo da variável D %d, %s “, D.num, D.nome);



VECTORES DO TIPO STRUCT

Como já foi estudado, uma estrutura pode ser comparada a uma base de dados quecontém campos e registos. Assim para inserir dados para 5 registos, por exemplo paraconstruir uma base de dados para os Felinos, será necessário declarar 5 variáveis do tipostruct Felinos.

Vejamos então o seguinte exercício resolvido:


Elabore um programa que permita ao utilizador inserir dados para 5 felinos. Os dados que deveramser inseridos são o número, o nome, a raça, o país e a data de nascimento de cada felino.

Resolução 1#include <stdio.h>struct felino


;void main ()

struct felino f1, f2, f3, f4, f5;printf (“Qual o número do 1º felino”);scanf (“%d”, f1.numero);printf (“Qual o nome do 1º felino”);scanf (“%s”, f1.nome);.....printf (“Qual o número do 3º felino”);scanf (“%d”, f3.numero);......printf (“Qual o nome do 5º felino”);scanf (“%s”, f5.nome);

Análise ao exercício

Será esta a resolução mais prática, organizada e rápida?

Sim? Então e para uma inserção para 500 registos? Ter-se-ia que declarar 500 variáveise fazer 2500 printf’s e 2500 scanf’s?

É obvio que esta não é a melhor solução.

Um estrutura é como qualquer outro tipo de dado no C. Pode-se, portanto, vectores dotipo struct.

Analise uma 2º resolução que suportará n registos:



Resolução 2#include <stdio.h>#define MAX 5struct felino


;void main ()

struct felino f[MAX];in i;for (i = 0; i < MAX; i ++)

printf (“Qual o número do %dº felino”, i);scanf (“%d”, f[i].numero);printf (“Qual o nome do %dº felino”,i);scanf (“%s”, f[i].nome);printf (“Qual o raça do %dº felino”,i);scanf (“%s”, f[i].raca);printf (“Qual o país do %dº felino”,i);scanf (“%s”, f[i].pais);printf (“Qual a data de nascimento do %dº felino”,i);scanf (“%s”, f[i].data_nascimento);



Exercício proposto

Que modificação faria na 2º resolução para que esta suportasse 500 registos.

IMPORTANTE

Pode-se atribuir duas estruturas que sejam do mesmo tipo. O C irá, neste caso, copiar uma estruturana outra. Esta operação não apresenta problemas pois quando se declara:#include <stdio.h>struct felino

int numero;//.....

;//....void main ()

struct felino f1, f2;//inserir dados para f1Inserir_Dados( &f1);f2 = f1;

São declaradas duas variáveis do tipo felino, f1 e f2. Supondo que seja declarada uma funçãoInseir_Dados() que faça a leitura de uma estrutura, admitindo-se que após a execução da segundalinha de main(), a estrutura f1 estará preenchida com dados válidos. Os valores de f1 são copiados emf2 apenas com a expressão de atribuição:

f2=f1;Todos os campos de primeira serão copiados na ficha chamada segunda. Deve-se tomar cuidado coma seguinte declaração:

struct felino f [100];pois neste caso f é um ponteiro para a primeira ficha.



O COMANDO TYPEDEF

O comando typedef permite ao programador definir um novo nome para um determinado tipo. A suaforma geral é:

typedef antigo_nome novo_nome;

Exemplo:

typedef int inteiro;

Agora pode-se declarar o tipo inteiro.

O comando typedef também pode ser utilizado para dar nome a tipos complexos, como as estruturas. Asestruturas criadas no exemplo da página anterior poderiam ser definidas como tipos através do comandotypedef. O exemplo ficaria:

#include <stdio.h>typedef struct felino

int numero;cha nome[20];//.....

Tfelino;//....void main ()

Tfelino f;......



O COMANDO SIZEOF

O operador sizeof é usado para se saber o tamanho de variáveis ou de tipos. Ele retorna o tamanho do tipoou variável em bytes.

O sizeof admite duas formas:

sizeof nome_da_variável

sizeof (nome_do_tipo)

Para saber o tamanho de um float utiliza-se sizeof(float)

Para saber o tamanho da variável f utiliza-se sizeof f

O operador sizeof também funciona com estruturas, campos bit, uniões e enumerações.Outra aplicação importante do operador sizeof é para se saber o tamanho de tipos definidos peloutilizador. Seria, por exemplo, uma tarefa complicada a de alocar a memória para um ponteiro para aestrutura cidadao se não fosse o uso de sizeof.

Exemplo:

#include <stdio.h>struct cidadao char nome [50]; int telefone;;void main(void) struct cidadao *ex; ex = (struct cidadao *) malloc (sizeof(struct cidadao)); ...

O comando sizeof é importantíssimo na utilização de ficheiros e estruturas (ver unidade 9).



ALOCAÇÃO DINÂMICA – O COMANDO MALLOC

A alocação dinâmica permite ao programador criar variáveis durante o tempo de execução, ou seja, alocarmemória para novas variáveis enquanto o programa está a ser executado.

MALLOC

A função malloc() serve para alocar memória, ou seja, serve para reservar memória para receber dados deuma variável.

Quando se declara uma variável do tipo int, por exemplo:

int x;

o compilador de C já sabe interiormente que tem que reservar 2 bytes para alocar a variável x (verunidade 2 - Variáveis, constantes, operadores e expressões).

ou, então quando se declara um vector do tipo int, para 10 elementos:

int v[10]

são reservados 2*10 bytes para alocar o vector v.

Onde se utiliza a função malloc?

A função malloc utiliza-se nos casos em que o programador necessita de usar um dado e não sabe aquantidade de memória que este ocupa.

Um bom exemplo poderá ser a resolução do seguinte problema:


Elabore um programa que permita efectuar e imprimir a média de N números inteiros inseridos peloutilizador, guardando num vector todos os N números.

Solução

Como o programador não sabe o número de números que o utilizador pretende inserir, nunca poderádeclarar um vector de inteiros, uma vez que limitará sempre o número de elementos a inserir, assim outilizador terá que alocar memória para N números usando a função malloc.



Explicação da função

A função malloc tem o seguinte protótipo: void *malloc (unsigned int quantidade);

A função recebe como parâmetro o número de bytes que se pretende alocar (quantidade), aloca namemória e retorna um ponteiro void * para o primeiro byte alocado. O ponteiro void * pode ser atribuídoa qualquer tipo de ponteiro.Se não existir memória suficiente para alocar a memória requisitada a função malloc() retorna umponteiro nulo.

Resolução

#include <stdio.h>#include <stdlib.h>void main (void)

int *p;int n, contador, soma=0, media;printf ("Quantos números pretende inserir ->")scanf ("%d",&n);p=(int *) malloc (n*sizeof(int));if (!p) printf ("** Erro: Memoria Insuficiente **"); exit;for (contador=0; contador <n; contador ++)

printf("\nInsira o %d número->", contador+1);scanf("%d",p);soma += *p); // ou soma += p[contador];p++;

printf ("A média é ->%f", float(soma/n));

Explicação do problema

No exemplo acima, é alocada memória suficiente para se colocar n números inteiros. O operador sizeof()retorna o número de bytes de um inteiro (ver função sizeof). O ponteiro void* que malloc() retorna éconvertido para um int* pelo cast e é atribuído a p. A declaração seguinte testa se a operação foi bemsucedida. Se não tiver sido, p terá um valor nulo, o que fará com que !p retorne verdadeiro. Se a operaçãotiver sido bem sucedida, pode-se usar o vector de inteiros alocados normalmente.

Exercício proposto

Elabore um programa que faça uma alocação de memória para uma variável que permita guardar umvalor inteiro e um real (ver tipo de dados struct).



O COMANDO FREE

Quando se aloca memória dinamicamente - por exemplo, utilizando o comando malloc - é necessáriolibertá-la quando ela não for mais necessária. Para isto existe a função free(). Para utilizá-la basta passar para free() o ponteiro que aponta para o início da memória alocada.


Elabore um programa, tomando como base no exercício resolvido da secção sizeof, que liberte amemória de uma variável do tipo ponteiro para uma estrutura.

Resolução

#include <stdio.h>struct cidadao char nome [50]; int telefone;;void main(void)

struct cidadao *ex;ex = (struct cidadao *) malloc (sizeof(struct cidadao));if (!ex)

printf ("** Erro: Memória Insuficiente **");

exit;...free(p);



PASSANDO VARIÁVEIS DO TIPO STRUCT PARAFUNÇÕES

A passagem de variáveis do tipo struct para funções é feita do mesmo modo que uma cadeia decaracteres, por exemplo:

strcpy (felino.nome,"Tareco");

Passagem por valor

Neste exemplo um elemento de uma estrutura é passado para a função strcpy( ).

Pode-se também passar para uma função uma estrutura inteira. Vejamos a seguinte função:void Inserir_Felino (struct felino f)...

A passagem da estrutura para a função é feita por valor.

Numa passagem de variáveis por valor para uma função as alterações nas variáveis dentro da funçãonão terão efeito fora desta. (ver unidade 3). Este pormenor pode-se contornar passando para a funçãoum ponteiro para a variável.


Elabore um programa que permita ao utilizador inserir dados para 1 felino utilizando uma função. Osdados que deveram ser inseridos são o número, o nome e a raça de cada felino.

Resolução#include <stdio.h>struct felino

int numero;char nome[20];char raca[20];

;void Inserir_Felino (struct felino f);void main ()

struct felino X;Inserir_Felino ( X );printf (“O número do felino que acabou de inserir é %d”, X.numero);

void Inserir_Felino (struct felino f)

printf (“Qual o número do felino”);scanf (“%d”, f.numero);printf (“Qual o nome do felino”);scanf (“%s”, f.nome);printf (“Qual a raça do felino”);



scanf (“%s”, f.raca);

Exercícios propostos

Acha que a resolução apresentada é a mais funcional? Porquê?

Qual seria o Output se o número do felino inserido fosse o 100? Justifique.

Elabore um programa semelhante ao anterior que recebe os dados do felino na função main e osimprima dentro de uma função Imprimir_Felino. Utilize variáveis locais.

Refaça a programa anterior de modo a inserir 5 registos para 5 felinos numa função Inserir_Felino eimprimir os mesmos 5 numa função Imprimir_Felino.

Passagem por referência

A passagem de variáveis por referência, como já foi referido na unidade 3, é feita através da utilização deponteiros.

Os ponteiros para uma estrutura funcionam como os ponteiros para qualquer outro tipo de dados em C.Há, no entanto, um detalhe importante a ser considerado:

Ao declarar uma variável :struct felino *f;

para aceder a um elemento da estrutura poder-se-ia fazer:(*p).nomeou utilizando o operador seta (->)p->nome (mais utilizado)

No caso da passagem de um vector de estruturas, para deslocar o ponteiro para o registo seguinte deve-seutilizar o operador ++.

p++;




Elabore um programa que permita ao utilizador inserir dados (número, nome e raça) para 1 felinoatravés de uma função utilizando passagem de valores/variáveis por referência, e que, depois deinseridos, os imprima na função main.

Refaça o programa anterior para a inserção de 6 registos utilizando, para isso, um vector de estruturascom 6 elementos.



APONTADORES PARA ESTRUTURAS E ESTRUTURASDENTRO DE ESTRUTURAS

APONTADORES PARA ESTRUTURAS

Quando se abordou a passagem de estruturas para funções referiu-se que a passagem por referência é feitaatravés da utilização de ponteiros e também na utilização do operador seta (->).

É possível, como para todos os outros tipos de dados, declarar ponteiros para estruturas.

Exemplo:#include <stdio.h>struct felino

int numero;char nome[20];char raca[20];

;void main ()

struct felino *F;printf (“Qual o número do felino”);scanf (“%d”, f->numero);printf (“%d”, f->numero);....

ESTRUTURAS DENTRO DE ESTRUTURAS

É possível tornar uma estrutura parte de uma segunda estrutura.

Imagine um automóvel, que tem marca, pais que fundou a marca e o ano de fundação da marca. Cadamarca de um automóvel produz vários modelos e com características específicas – cilindrada, tipo decombustível, velocidade máxima.


Declare as estruturas necessárias para armazenar os dados descritos acima para um automóvel.



Resolução

struct automovel_modelo

char nome_modelo[20], tipo_combustivel[10];int cilindrada, velocidade_maxima;

AutoMarca;

struct automovel_marca

char marca[20], pais[30];int ano;struct automovel_modelo modelo;

AutoModelo;


Tomando como base as estruturas definidas no exercício proposto:

Diga como faria para imprimir o valor do campo velocidade_maxima.

Elabore um programa que permita inserir todos os campos para dois automóveis.



UNIÕES

Uma declaração union determina uma única localização de memória onde podem estar armazenadasvárias variáveis diferentes. A declaração de uma união é semelhante à declaração de uma estrutura:

union nome_do_tipo_da_union

tipo_1 nome_1;

tipo_2 nome_2;

...

tipo_n nome_n;

variáveis_union;

Exemplo:union angulo float graus; float radianos;;

Na união tem-se duas variáveis (graus e radianos) que, apesar de terem nomes diferentes, ocupam omesmo local da memória. Isto quer dizer que só se ocupa o espaço equivalente a um único float.

As uniões podem ser feitas também com variáveis de diferentes tipos. Neste caso, a memória alocadacorresponde ao tamanho da maior variável no union.


Elabore um programa que permita ao utilizador digitar o valor de um ângulo em graus ou emradianos utilizando a estrutura de dados union para guardar o valor inserido.

Resolução

#include <stdio.h>#define GRAUS 'G'#define RAD 'R'union angulo int graus; float radianos;;void main()

union angulo ang;char op;printf("\nNúmeros em graus ou radianos? ");scanf("%c",&op);



if (op == GRAUS)

ang.graus = 180; printf("\nAngulo: %d\n",ang.graus);

else

if (op == RAD)

ang.radianos = 3.1415;printf("\nAngulo: %f\n",ang.radianos);

else

printf("\nEntrada inválida!!\n");



ARQUIVOS

ABRIR E FECHAR UM ARQUIVO

O sistema de entrada e saída do ANSI C é composto por uma série de funções, cujos protótipos estãoreunidos em stdio.h. Todas estas funções trabalham com o conceito de "ponteiro de arquivo". Este não éum tipo propriamente dito, mas uma definição usando o comando typedef. Esta definição também está noarquivo stdio.h. Pode-se declarar um ponteiro de arquivo da seguinte maneira:

FILE *p;p será então um ponteiro para um arquivo.

fopen

Esta é a função de abertura de arquivos.

Exemplo:FILE *f ;f=fopen(“ficheiro.dat”, r);

O nome_do_arquivo – ficheiro.dat- determina qual o arquivo que deverá ser aberto. O r indica modo deabertura que diz à função fopen() que tipo de uso se vai fazer do arquivo. A tabela abaixo mostra osvalores de modo válidos:

Modo Significado

"r" Abre um arquivo texto para leitura. O arquivo deve existir antes de ser aberto.

"w"Abrir um arquivo texto para gravação. Se o arquivo não existir, ele será criado. Se já existir, o conteúdoanterior será destruído.

"a"Abrir um arquivo texto para gravação. Os dados serão adicionados no fim do arquivo ("append"), se elejá existir, ou um novo arquivo será criado, no caso de arquivo não existente anteriormente.

"rb" Abre um arquivo binário para leitura. Igual ao modo "r" anterior, só que o arquivo é binário.

"wb" Cria um arquivo binário para escrita, como no modo "w" anterior, só que o arquivo é binário.

"ab" Acrescenta dados binários no fim do arquivo, como no modo "a" anterior, só que o arquivo é binário.

"r+" Abre um arquivo texto para leitura e gravação. O arquivo deve existir e pode ser modificado.

"w+"Cria um arquivo texto para leitura e gravação. Se o arquivo existir, o conteúdo anterior será destruído.Se não existir, será criado.



"a+"Abre um arquivo texto para gravação e leitura. Os dados serão adicionados no fim do arquivo se ele jáexistir, ou um novo arquivo será criado, no caso de arquivo não existente anteriormente.

"r+b" Abre um arquivo binário para leitura e escrita. O mesmo que "r+" acima, só que o arquivo é binário.

"w+b" Cria um arquivo binário para leitura e escrita. O mesmo que "w+" acima, só que o arquivo é binário.

"a+b"Acrescenta dados ou cria uma arquivo binário para leitura e escrita. O mesmo que "a+" acima, só que oarquivo é binário

Podería-se então, para abrir um arquivo binário para escrita, escrever:FILE *fp; /* Declaração da estruturafp=fopen ("exemplo.bin","wb");/* o arquivo chama-se exemplo.bin e está localizado no diretóriocorrente */if (!fp) printf ("Erro na abertura do arquivo.");

A condição !fp testa se o arquivo foi aberto com sucesso porque no caso de um erro a função fopen()retorna um ponteiro nullo (NULL).

Uma vez aberto um arquivo, pode-se ler ou escrever nele utilizando as funções que serãoapresentadas nas próximas páginas.

Todas as vezes que se estiver a trabalhar com arquivos, há uma espécie de posição actual no arquivo.Esta é a posição de onde será lido ou escrito o próximo caracter.

Normalmente, num acesso sequencial a um arquivo, não se tem que mexer nesta posição pois quandose lê um caracter a posição no arquivo é automaticamente actualizada. Num acesso aleatório tem dese mexer nesta posição (ver fseek()).



exit

Esta função aborta a execução do programa. Pode ser chamada de qualquer ponto no programa e faz comque o programa termine e retorne, para o sistema operativo, o código_de_retorno. A convenção maisusada é que um programa retorne zero no caso de um término normal e retorne um número não nulo nocaso de ter ocorrido um problema.A função exit() torna-se importante em casos como alocação dinâmica e abertura de arquivos pois nestescasos, se o programa não conseguir a memória necessária ou abrir o arquivo, a melhor saída pode serterminar a execução do programa.Exemplo:

#include <stdio.hmain (void)FILE *fp;...fp=fopen ("exemplo.bin","wb");if (!fp) printf ("Erro na abertura do arquivo. Fim de programa."); exit (1); ...return 0;

fclose

Quando se usa um arquivo deve-se fechá-lo. Para tanto usa-se a função fclose():

Fechar um arquivo faz com que qualquer caracter que tenha permanecido no "buffer" associado ao fluxode saída seja gravado.

Mas, o que é este "buffer"?

Quando se envia caracteres para serem gravados num arquivo, estes caracteres são armazenadostemporariamente numa área de memória (o "buffer") em vez de serem escritos em discoimediatamente. Quando o "buffer" estiver cheio, o seu conteúdo é escrito no disco. A razão para sefazer isto tem a ver com a eficiência nas leituras e gravações de arquivos. Se, para cada caracter agravar, se tivésse que posicionar a cabeça de gravação num ponto específico do disco, apenas paragravar aquele caracter, as gravações seriam muito lentas. Assim estas gravações só serão efectuadasquando existir um volume razoável de informações a serem gravadas ou quando o arquivo forfechado.

Nota: A função exit() fecha todos os arquivos que um programa tiver aberto.



LENDO E ESCREVENDO CARACTERES EM ARQUIVOS

putc ou fputcA função putc é uma função de escrita em arquivos. Escreve um caracter no arquivo.

O seu protótipo é: int putc (int ch,FILE *fp);

O programa a seguir lê uma string do teclado e escreve-a, caracter por caracter num arquivo em disco (oarquivo arquivo.txt, que será aberto no diretório corrente).

#include <stdio.h>void main() FILE *fp; char string[100]; int i; fp = fopen("arquivo.txt","w"); /* Arquivo ASCII, para escrita*/ if(!fp) printf( "Erro na abertura do arquivo"); exit(0); printf("Digite com a string a ser gravada no arquivo:"); gets(string); for(i=0; string[i]!=’\0’; i++) putc(string[i], fp); fclose(fp);

getc ou fgetc

Retorna um caracter lido do arquivo.

O seu protótipo: int getc (FILE *fp);

O programa a seguir imprime os dois primeiros caracteres do ficheiro arquivo.txt, que será aberto nodiretório corrente.

#include <stdio.h>void main()

FILE *fp; char c; fp = fopen("arquivo.txt","r"); /* Arquivo ASCII, paraleitura */

if(!fp) printf( "Erro na abertura do arquivo"); exit(0);

c=getc(fp); printf (“%c”,c); printf(“%c”, getc(fp)); fclose(fp);



feof

EOF ("End of file") indica o fim de um arquivo. Às vezes, é necessário verificar se um arquivo chegou aofim. Para isto pode-se usar a função feof(). Ela retorna não-zero se o arquivo chegou ao EOF, casocontrário retorna zero. O seu protótipo é:

int feof (FILE *fp);

Outra forma de se verificar se o final do arquivo foi atingido é comparar o caracter lido por getc comEOF. O programa a seguir abre um arquivo já existente e lê-o, caracter por caracter, até que o final doarquivo seja atingido. Os caracteres lidos são apresentados no ecrã:

#include <stdio.h>int main() FILE *fp; char c; fp = fopen("arquivo.txt","r"); /* Arquivo ASCII, para leitura */ if(!fp) printf( "Erro na abertura do arquivo"); exit(0); while(!feof(fp)) /* Enquanto não chegar ao final do arquivo */ c = getc(fp); printf("%c", c); /* imprime o caracter lido */ fclose(fp); return 0;

A seguir é apresentado um programa onde várias operações com arquivos são realizadas, usando asfunções vistas nesta página. Primeiro o arquivo é aberto para a escrita, e escreve-se qualquer coisa nele.Em seguida, o arquivo é fechado e novamente aberto para a leitura. Verifique o exemplo.

#include <stdio.h>#include <string.h>void main()

FILE *p;char c, str[30], frase[80] = "Este é um arquivo chamado: ";int i;/* Lê um nome para o arquivo a ser aberto: */printf("\n\n Digite um nome para o arquivo:\n");gets(str);if (!(p = fopen(str,"w")))

/* Caso ocorra algum erro na abertura do arquivo..*/ /* o programa aborta automaticamente */ printf("Erro! Impossivel abrir o arquivo!\n"); exit(1);

/* Se não houve erro, imprime no arquivo e o fecha ...*/strcat(frase, str);for (i=0; frase[i]; i++) putc(frase[i],p);fclose(p);/* Abre novamente para leitura */p = fopen(str,"r");



while (!feof(p))/* Enquanto não se chegar no final do arquivo */

c = getc(p); /* Lê um caracter no arquivo */ printf("%c",c); /* e o imprime no ecrã */

fclose(p); /* Fecha o arquivo */

fgets

Para se ler uma string de um arquivo pode-se usar fgets() cujo protótipo é: char *fgets (char *str, int tamanho,FILE *fp);

A função recebe 3 argumentos: a string a ser lida, o limite máximo de caracteres a serem lidos e oponteiro para FILE, que está associado ao arquivo de onde a string será lida. A função lê a string até queum caracter de nova linha seja lido ou tamanho-1 caracteres tenham sido lidos. Se o caracter de novalinha ('\n') for lido, ele fará parte da string, o que não acontecia com gets. A string resultante sempreterminará com '\0' (por isto somente tamanho-1 caracteres, no máximo, serão lidos).

Exemplo:#include <string.h>#include <stdio.h>main( )

FILE *s; char msg[20]; s = fopen("c:\\lixo.txt", "r+"); fseek(s, 0, SEEK_SET); fgets(msg, 20, s); printf("%s", msg); fclose(s);

fputs

Protótipo: char *fputs (char *str,FILE *fp);Escreve uma string num arquivo.



ferror e perrorProtótipo de ferror: int ferror (FILE *fp);A função retorna zero, se nenhum erro ocorreu e um número diferente de zero se algum erro ocorreudurante o acesso ao arquivo.ferror() torna-se muito útil quando se quer verificar se cada acesso a um arquivo teve sucesso, de modoque se consiga garantir a integridade dos dados. Na maioria dos casos, se um arquivo pode ser aberto, elepode ser lido ou gravado. Porém, existem situações em que isto não ocorre. Por exemplo, pode acabar oespaço em disco enquanto se grava, ou o disco pode estar com problemas e não se consegue ler, etc.Uma função que pode ser usada em conjunto com ferror() é a função perror() (print error), cujoargumento é uma string que normalmente indica em que parte do programa o problema ocorreu.No exemplo a seguir, faz-se uso de ferror, perror e fputs

#include <stdio.h>int main() FILE *pf; char string[100]; if((pf = fopen("arquivo.txt","w")) ==NULL) printf("\nNao consigo abrir o arquivo ! "); exit(1); do printf("\nDigite uma nova string. Para terminar, digite <enter>: "); gets(string); fputs(string, pf); putc('\n', pf); if(ferror(pf)) perror("Erro na gravacao"); fclose(pf); exit(1); while (strlen(string) > 1); fclose(pf);

fread

Pode-se escrever e ler blocos de dados. Para tanto, tem-se as funções fread() e fwrite(). O protótipo defread() é: unsigned fread (void *buffer, int número_de_bytes, int count,FILE *fp);

O buffer é a região de memória na qual serão armazenados os dados lidos. O número de bytes é otamanho da unidade a ser lida. count indica quantas unidades devem ser lidas. Isto significa que o númerototal de bytes lidos é:

número_de_bytes*countA função retorna o número de unidades efetivamente lidas. Este número pode ser menor que countquando o fim do arquivo for encontrado ou ocorrer algum erro.Quando o arquivo for aberto para dados binários, fread pode ler qualquer tipo de dados.

Exemplo:

#include <string.h>



#include <stdio.h>void main()

FILE *fp; char string[20]; fp = fopen("teste.txt", "w+"); if((pf = fopen("arquivo.bin", "wb")) == NULL) printf("Erro na abertura do arquivo"); exit(1); fseek(fp, 0, SEEK_SET); fread(string, strlen(string), 1, fp); fseek(fp, 0, SEEK_SET); printf("%s", mstring); fclose(fp); return 0;

fwrite

A função fwrite() funciona como a sua companheira fread(), porém escrevendo no arquivo. O seuprotótipo é: unsigned fwrite(void *buffer,int número_de_bytes,intcount,FILE *fp);A função retorna o número de itens escritos. Este valor será igual a count a menos que ocorra algum erro.O exemplo abaixo ilustra o uso de fwrite e fread para gravar e posteriormente ler uma variável float numarquivo binário.

#include <stdio.h>int main()FILE *pf;float pi = 3.1415;float pilido;if((pf = fopen("arquivo.bin", "wb")) == NULL) /* Abre arquivo binário para escrita */ printf("Erro na abertura do arquivo"); exit(1);if(fwrite(&pi, sizeof(float), 1,pf) != 1) /* Escreve a variável pi */ printf("Erro na escrita do arquivo");fclose(pf); /* Fecha o arquivo */if((pf = fopen("arquivo.bin", "rb")) == NULL) /* Abre o arquivo novamente para leitura*/ printf("Erro na abertura do arquivo"); exit(1);if(fread(&pilido, sizeof(float), 1,pf) != 1) /* Lê em pilido o valor da variávelarmazenada anteriormente */ printf("Erro na leitura do arquivo");printf("\nO valor de PI, lido do arquivo e': %f", pilido);fclose(pf);return(0);

Note-se o uso do operador sizeof, que retorna o tamanho em bytes da variável ou do tipo de dados.

fseek



Para se fazer consultas e acessos randômicos em arquivos usa-se a função fseek(). Esta move a posiçãocorrente de leitura ou escrita no arquivo de um valor especificado, a partir de um ponto especificado. Oseu protótipo é: int fseek (FILE *fp,long numbytes,int origem);

O parâmetro origem determina a partir de onde os numbytes de movimentação serão contados. Os valorespossíveis são definidos por macros em stdio.h e são:

Nome Valor Significado

SEEK_SET 0 Início do arquivo

SEEK_CUR 1 Ponto corrente no arquivo

SEEK_END 2 Fim do arquivo

Tendo-se definido a partir de onde irá se contar, numbytes determina quantos bytes de deslocamentoserão dados na posição atual.Exemplo:

#include <stdio.h>main() FILE *s; s = fopen("c:\\teste.TXT", "r+"); fprintf(s, "Isto ‚ um teste"); // posiciona-se no segundo caracter do ficheiro a partir do início. fseek(s, 2, SEEK_SET); printf ("\n%c",fgetc(s)); // escreve o caracter “t" no ecrã. fclose(s);

rewind

A função rewind() de protótipo void rewind (FILE *fp);retorna a posição corrente do arquivo para o início.

removeProtótipo: int remove (char *nome_do_arquivo);Apaga um arquivo especificado.



FLUXOS PADRÃO

Os fluxos padrão em arquivos permitem ao programador ler e escrever em arquivos da maneira padrãocom a qual o já se lía e se escrevía no ecrã.

fprintf

A função fprintf() funciona como a função printf(). A diferença é que a saída de fprintf() é um arquivo enão o ecrã do computador. Protótipo: int fprintf (FILE *fp,char *str,...);

A única diferença do protótipo de fprintf() para o de printf() é a especificação do arquivo destino atravésdo ponteiro de arquivo.

fscanf

A função fscanf() funciona como a função scanf(). A diferença é que fscanf() lê de um arquivo e não doteclado do computador. Protótipo: int fscanf (FILE *fp,char *str,...);

A única diferença do protótipo de fscanf() para o de scanf() é a especificação do arquivo destino atravésdo ponteiro de arquivo.

Exemplo:

#include <stdio.h>#include <stdlib.h>int main()

FILE *p;char str[80],c;printf("\n\n Digite um nome para o arquivo:\n");gets(str);if (!(p = fopen(str,"w")))

printf("Erro! Impossivel abrir o arquivo!\n"); exit(1);

fprintf(p,"Este é um arquivo chamado:\n%s\n", str);fclose(p);/* abre novamente para a leitura */p = fopen(str,"r");while (!feof(p))

fscanf(p,"%c",&c); printf("%c",c);

fclose(p);return(0);


ECB- Resolução 4º Teste de TLP126/127

ESTRUTURAS E FICHEIROS

Para ler e escrever tipos de dados maiores que um byte o C permite as funções fread() e fwrite()respectivamente (já abordadas), que permitem a leitura e escrita de blocos de qualquer tipo de dados.

Protótipo :

sizet-t fread (void *buffer, size_t num_bytes, size_t contador, FILE *fp);sizet-t fwrite (void *buffer, size_t num_bytes, size_t contador, FILE *fp);

A função fread devolve o número de blocos lidos, se este for inferior ao contador pode ter sucedido umerro.A função fwrite devolve o número de blocos escritos, se este for inferior ao contador pode ter sucedidoum erro.

Exemplo :#include <stdio.h>struct D

int Dia;int Mes;int Ano;

data [100] ;main()

FILE *f ;f = fopen ( “Teste”, “a+b” ) ;fread ( data, sizeof (struct D), 100 , f) ;data[50]. Dia = 20 ;data[50]. Mes = 7 ;data[50]. Ano = 1970 ;fwrite( data, sizeof ( struct D), 100, f);fclose(f);

No exemplo anterior é necessário definir um array de estruturas. Esta situação traz um grande problema: onúmero de registos a inserir é limitado ao tamanho do array de estruturas.Assim a solução é trabalhar directamente no ficheiro e declarar apenas uma estrutura que permita guardarapenas um registo.


ECB- Resolução 4º Teste de TLP127/127

EXEMPLO DE INSERÇÃO E PESQUISA DIRECTA NUM FICHEIRO

struct Registo

int Cod;char Nome[20];

;............................................................................................................................................void Inserir() FILE *F; struct Registo Reg; // abertura de um ficheiro, se não existir cria-o F=fopen("registo.dat","a+b"); printf("\nInsira o Código ->"); scanf("%d",&Reg.Cod); ................... fwrite(&Reg,sizeof(Reg),1,F); // escreve sempre no final do ficheiro fclose(F);void Consultar_Numero(int num)//numero do registo por ordem de inserção FILE *F; struct Registo Reg; F=fopen("registo.$$$","a+b"); fseek(F, sizeof (Reg) * (num-1) ,SEEK_SET); fread(&Reg,sizeof(Reg),1,F); // Vai buscar ao ficheiro printf("\nCódigo -> %d",Reg.Cod); printf("\nNome -> %s",Reg.Nome); fclose(F);void Consultar_Codigo(int num) FILE *F; int num_reg,encontrou=0; struct Registo Reg; F=fopen("registo.$$$","a+b"); num_reg = 0 ; // começa no 1§ registo while ( (encontrou ==0) && (!feof(F)) )

fseek(F, sizeof (Reg) * num_reg ,SEEK_SET);// x bytes a partir do iniciofread(&Reg,sizeof(Reg),1,F); // Vai buscar ao ficheiroif (Reg.Cod == num )

encontrou = 1 ;num_reg ++;

if (encontrou ) printf("\nCódigo -> %d",Reg.Cod); printf("\nNome -> %s",Reg.Nome); else printf("\nNão encontrou "); fclose(F);

Documents

MANUAL DE C - Clientes Netvisaoclientes.netvisao.pt/paraujob/menu/informatica/c/manualc.pdf · C if e for , por exemplo, só podem ser escritos em minúscula, caso contrário o compilador