Escolar Documentos
Profissional Documentos
Cultura Documentos
ATAD IntroducaoC
ATAD IntroducaoC
Introdução à Programação
em
Linguagem C
Indíce
Introdução ........................................................................................................................... 2
I - Programas Simples .......................................................................................................... 3
Programa em C ............................................................................................................... 3
Declaração de variáveis ............................................................................................... 3
Arrays (vetores) ................................................................................................................ 4
Entrada e saída de valores............................................................................................ 5
Ciclo de desenvolvimento de uma aplicação .......................................................... 7
Operações aritméticas .................................................................................................. 7
Exercícios .......................................................................................................................... 8
II - Instruções ......................................................................................................................... 9
Operadores relacionais ou de comparação ............................................................. 9
Operadores lógicos ........................................................................................................ 9
Instrução if ........................................................................................................................ 9
Instrução switch ............................................................................................................... 9
Instrução while ............................................................................................................... 10
Instrução do-while......................................................................................................... 10
Instrução for ................................................................................................................... 10
Instrução break.............................................................................................................. 11
Exercícios ........................................................................................................................ 12
III - Funções e Estruturas .................................................................................................... 13
Funções .......................................................................................................................... 13
Passagem de arrays para funções............................................................................. 14
Estruturas de Dados ...................................................................................................... 15
Acesso a campos de uma estrutura .......................................................................... 15
Definição de tipos – typedef ....................................................................................... 16
Estruturas dentro de estruturas .................................................................................... 17
Passagem de estruturas para funções ...................................................................... 17
Exercícios ........................................................................................................................ 18
IV - Ponteiros ...................................................................................................................... 19
Ponteiros ou apontadores ........................................................................................... 19
Apontadores e Funções............................................................................................... 19
O porquê dos & no scanf() ...................................................................................... 20
Apontadores e arrays ................................................................................................... 20
Apontadores e Estruturas ............................................................................................. 22
Exercícios ........................................................................................................................ 23
1 | 25
Introdução à Programação em Linguagem C
Introdução
Programas simples.
Instruções.
Funções e estruturas.
Ponteiros.
2 | 25
Introdução à Programação em Linguagem C
I - Programas Simples
Programa em C
Na linguagem C existe uma função especial chamada “main” (traduz-se por: principal)
que é o local onde começam todos os programas em C.
main() {
Neste caso a função main não recebe nenhum argumento (não existe nada escrito entre
os parentesis). As chavetas { } agrupam as instruções a executar pela função e como não
escrevemos qualquer instrução o programa começa e termina logo de seguida, como não
utilizamos a instrução return também não retorna nada.
Declaração de variáveis
char (caracter)
int (inteiro)
float (real com precisão simples)
double (real com precisão dupla)
3 | 25
Introdução à Programação em Linguagem C
tipo_da_variável nome_da_variável;
Podemos ter variáveis locais (só existem dentro da função em que são declaradas), e
variáveis globais (visíveis em todas as funções de um programa). Por exemplo, no programa
seguinte podemos ver diversos tipos de inicialização possíveis:
float sum = 0.0;/* declaracao e inicialiacao da variável sum do tipo real com o valor 0
*/
int bignumber = 0, bigsum; /* declaracao das variaveis bignumber e bigsum do tipo
inteiro em que a variavel bignumber é inicializada a 0 */
main()
{
/* Inicio variaveis locais */
Arrays (vetores)
tipo_da_variável nome_da_variável[número_elementos];
4 | 25
Introdução à Programação em Linguagem C
tipo_da_variável nome_da_variável[N][M];
tipo_da_variável nome_da_variável[N1][N2]...[Nm];
Exemplo:
Um vector pode conter elementos de qualquer tipo mas todos os seus elementos têm
de ser do mesmo tipo.
Os índices de um vector variam entre zero e o seu número de elementos – 1.
O índice do primeiro elemento é sempre o zero.
Os vectores quando são criados contêm valores aleatórios (LIXO) nas suas posições
até serem inicializadas.
Exemplo:
char num[4];
num[0] = ܝ2;ܞ
num[1] = ܝ4;ܞ
num[2] = ܝ6;ܞ
num[3] = ܝ8;ܞ
int num[10];
que é equivalente a:
Podemos também definir strings recorrendo a arrays (vectores) . Uma string é uma cadeia
de caracteres, i.e., é um array (vector) de caracteres:
char nome[20]=ܢATAD;ܢ
A variável nome comporta-se como um array (vector) usual. Podemos aceder às letras
de uma cadeia de caracteres acedendo às posições do array (vector) . No exemplo acima
nome[4] guarda o caracter ‘e’ (não esquecer que a primeira posição de um vector é a
zero);
5 | 25
Introdução à Programação em Linguagem C
A linguagem C não possui mecanismos de Input e Output. Para resolver este problema
temos de recorrer a um conjunto de funções que existem em bibliotecas de funções. Isto
implica que temos de adicionar à linguagem um conjunto de outras funcionalidades que,
por defeito, ela não nos proporciona. Para termos acesso a esse conjunto de funções
teremos de incluir a sua definição no nosso programa, para tal escrevemos no início do
programa:
#include <stdio.h>
main()
{
}
Há que ter em atenção que a string especificando a ordem das variáveis ler não
pode conter outros caracteres (por exemplo: \n e \t) que não os caracteres indicadores dos
formatos. Não esquecer também que na lista de variáveis é obrigatório usar o operador &
antes de cada variável (o motivo será explicado na secção quatro: Ponteiros), excepto nas
strings.
Note-se que quando se usa a função scanf() para ler strings a função apenas lê até ao
primeiro espaço, logo se escrevermos uma frase apenas a primeira palavra é guardada na
variável.
gets(nome_variável);
Neste caso é lida a cadeia de caracteres que o utilizador insere até pressionar
return (ie, lê espaços, o que permite guardar numa variável uma frase).
6 | 25
Introdução à Programação em Linguagem C
Notas: As strings em C definem-se entre aspas (" "), os caracteres simples aparecem
entre plicas (' '); o texto normal da string de formatação aparece tal e qual no écran, os
valores das variáveis aparecem nos locais indicados pelo carácter %. É possível formatar a
string utilizado caracteres especiais, tais como:
new line: \n
tab: \t
puts(nome_variável);
Por exemplo:
puts(ܡHello world!;)ܢ
é equivalente a
printf(ܡHello world!\n;)ܢ
Um exemplo:
#include <stdio.h>
main()
{
char ch;
char palavra[10];
char frase[30];
int i ;
float x;
puts(frase);
printf("Os valores das variaveis sao: \n \t %c,\t %d, \t%f, \t%s", ch, i, x,
palavra);
}
Se tivéssemos inserido os valores A, 41, 0.0, olá e Bom dia, o resultado seria:
Bom dia
Os valores das variáveis são:
A, 41, 0.0, ola
7 | 25
Introdução à Programação em Linguagem C
#include <stdio.h>
main()
{
printf("Hello world!");
}
O ficheiro executável é criado a partir do ficheiro objecto e através das bibliotecas que
contêm código já compilado das funções do próprio C e que são necessárias ao executável
final.
Operações aritméticas
8 | 25
Introdução à Programação em Linguagem C
Exercícios
a. Escreva um programa que leia um valor real, representando graus Celsius e escreva o
seu equivalente em Fahrenheit na seguinte forma:
b. Escreva um programa que leia 6 inteiros que representam o valor dos lados de uma
figura geométrica e que escreve o seu perímetro:
9 | 25
Introdução à Programação em Linguagem C
II - Instruções
A linguagem C não possui nenhum tipo que permita representar os valores lógicos
(verdade e falso). Em C o valor lógico falso é representado por 0 (zero). Tudo aquilo que seja
diferente de zero é verdade (Nota: o valor lógico verdade não é apenas o valor 1 mas todos
os que são diferentes de zero).
O operador de teste de igualdade no C é == (não confundir com o operador de
atribuição =), e de desigualdade é o !=.
Os restantes operadores de comparação são os usuais: < (menor), <= (menor ou igual), >
(maior), >= (maior ou igual).
Operadores lógicos
negação (not): !
e (and): &&
ou (or): ||
Instrução if
if (condição)
instrução;
ou
if (condição)
instrução_1;
else
instrução_2;
if(condição_1)
instrução_1;
else if(condição_2)
instrução_2;
else
instrução_3;
10 | 25
Introdução à Programação em Linguagem C
Instrução switch
switch (condição) {
case constante_1:
instrução1;
break;
case constante_2:
instrução2;
break;
...
case constante_n:
instruçãon;
break;
default:
instrução;
}
Os valores que aparecem a seguir à palavra case são valores constantes, não podem ser
expressões nem variáveis. Se a expressão inicial coincidir com algum desses itens executa-se a
instrução que vem logo a seguir. Caso contrário, e se a palavra default estiver presente
(não é obrigatório), passa-se a essa instrução; se não estiver presente passa-se à instrução
que se segue à instrução switch. A palavra break (é uma instrução do C) faz com que se
passe imediatamente à instrução que se segue à presente (a instrução que virá a seguir a
esta instrução switch no programa). Se não estiver presente a execução continua para a
instrução do próximo case.
Instrução while
A instrução while (também chamada ciclo while), executa uma instrução ou bloco de
instruções enquanto uma determinada condição for verdadeira. Adapta-se particularmente
às situações em que o número de iterações não é conhecido à partida. A sua sintaxe é:
while (condição)
{
bloco
}
Instrução do-while
A instrução do-while (também chamada ciclo do- while) difere do ciclo anterior porque
executa o bloco de instruções uma vez antes de avaliar a condição. Continua a executar o
bloco enquanto determinada condição for verdadeira. A sua sintaxe é:
do
{
bloco
} while (condição);
11 | 25
Introdução à Programação em Linguagem C
Instrução for
Exemplo:
int i;
for (i = 0; i <= 10; i++)
{
printf(\ܡnO quadrado do numero %d e %d\nܢ, i, i*i);
}
Instrução break
A instrução break (que é a mesma que é utilizada na instrução switch), quando aplicada
dentro de um ciclo, termina o correspondente ciclo, continuando na instrução
imediatamente a seguir a esse ciclo.
12 | 25
Introdução à Programação em Linguagem C
Exercícios
a. Escreva um programa que leia uma data, verifique se ela é valida e a escreva por
extenso (por exemplo: 01 01 2004 = 1 de Janeiro de 2004). Utilize no programa ambas
as instruções if-else e switch.
b. Escreva dois programas que escrevam no ecrã uma tabela de conversão de graus
Celsius para Fahrenheit. A tabela deve apresentar os graus Celsius de 0 a 40 de 2 em
2.
c. (Nota: º F = º C + 112)
d. Escreva um programa que leia um inteiro n e escreva todos os números primos até n.
13 | 25
Introdução à Programação em Linguagem C
Funções
tipo_retornado nome_da_funcao(argumentos)
{
bloco
}
return resultado;
14 | 25
Introdução à Programação em Linguagem C
Exemplo:
#include <stdio.h>
main()
{
int i , j;
É possível passar arrays como argumentos de funções. No entanto essa passagem tem
um comportamento diferente dos outros tipos de variáveis. Quando se passa qualquer outro
tipo de variável como parâmetro de uma função, é inicialmente criada uma cópia dessa
variável e a função actua sobre essa cópia sem poder modificar a variável original que foi
passada (chama-se a esse mecanismo passagem por valor). Quando se passa um array não
se cria uma cópia; em vez disso é passado o endereço do primeiro elemento do vector de
forma automática e transparente para o utilizador. A consequência dessa forma de
passagem (passagem por referência) é que os elementos do vector que forem modificados
na função mantêm essas modificações, mesmo depois da função terminar.
Para arrays unidimensionais a passagem como parâmetro de uma função pode ser feita
como no exemplo seguinte:
Por exemplo:
15 | 25
Introdução à Programação em Linguagem C
Estruturas de Dados
Até agora todos os dados eram armazenados em variáveis simples, isto é, variáveis dos
tipos char, int, float ou double. Quando queríamos armazenar vários conjuntos de
informação estes tinham de ser todos do mesmo tipo. O exemplo acima mostra como
armazenar números de alunos e as suas respectivas notas de três testes, mas, e se
quiséssemos armazenar também o seu nome? Isto não é possível com arrays dado que o
nome é do tipo char[] e o número e notas são, neste caso, inteiros.
struct [nome_da_estrutura]
{
tipo_1 campo_1, campo_2;
...
tipo_n campo_n;
}
Ficheiro data.h
#include <stdio.h>
struct data
{
int dia;
int mes;
int ano;
}
Ficheiro principal
#include <stdio.h>
#include ܡdata.hܢ
main()
{
struct data datas[100], data_inicio, data_fim;
}
A definição da estrutura Data (struct data) indica apenas que, a partir deste momento,
o compilador passa a conhecer um outro tipo, chamado struct data e que é composto por
dois inteiros e um vector de 10 caracteres.
Para declararmos uma variável do tipo struct data, basta indicar qual o tipo seguido
do nome das variáveis:
Note-se que a variável datas é um vector que contém 100 datas, isto é, cada posição do
vector é do tipo Data.
16 | 25
Introdução à Programação em Linguagem C
O acesso aos campos da estrutura faz-se escrevendo o nome da estrutura seguido de “.”
seguido do nome do campo a que queremos aceder. Por exemplo:
main()
{
struct data datas[100], data_inicio, data_fim;
data_inicio.dia = 1;
data_inicio.ano = 2004;
data_inicio.mes = 1;
printf("\n%d de %d de %d", data_inicio.dia, data_inicio.mes, data_inicio.ano);
datas[0].dia = 2;
datas[0].ano = 2004;
datas[0].mes = 1;
datas[1].dia = 2;
datas[1].ano = 2004;
datas[1].mes = 1;
printf("\n%d de %d de %d", datas[0].dia, datas[0].mes, datas[0].ano);
printf("\n%d de %d de %d", datas[1].dia, datas[1].mes, datas[1].ano);}
A palavra typedef não cria um novo tipo simplesmente permite que usemos o
tipo_existente referindo apenas o seu sinónimo. O uso de typedef não se restringe apenas
às estruturas, pode ser utilizado com qualquer tipo da linguagem:
inteiro i;
/* ou */
int i2;
int ano;
} Data;
Como foi dito, uma estrutura pode conter qualquer tipo da linguagem C. Isto quer dizer
que uma estrutura também pode conter estruturas. Um exemplo seria:
#include <stdio.h>
int mostra(Data data) /* também podia ser: int mostra(struct data data) */
{
printf(ܡ%d de %d de %dܢ, data.dia, data.mes, data.ano);
}
main()
{
Data data = {1,1,2004};
mostra(data);
}
18 | 25
Introdução à Programação em Linguagem C
Exercícios
a. Escreva um programa que leia dois inteiros que representam o valor dos lados de um
rectângulo e que escreve a sua área e perímetro, recorrendo a funções.
c. O maior divisor comum (mdc) de dois inteiros x e y é o maior inteiro que divide tanto x
como y (com resto 0). Escreva uma função int mdc(int x, int y) capaz de calcular o maior
divisor comum de dois inteiros, seguindo a definição acima.
e. Escreva um programa que peça ao utilizador o número, nome e nota de dois testes dos
alunos de uma turma, guarde essa informação numa estrutura, e mostre a pauta com os
seguintes campos: número, nome, nota1, nota2, média.
f. Escreva um programa que leia os valores das coordenadas de dois pontos e que
calcule a distância entre eles.
19 | 25
Introdução à Programação em Linguagem C
IV - Ponteiros
Ponteiros ou apontadores
tipo *nome_apontador;
Quando se declara um apontador ele não aponta para nada. Há que colocar no
apontador um endereço válido, antes de o poder utilizar (o melhor é iniciá-lo logo quando é
criado).
Por exemplo:
*ptr_pi = 3.1415; /* o valor apontado por ptr_pi vai passar a ser 3.1415 */
Há situações onde pode ser necessário declarar um apontador mas não o inicializar,
neste caso colocamo-lo a apontar para NULL.
Apontadores e Funções
Imaginemos que queríamos programar uma função para trocar o valor de duas variáveis.
Uma primeira aproximação seria:
#include <stdio.h>
aux = x;
x = y;
y = aux;
}
20 | 25
Introdução à Programação em Linguagem C
main()
{
int a = 2, b = 5;
troca(a, b);
printf("%d %d", a, b );
}
Quando chamamos uma função passando como argumentos variáveis (neste caso
chamamos a função troca() passando como argumentos as variáveis a e b), procedemos à
cópia dos valores que essas variáveis possuem para as variáveis que são os argumentos da
função (ie, a variável x vai guardar uma cópia do valor de a e a y do valor de b) e a função
vai executar as suas operações sobre as variáveis dos argumentos (as variáveis x e y)
enquanto que as variáveis que foram passadas mantém os seus valores (ou seja, os valores
das variáveis x e y vão ser trocados mas os das varáveis a e b não).
Uma forma de alterar o valor de variáveis dentro das funções é utilizando variáveis globais
(o que é de evitar a todo o custo visto que torna os programas menos genéricos e diminui a
possibilidade de reutilização do código por outro programa pois vai depender de variáveis
que podem não existir. Outra é passando como argumento da função o endereço das
variáveis:
#include <stdio.h>
aux = *x;
*x = *y;
*y = aux;
}
main()
{
int a = 2, b = 5;
troca(&a, &b);
printf("%d %d", a, b);
}
O scanf é uma função que pretende modificar o valor de variáveis (as variáveis passadas
como argumentos vão passar a ser conter os valores que o utilizador introduzir), e a única
forma de o fazer é passando o endereço dessas variáveis.
Apontadores e arrays
int a[10], x;
int *ptr_a;
21 | 25
Introdução à Programação em Linguagem C
ptr_a = &a[0]; /* ptr_a fica a apontar para a[0] - endereço inicial do vector a[] */
É válido escrever:
ptr_a[i] e *(ptr_a + i)
strlen(s) ou strlen(&s[0])
22 | 25
Introdução à Programação em Linguagem C
Apontadores e Estruturas
typedef struct cd
{
char titulo[50];
char grupo[30];
int ano;
} CD;
main()
{
CD *ptr_cd;
CD cd1;
ptr_cd = &cd1;
}
Por exemplo:
ptr_cd->ano = 2002;
23 | 25
Introdução à Programação em Linguagem C
Exercícios
Escreva um programa que utilize uma função para calcular as raízes de uma
equação do segundo grau utilizando a fórmula resolvente.
24 | 25