05/11/2015
curso básico de C
Fundamentos da
Linguagem C
Prof. Carlos Gonçalves
email: [email protected]
DEINF - CCET - UFMA
São Luís, MA
1
Menu
TÓPICOS
Da aprovação
Bibliografia e recursos
Fundamentos de Linguagens
A Linguagem C
Estruturas de Dados Homogêneas
05/11/2015
curso básico de C
Pré-Requisitos
Ponteiros
Anexos
Sobre
©2003 Prof. Carlos Gonçalves
2
Requisitos
Disciplina: Introdução à Computação (60 h)
 Acesso a um computador PC
 Conhecimento de ambiente DOS/Windows
 Compilador C instalado e rodando
 Habilidade no uso de um PC
 Livro sobre C ANSI ou equivalente
 Cópias das Notas de Aulas e dos Textos do
Professor (vd. website do Prof.)
05/11/2015
curso básico de C

©2003 Prof. Carlos Gonçalves
3
Da Aprovação na Disciplina
Freqüência: Presença em 75% da carga
horária
 Média igual ou acima de 7,0 nos testes
feitos
 As notas serão assim atribuídas:




05/11/2015
curso básico de C

1a. Nota = 0,4 · lista + 0,6 · prova
2a. Nota = 0,4 · lista + 0,6 · prova
3a. Nota = 0,5 · lista + 0,5 · prova
Dedicação: mínimo de 2 h/semana
extraclasse no PC programando e
depurando exercícios da lista dada
©2003 Prof. Carlos Gonçalves
4
Datas das Avaliações
Prova: dd/mmm/2003
 2a. Prova: dd/mmm/2003
 3a. Prova: dd/mmm/2003
Reposição: dd/mmm/2003
 Final: dd/mm/2003!
05/11/2015
curso básico de C
 1a.
©2003 Prof. Carlos Gonçalves
5
Bibliografia e Recursos: Livros






05/11/2015
curso básico de C


ARAKAKI, Reginaldo et alii. Fundamentos de programação:
C - técnicas e aplicações. Rio de Janeiro: LTC Editora.
KERNIGHAN, Brian e Ritchie, Dennis. C: A linguagem de
programação-Padrão ANSI. Ed. Campus: Rio de Janeiro.
SCHILDT, Herbert. C - Completo e Total. São Paulo: Makron
Books.
SCHILDT, Herbert. Turbo C - Guia do Usuário. São Paulo:
McGraw-Hill.
GHEZZI, Carlo e Jazayeri, Mehdi. Conceitos de linguagem de
programação. Ed. Campus: Rio de Janeiro.
MARTIN, James & McClure, Clara. Técnicas estruturadas e
CASE. São Paulo: Makron, McGraw-Hill.
YOURDON, Edward. Administrando técnicas estruturadas.
Rio de Janeiro: Campus.
BURGESS, Mark e Hale-Evans, Ron. The GNU C
Programming Tutorial. Free Software Foundation, Inc.
©2003 Prof. Carlos Gonçalves
6
Bibliografia e Recursos: Internet
05/11/2015
curso básico de C

Sites na Internet
 http://www.deinf.ufma.br/~cav — ou ainda (para acesso
exterior a UFMA) — http://cavg.vila.bol.com.br. Site do
Prof. da disciplina, inclui lista de exercícios, apostilas e
tutoriais, links, e outras informações atualizadas.
 http://www.portalc.nip.net. Site repleto de apostilas, textos,
tutoriais, programas-fontes e até compiladores para a
linguagem C e C++. Fundamental uma visita com calma a
fim de explorar bem o material. Possui links para outros
sites.
 http://www.deinf.ufma.br/~cav/c-basico.zip. Link direto
para a apostila de “Fundamentos de C”, citada ao longo
desta apresentação, hospedada em servidor do
DEINF/UFMA.
©2003 Prof. Carlos Gonçalves
7
Objetivos do Curso
05/11/2015
curso básico de C

Conceituar as linguagens de programação.
 Tipos de linguagens: alto e baixo nível,
genéricas e especificas.
 Histórico da criação da linguagem e a
descrição das características mais
importantes da linguagem C.
 Aspecto geral de um código-fonte escrito
em C.
 Elaborar programas-fontes em C com
pequeno grau de complexidade, compilálos e depurá-los.
©2003 Prof. Carlos Gonçalves
8
Sobre as Linguagens de
Programação
05/11/2015
curso básico de C

Um programa de computador é um
conjunto de instruções que representam um
algoritmo para a resolução de algum
problema. Estas instruções são escritas
através de um conjunto de códigos
(símbolos e palavras). Este conjunto de
códigos possui regras de estruturação
lógica e sintática própria. Diz-se que este
conjunto de símbolos e regras formam uma
linguagem de programação.
©2003 Prof. Carlos Gonçalves
9
Pseudo-código
leia(num)
para n de 1
até 10 passo 1
faça
tabnum*n
imprima(tab)
fim-para;
05/11/2015
curso básico de C
L.P.: Exemplos de Códigos:
BASIC
©2003 Prof. Carlos Gonçalves
BASIC
10 input num
20 for n=1 to 10
step 1
30 let tab=num*n
40 print chr$(tab)
50 next n
10
Pseudo-código
leia(num)
para n de 1
até 10 passo 1
faça
tabnum*n
imprima(tab)
fim-para;
05/11/2015
curso básico de C
L.P.: Exemplos de Códigos:
FORTRAN
©2003 Prof. Carlos Gonçalves
FORTRAN 77
read (num)
do 10 n=1,10
tab=num*n
write(tab)
10 continue
11
Pseudo-código
leia(num)
para n de 1
até 10 passo 1
faça
tabnum*n
imprima(tab)
fim-para;
05/11/2015
curso básico de C
L.P.: Exemplos de Códigos:
Assembly
©2003 Prof. Carlos Gonçalves
Assembly (Intel 8088)
MOV CX,0
IN AX,PORTA
MOV DX,AX
LABEL:
INC CX
MOV AX,DX
MUL CX
OUT AX, PORTA
CMP CX,10
JNE LABEL
12
Pseudo-código
leia(num)
para n de 1
até 10 passo 1
faça
tabnum*n
imprima(tab)
fim-para;
05/11/2015
curso básico de C
L.P.: Exemplos de Códigos: C
©2003 Prof. Carlos Gonçalves
C
scanf(&num);
for(n=1;n<=10;n++)
{
tab=num*n;
printf(”\n %d”,
tab);
};
13
Baixo-Nível: São linguagens voltadas para a
máquina, isto é, são escritas usando-se as
instruções do microprocessador do computador.
São genericamente chamadas de linguagens
Assembly ou de montagem.


05/11/2015
curso básico de C
Tipos de Linguagens: Baixo Nível
Vantagens: Os programas são executados com maior
velocidade de processamento e ocupam menor espaço na
memória.
Desvantagens: Em geral, programas em Assembly têm
pouca portabilidade, isto é, um código gerado para um tipo de
processador não serve para outro. Códigos Assembly não
são estruturados, tornando a programação bem mais difícil.
©2003 Prof. Carlos Gonçalves
14
Alto-Nível: São linguagens voltadas para o ser
humano. Em geral utilizam sintaxe estruturada
tornando seu código mais legível. Necessitam de
compiladores ou interpretadores para gerar as
instruções do microprocessador.


05/11/2015
curso básico de C
Tipos de Linguagens: Alto Nível
Vantagens: Por serem compiladas ou interpretadas, têm
maior portabilidade podendo ser executados em várias
plataformas com pouquíssimas modificações. Em geral, a
programação torna-se mais fácil por causa do maior ou
menor grau de estruturação de suas linguagens.
Desvantagens: Em geral, as rotinas geradas (em linguagem
de máquina) são mais genéricas e portanto mais complexas e
por isso são mais lentas e ocupam mais memória.
©2003 Prof. Carlos Gonçalves
15
05/11/2015
curso básico de C
Linguagens de A. N. Quanto a
Aplicação
As linguagens de alto nível podem se
distinguir ainda quanto a sua
aplicação:
 Genéricas: como C, Pascal e Basic;
 Específicas: como Fortran (cálculo
matemático), GPSS (simulação), LISP
(inteligência artificial) ou CLIPPER
(banco de dados).
©2003 Prof. Carlos Gonçalves
16
A Linguagem C: Considerações
05/11/2015
curso básico de C

É uma linguagem de alto nível, genérica. Foi
desenvolvida por programadores para
programadores, tendo como meta características
de flexibilidade e portabilidade. O C é uma
linguagem que nasceu juntamente com o advento
da teoria de linguagem estruturada e do
computador pessoal. Assim, tornou-se rapidamente
uma linguagem “popular” entre os programadores.
O C foi usado para desenvolver o sistema
operacional UNIX, e hoje está sendo usada para
desenvolver novas linguagens, entre elas a
linguagem C++ e Java.
©2003 Prof. Carlos Gonçalves
17
A Linguagem C: Características


05/11/2015
curso básico de C

C é uma linguagem de alto nível com uma sintaxe
bastante estruturada e flexível tornando sua
programação bastante simplificada.
Programas em C são compilados, gerando
programas executáveis.
C compartilha recursos tanto de alto quanto de
baixo nível, pois permite acesso e programação
direta do microprocessador. Com isto, rotinas cuja
dependência do tempo é crítica, podem ser
facilmente implementadas usando instruções em
Assembly. Por esta razão o C é a linguagem
preferida dos programadores de aplicativos.
©2003 Prof. Carlos Gonçalves
18
A Linguagem C: Características

05/11/2015
curso básico de C

C é uma linguagem estruturalmente simples e de
grande portabilidade. O compilador C gera códigos
mais enxutos e velozes do que muitas outras
linguagens.
Embora estruturalmente simples (poucas funções
intrínsecas) o C não perde funcionalidade pois
permite a inclusão de uma farta quantidade de
rotinas do usuário. Os fabricantes de compiladores
fornecem uma ampla variedade de rotinas précompiladas em bibliotecas.
©2003 Prof. Carlos Gonçalves
19
Linguagem C: Histórico-1/2


05/11/2015
curso básico de C

1970: Denis Ritchie desenha uma linguagem a
partir do BCPL nos laboratórios da Bell
Telephones, Inc. Chama a linguagem de B.
1978: Brian Kerningham junta-se a Ritchie para
aprimorar a linguagem. A nova versão chama-se C.
Pelas suas características de portabilidade e
estruturação já se torna popular entre os
programadores.
~1980: A linguagem é padronizada pelo American
National Standard Institute: surge o ANSI C.
©2003 Prof. Carlos Gonçalves
20
Linguagem C: Histórico-2/2

05/11/2015
curso básico de C

~1990: A Borland International Co, fabricante de
compiladores profissionais escolhe o C e o Pascal
como linguagens de trabalho para o seu Integrated
Development Enviroment (Ambiente Integrado de
Desenvolvimento): surge o Turbo Pascal e o
Turbo C para DOS.
~1992: C se torna ponto de concordância entre
teóricos do desenvolvimento da teoria de Object
Oriented Programming (programação orientada a
objetos): surge então o C++.
©2003 Prof. Carlos Gonçalves
21
Estrutura dos programas em C
05/11/2015
curso básico de C
 Um
cabeçalho contendo as diretivas
de compilador onde se definem o
valor de constantes simbólicas,
declaração de variáveis, inclusão de
bibliotecas, declaração de rotinas, etc.
 Um bloco de instruções principal e
outros blocos de rotinas.
 Documentação do programa: são os
comentários.
©2003 Prof. Carlos Gonçalves
22
Exemplo: Um Programa em C-1/3
/* *******************************************************************
Proposito: Calcula a raiz quadrada de um numero real positivo
maior que 1.0 com precisao PREC (0.00001).
Ultima Revisao: 16/06/97
******************************************************************* */
#define MAX 100
// numero maximo de iteracoes
#define PREC 0.000001
void main(){
// precisao da raiz
// inicia programa principal...
float num
05/11/2015
curso básico de C
Programa: e0101.cpp
// numero do qual se quer saber a raiz quadrada
float raiz;
float inf, sup;
©2003 Prof. Carlos Gonçalves
// aproximacao para raiz de num
// intervalo que contem a raiz procurada
23
Exemplo: Um Programa em C-2/3
do{ printf("\n\nDigite um numero real positivo: ");
inf = 0.0;
sup = num;
// inicializa intervalo inicial de busca
i = 0;
// inicializa contador
do{ // faca...
i = i + 1;
// incrementa contador
raiz = 0.5 * (inf + sup); // faz estimativa de raiz
if(raiz*raiz > num){
sup = raiz;
}else{
05/11/2015
curso básico de C
scanf("%f",&num;} while (num <= 1.0); // aceita somente num >1.0
inf = raiz; };
// se chute foi alto...
// baixa limite superior
// ...senao...
// sobe limite inferior
} while( (sup-inf) > PREC && i < MAX); // enquanto intervalo gde
©2003 Prof. Carlos Gonçalves
24
Exemplo: Um Programa em C-3/3
raiz = 0.5 * (inf + sup);
// estima a raiz
// imprime o valor da raiz
}; // fim do programa1
Observações: Note-se que os comentários têm duas apresentações, a
saber:
/* esta e´ uma linha de comentário em C */
// este e´ um comentário valido apenas em C++
05/11/2015
curso básico de C
printf("Raiz: %f +- %f",raiz,PREC);
©2003 Prof. Carlos Gonçalves
25
C: Normas Gerais: Conjunto de
Caracteres Válidos




05/11/2015
curso básico de C

Um programa-fonte em C é um texto não
formatado escrito em um editor de textos usando
um o conjunto padrão de caracteres ASCII. A
seguir estão os caracteres utilizados em C:
a b c d e f g h i j k l m n o p q r s
t u v w x y z
A B C D E F G H I J K L M N O P Q R S
T U V W X Y Z
1 2 3 4 5 6 7 8 9 0
+ - * / \ = | & ! ? # % ( ) { } [ ] _
‘ “ . , : < >
©2003 Prof. Carlos Gonçalves
26
C: Normas Gerais (cont.)



05/11/2015
curso básico de C

Formação de identificadores: Ao contrário de outras
linguagens, C faz distinção na capitalização dos
identificadores de variáveis usados em um programa, i.e., os
identificadores soma, Soma e SOMA são distintos para o
compilador C.
Comentários: podem ser escritos em qualquer lugar do
texto para facilitar a interpretação do algoritmo. Para que o
comentário seja identificado como tal, ele deve ter um /*
antes e um */ depois.
Exemplo: /* esta e´ uma linha de comentário em
C */
// este e´ um comentário valido apenas em C++
©2003 Prof. Carlos Gonçalves
27
C: Normas Gerais (cont.)



05/11/2015
curso básico de C

Diretivas de Compilação : são comandos que são
processados durante a compilação do programa. Estes
comandos são genericamente chamados de diretivas de
compilação e informam ao compilador C quais são as
constantes simbólicas usadas no programa e quais
bibliotecas devem ser anexadas ao programa executável.
A diretiva #include diz ao compilador para incluir na
compilação do programa outros arquivos. Geralmente estes
arquivos contem bibliotecas de funções ou rotinas do usuário.
A diretiva #define diz ao compilador quais são as
constantes simbólicas usadas no programa.
Declaração de variáveis: as variáveis devem ser declaradas
no inicio do programa. Estas variáveis podem ser de vários
tipos: char (literal/string), int (inteiro), float (real de
simples precisão) e outras que serão vistas ainda no cap.02
da apostila.
©2003 Prof. Carlos Gonçalves
28
C: Normas Gerais (cont.)

05/11/2015
curso básico de C

Entrada e saída de dados: existem várias
maneiras de fazer a leitura e escrita de
informações. No exemplo apresentado, printf é
uma função de escrita na tela e scanf é uma
função de leitura de teclado.
Estruturas de controle: A linguagem C permite
uma ampla variedade de estruturas de controle de
fluxo de processamento. Estas estruturas serão
vistas em detalhes nos capítulos 4 e 5 da apostila
no website. Duas estruturas básicas (decisão e
repetição) são muito semelhantes às estruturas
usadas nas pseudo-linguagens algorítmicas:
©2003 Prof. Carlos Gonçalves
29
C: Normas Gerais: Estruturas de
Controle: Decisão (if-else)
Pseudo-linguagem
se condição então
bloco1
senão
bloco2
fim-se;

C
if(condição){
bloco 1;
}else{
bloco 2;
};

05/11/2015
curso básico de C

©2003 Prof. Carlos Gonçalves
Note-se que o (;) é um
terminador de
comandos em C.
30
C: Normas Gerais: Estrutura de
Controle: Repetição (while)
Pseudo-linguagem
enquanto condição
faça bloco
fim-enquanto;

05/11/2015
curso básico de C


C
while(condição){
bloco;
};
Note-se que enquanto
condição for true (ou
1, ou não zero) o laço
será feito, só findando
quando condição for
false (ou zero).
©2003 Prof. Carlos Gonçalves
31
C: Normas Gerais: Estrutura de
Controle: Repetição (for)-1/3
Pseudo-linguagem
para var=vi até vf passo p faça
bloco
fim-para;

C
for(inicialização;condição;incremento){
bloco;
};
05/11/2015
curso básico de C

©2003 Prof. Carlos Gonçalves
32
C: Normas Gerais: Estrutura de
Controle: Repetição (for)-2/3



05/11/2015
curso básico de C

Significado das expressões no laço for:
inicialização: expressão que inicia a var. de
controle ou a var. testada em condição, e.g.
index=1.
condição: é avaliada no começo de cada ciclo e
o laço só é executado se expressão é true,
e.g., index<=20.
incremento: esta expr. é usada para alterar o
valor da var. de controle. Em C ela pode ser
qualquer coisa. Exemplos: index++, index
*= 20, ou index /= 2.3.
©2003 Prof. Carlos Gonçalves
33
C: Normas Gerais: Estrutura de
Controle: Repetição (for)-3/3
05/11/2015
curso básico de C

Exemplo de um laço que imprime inteiros
de 1 a 10:
int my_int;
for (my_int = 1; my_int <= 10;
my_int++)
{
printf ("%d ", my_int);
printf("\n");
}
©2003 Prof. Carlos Gonçalves
34
C: Normas Gerais: A flexibilidade
do laço for-1/2

05/11/2015
curso básico de C

O construto for do C é altamente versátil,
podendo-se usar inclusive comandos vazios no
cabeçalho. Por exemplo, a omissão das partes
inicialização e incremento, cria
essencialmente um laço while.
Exemplo:
int my_int = 1;
for ( ; my_int <= 20; )
{
printf ("%d ", my_int);
my_int++;
}
©2003 Prof. Carlos Gonçalves
35
C: Normas Gerais: A flexibilidade
do laço for-2/2

05/11/2015
curso básico de C

Pode-se combinar vários comandos nas partes da
inicialização e do incremento do laço for, usando-se
para isto o operador vírgula (,), o que produz um laço peculiar.
Exemplo:
#include <stdio.h>
int main(){
int up, down;
for (up = 0, down=10; up < down; up++, down--)
{
printf("up = %d, down= %d\n",up,down);
}
return 0;
}
©2003 Prof. Carlos Gonçalves
36

As funções pré-definidas (built-in), são inerentes a
maioria das linguagens e no C temos várias, tais
como sqrt(), toupper(), getch() ou
putchar().

Estas funções já são providenciadas pelas
bibliotecas-padrão do C e são inseridas pelo
compilador quando e onde necessárias.
As funções do usuário permitem ao programador
separar o código por seu propósito e torna esta
seção do código reusável, i.e., permite que esta
seção possa ser chamada em diferentes contextos.

05/11/2015
curso básico de C
C: Funções (ou sub-programas)
©2003 Prof. Carlos Gonçalves
37
C: Funções do Usuário:
Declaração
05/11/2015
curso básico de C

De modo formal, a sintaxe de uma função é a
seguinte:
tipo_de_retorno
nome_da_função(tipo1
arg1,
tipo2 arg2, ...){
[bloco de instruções da função]
return(valor_retorno);
}
Exemplo de uma função:
float media2(float a, float b){ // função
float med;
med = (a + b) / 2.0;
return(med);
}
©2003 Prof. Carlos Gonçalves
38
C: Funções do Usuário:
Chamada ou Ativação

05/11/2015
curso básico de C

Depois de definirmos um função, podemos usá-la
dentro de um programa qualquer. Dizemos que
estamos fazendo uma chamada ou ativação da
função.
Exemplo: No exemplo abaixo chamamos a função
media2() dentro do programa principal:
void main(){
float num1, num2, med;
puts(”Digite dois números:”);
scanf(”%f %f”, &num1, &num2);
printf(”\nA media dos numeros e´ %f”,
media2(num1,num2));}
©2003 Prof. Carlos Gonçalves
39
C: Funções do Usuário:
Declarada Antes de main()
float media2(float a, float b){
float med;
med = (a + b) / 2.0;
return(med);}
05/11/2015
curso básico de C
#include <conio.h>
#include <stdio.h>
Função
declarada e
definida pelo
usuário.
void main(){
float num1, num2, med;
puts("Digite dois numeros: ");
scanf("%f %f", &num1, &num2);
med = media2(num1, num2);
// chamada a funcao
printf("\nA media destes numeros eh %f",med);}
©2003 Prof. Carlos Gonçalves
40
C: Funções do Usuário:
Declarada Antes de main()-(cont.)
05/11/2015
curso básico de C

A localização das funções num código C
podem variar. Existem basicamente duas
posições possíveis para escrevermos o
corpo de uma função: antes ou depois do
programa principal. Podemos ainda
escrever uma função no mesmo arquivo
do programa principal ou em um arquivo
separado. Para maiores detalhes veja
cap.06 da apostila “Fundamentos de C”,
presente no site do Prof.
©2003 Prof. Carlos Gonçalves
41
Estruturas de Dados
Homogêneas: Vetores
05/11/2015
curso básico de C

Vetores são coleção de objetos que têm
mesma natureza, i.e., todos seus
elementos possuem um mesmo tipo básico.
De fato, um vetor pode ser visto
conceitualmente como sendo equivalente a
uma matriz de dimensão 1 x m, onde m.
São chamados ainda de array, em inglês.
 Os elementos de um vetor são identificados
pelo nome seguido de índice entre
colchetes.
©2003 Prof. Carlos Gonçalves
42
Estruturas de Dados
Homogêneas: Vetores-(cont.)
Tem-se, então na memória o seguinte
arranjo:
...
li
05/11/2015
curso básico de C

li+1
li+2
ls-1
ls
li = limite inferior = 0, ls= limite superior,
O número de elementos num vetor em C é
dado por ls+1, pois o primeiro índice é
sempre 0!
©2003 Prof. Carlos Gonçalves
43
Estruturas de Dados
Homogêneas: Vetores-(cont.)
05/11/2015
curso básico de C

Exemplo: Vetor de notas de uma turma:
notas
7,0
6,7
7,8
0
1
2
...
8,0
6,6
21
22
A sintaxe para a declaração de um vetor é a seguinte:
tipo nome[tam];
Exemplo: float notas[22];
 Obs.: Como exercício, implementar em C, o
algoritmo de “classificação da bolha” visto na
transparência do Prof.
©2003 Prof. Carlos Gonçalves
44
Vetores: Iniciação - (cont.)
Veja exemplos de declarações e
inicializações de vetores a seguir.




05/11/2015
curso básico de C

int dia[7] = {12,30,14,7,13,15,6};
float notas[5] =
{8.4,6.9,4.5,4.6,7.2};
char vogal[5] = {'a’, ‘e’, ‘i’, ‘o’,
‘u'};
Programa Exemplo: O arquivo e0701.cpp
da apostila contém um programa que
mostra o uso de vetores: declaração,
iniciação, leitura e escrita de elementos...
©2003 Prof. Carlos Gonçalves
45
Vetores: Observações

05/11/2015
curso básico de C

Na linguagem C, devemos ter cuidado com os
limites de um vetor/matriz. Embora na sua
declaração, tenhamos definido o tamanho de um
vetor/matriz, o C não faz nenhum teste de
verificação de acesso a um elemento dentro do
vetor/matriz.
Por exemplo se declaramos um vetor/matriz como
int valor[5], teoricamente só tem sentido
usarmos os elementos valor[0], ...,
valor[4]. Porém, o C não acusa erro se
usarmos valor[12] em algum lugar do
programa. Estes testes de limites devem ser feitos
logicamente dentro do programa, pelo
programador.
©2003 Prof. Carlos Gonçalves
46
Matrizes: Conceito e Definição
05/11/2015
curso básico de C
 Matrizes
são coleção de objetos que
têm mesma natureza, de forma similar
aos vetores. De fato, uma matriz pode
ser vista conceitualmente como sendo
equivalente a uma matriz
multidimensional, semelhante ao que
ocorre na matemática. Mais ainda,
pode-se ver uma matriz como uma
coleção de vetores, i.e. um vetor de
vetores.
©2003 Prof. Carlos Gonçalves
47
Matrizes: Declaração
A sintaxe para declaração de vetores
multidimensionais é:

tipo nome[tam_1][tam_2]...[tam_N;
onde:




05/11/2015
curso básico de C

tipo é o tipo dos elementos do vetor.
nome é o nome (identificador) do vetor.
[tam_1][tam_2]...[tam_N] é o tamanho de cada
dimensão do vetor.
Os índices dos vetores multidimensionais, também
começam em 0. Por exemplo: vet[0][0], é o
primeiro elemento do vetor.
©2003 Prof. Carlos Gonçalves
48
05/11/2015
curso básico de C
Matrizes: Exemplo de Declaração

Seja:
float notas[3][5];

Isto resultará na seguinte estrutura bidimensional
na RAM (teoricamente falando):
notas
0,0
0,1
0,2
0,3
0,4
1,0
1,1
1,2
1,3
1,4
2,0
2,1
2,2
2,3
2,4
©2003 Prof. Carlos Gonçalves
49

Seja: float notas[3][5]=
{{8.4,7.4,5.7,5.6,7.7},
{6.9,2.7,4.9,4.5,8.7},
{4.5,6.4,8.6,6.9,9.1}};

Isto resultará na seguinte estrutura bidimensional:
notas
0,0
0,1
8.4
1,0
0,2
7.4
1,1
6.9
05/11/2015
curso básico de C
Matrizes: Iniciação imediata
2,0
5.7
1,2
2.7
2,1
4.5
©2003 Prof. Carlos Gonçalves
0,3
5.6
1,3
4.9
2,2
6.4
0,4
1,4
4.5
2,3
8.6
7.7
8.7
2,4
6.9
9.1
50
Vetores: Passagem para as
Funções
Sintaxe: Na passagem de vetores para funções
usamos a seguinte sintaxe:



nome_da_função(nome_do_vetor)
onde:

05/11/2015
curso básico de C

nome_da_função é o nome da função que se está
chamando.
nome_do_vetor é o nome do vetor que
queremos passar. Indicamos apenas o nome do
vetor, sem índices!
©2003 Prof. Carlos Gonçalves
51
Vetores: Passagem para as
Funções – (cont.)

Sintaxe: Na declaração de funções que recebem vetores:
tipo_função nome_função(tipo_vetor
nome_vetor[]){
... }
onde:





05/11/2015
curso básico de C

tipo_função é o tipo de retorno da função.
nome_função é o nome da função.
tipo_vetor é o tipo de elementos do vetor.
nome_vetor é o nome do vetor. Observe que depois do nome
do vetor temos um índice vazio [] para indicar que estamos
recebendo um vetor.
Programa Exemplo: O arquivo e0704.cpp na apostila
contém um programa que mostra a passagem de vetores
para funções.
©2003 Prof. Carlos Gonçalves
52
Matrizes: Passagem para as
Funções

A sintaxe para passagem de vetores
multidimensionais para funções é semelhante a
passagem de vetores unidimensionais: chamamos
a função e passamos o nome do vetor, sem
índices. A única mudança ocorre na declaração de
funções que recebem vetores:
Sintaxe: Na declaração de funções que recebem
vetores:


05/11/2015
curso básico de C

tipo_f função(tipo_v
vetor[tam_1][tam_2]...[tam_n]){...}
Observe que depois do nome do vetor temos os
índices contendo os tamanhos de cada dimensão
do vetor.
©2003 Prof. Carlos Gonçalves
53
05/11/2015
curso básico de C
Matrizes: Passagem para as
Funções – (cont.)

Exemplo: Observe a declaração da função:
int max(int vetor[5][7],int N, int M){
// declaração da função
...}

E a chamada da função:
void main(){
int valor[5][7]; //declaração do vetor
...
med = media(valor, n); //passagem do
vetor para a função
... }
©2003 Prof. Carlos Gonçalves
54
Matrizes: Passagem para as
Funções – (cont.)
05/11/2015
curso básico de C

Programa Exemplo: O arquivo
e0706.cpp da apostila contém um
programa que mostra a manipulação de
vetores bidimensionais: leitura de
elementos, escrita, passagem para
funções, etc. Assim como os demais
exemplos deve ser estudado e assimilado
em sua integridade.
©2003 Prof. Carlos Gonçalves
55
Ponteiros: Definição e Conceito
05/11/2015
curso básico de C

Ponteiros são
variáveis que contêm
endereços. Neste
sentido, estas
variáveis apontam
para algum
determinado endereço
da memória. Em geral,
o ponteiro aponta para
o endereço de alguma
variável já declarada
no programa.
©2003 Prof. Carlos Gonçalves
Endereços
1000
Variável
1003
1001
1002
1003
1004
1005
Memória
56
05/11/2015
curso básico de C
Ponteiros: Declaração

Quando declara-se um ponteiro, deve-se declará-lo
com o mesmo tipo (int, char, etc.) do bloco a ser
apontado. Por exemplo, se queremos que um
ponteiro aponte para uma variável int (bloco de 2
bytes) devemos declará-lo como int também.

Cada informação é representada por um certo
conjunto de bytes (Ver capítulo 2). Por exemplo:
caracter (char): 1 byte, inteiro (int): 2 bytes, etc.

Cada um destes conjuntos de bytes, que
chamaremos de bloco, tem um nome e um
endereço de localização especifica na memória.
©2003 Prof. Carlos Gonçalves
57
Ponteiros: Declaração – (cont.)
Sintaxe: A sintaxe da declaração de um ponteiro é
a seguinte:
tipo_ptr *nome_ptr_1;
ou
tipo_ptr* nome_ptr_1, nome_ptr_2, ...;
 onde:



05/11/2015
curso básico de C

tipo_ptr : é o tipo de bloco para o qual o ponteiro
apontará.
* : é um operador que indica que nome_ptr é um
ponteiro.
nome_ptr_1, nome_ptr_2,...: são os nomes dos
ponteiros (os nomes dos ponteiros obedecem as mesmas
regras da seção 2.2.1)
©2003 Prof. Carlos Gonçalves
58
Ponteiros: Declaração – (cont.)

Exemplo: Veja as seguintes instruções:



05/11/2015
curso básico de C

int *p;
float* s_1, s_2;
A primeira instrução declara um ponteiro chamado
p que aponta para um inteiro. Este ponteiro aponta
para o primeiro endereço de um bloco de dois
bytes. Sempre é necessário declarar o tipo do
ponteiro. Neste caso dizemos que declaramos um
ponteiro tipo int.
A segunda instrução declara dois ponteiros (s_1 e
s_2) do tipo float. Observe que o * está
justaposto ao tipo: assim todos os elementos da
lista serão declarados como ponteiros.
©2003 Prof. Carlos Gonçalves
59
Ponteiros: Operadores & e *
Quando trabalhamos com ponteiros,
queremos fazer duas coisas basicamente:



conhecer endereço de uma variável;
conhecer o conteúdo de um endereço.
Para realizar estas tarefas a linguagem C
nos providencia dois operadores especiais:


05/11/2015
curso básico de C

o operador de endereço: &
o operador de conteúdo: *
©2003 Prof. Carlos Gonçalves
60
Ponteiros: Operador &

O operador de endereço (&) determina o endereço
de uma variável (o primeiro byte do bloco ocupado
pela variável). Por exemplo, &val determina o
endereço do bloco ocupado pela variável val. Esta
informação não é totalmente nova pois já a
usamos antes: na função scanf()!
Exemplo: Quando escreve-se a instrução:


05/11/2015
curso básico de C

scanf("%d", &num);
estamos nos referimos ao endereço do bloco
ocupado pela variável num. A instrução significa:
"leia o buffer do teclado, transforme o valor lido em
um valor inteiro (2 bytes) e o armazene no bloco
localizado no endereço da variável num".
©2003 Prof. Carlos Gonçalves
61
Ponteiros: Operador & - Exemplo
Exemplo: Para se atribuir a um ponteiro o
endereço de uma variável escreve-se:




05/11/2015
curso básico de C

int *p, val=5;
variável
p = &val;
// declaração de ponteiro e
// atribuição
Observe que o ponteiro p deve ser declarado
anteriormente com o mesmo tipo da variável para a
qual ele deve apontar.
Obs.: O operador endereço (&) somente pode ser
usado em uma única variável. Não pode ser usado
em expressões como, por exemplo, &(a+b).
©2003 Prof. Carlos Gonçalves
62
Ponteiros: Operador * - Exemplo

O operador conteúdo (*) determina o conteúdo
(valor) do dado armazenado no endereço de um
bloco apontado por um ponteiro. Por exemplo, *p
determina conteúdo do bloco apontado pelo
ponteiro p. De forma resumida: o operador (*)
determina o conteúdo de um endereço.
Exemplo: Para se atribuir a uma variável o
conteúdo de um endereço escreve-se:



05/11/2015
curso básico de C

int *p = 0x3f8, val;
// declaração de
ponteiro e variável
val = *p;
// atribuição
Obs.: O operador conteúdo (*) somente pode ser
usado em variáveis ponteiros.
©2003 Prof. Carlos Gonçalves
63
Ponteiros: Operadores & e *Dicas
Programa Exemplo: O arquivo
e0802.cpp contém um programa que
mostra como se manipulam ponteiros e
variáveis. Ainda, como se transportam
informações entre ponteiros e variáveis.
 É elucidativo ler os tópicos “8.3-Operações
elementares ponteiros” e “8.4-Ponteiros,
endereços e funções “ da apostila, a fim de
familiarizar-se com os ponteiros.
05/11/2015
curso básico de C

©2003 Prof. Carlos Gonçalves
64
Ponteiros e Vetores

05/11/2015
curso básico de C

Em C, o nome de um vetor é tratado como o
endereço de seu primeiro elemento. Assim ao se
passar o nome de um vetor para uma função está
se passando o endereço do primeiro elemento de
um conjunto de endereços de memória.
Por exemplo, se vet é um vetor, então vet e
&vet[0] representam o mesmo endereço. E
mais, podemos acessar o endereço de qualquer
elemento do vetor do seguinte modo: &vet[i] e
equivalente a (vet + i). Aqui deve-se ressaltar
que (vet + i) não representa uma adição
aritmética normal mas o endereço do i-ésimo
elemento do vetor vet (endereço contado a partir
do endereço inicial vet[0]).
©2003 Prof. Carlos Gonçalves
65
Ponteiros e Vetores – (cont.)

05/11/2015
curso básico de C

Do mesmo modo que se pode acessar o endereço
de cada elemento do vetor por ponteiros, também
se pode acessar o valor de cada elemento usando
ponteiros. Assim vet[i] é equivalente a *(vet +
i). Aqui se usa o operador conteúdo (*) aplicado
ao endereço do i-ésimo elemento do vetor vet.
Programa Exemplo: O arquivo e0807.cpp
contém um programa que mostra a equivalência
entre ponteiros e vetores.
©2003 Prof. Carlos Gonçalves
66
Ponteiros e Strings
Em C, uma string é um vetor
unidimensional de elementos caracteres
ASCII, sendo o ultimo destes elementos o
caracter especial ’\0’.
 Sintaxe: As duas maneiras mais comuns
de declararmos uma string são:



char nome[tam]; ou,
char *nome;
onde:

05/11/2015
curso básico de C


nome é o nome do vetor de caracteres e,
tam seu tamanho.
©2003 Prof. Carlos Gonçalves
67
Ponteiros e Strings – (cont.)

05/11/2015
curso básico de C

Observe que sendo um vetor, uma string pode ser
declarada também como um ponteiro. Aliás a
segunda declaração representa justamente isto.
Sabendo isto podemos realizar uma grande
variedade de manipulações com strings e
caracteres. Existe uma biblioteca padrão C
chamada string.h que providencia algumas
funções de manipulação de strings muito úteis.
Programa Exemplo: O arquivo e0808.cpp
contém um programa que mostra algumas
operações usando-se strings (vetores e ponteiros).
©2003 Prof. Carlos Gonçalves
68
Ponteiros: Sugestões Finais
05/11/2015
curso básico de C

A fim de complementar as informações
contidas nesta apresentação, sugere-se a
leitura dos tópicos finais da apostila, “8.6Alocação Dinâmica de Memória” e “8.7Ponteiros para Funções “.
 É necessário sedimentar os conhecimentos
adquiridos, pondo-os em prática num
computador, ao elaborar-se programas para
os exercícios da lista dada (vd. site) e
estudando os programas-exemplos dados
na apostila.
©2003 Prof. Carlos Gonçalves
69
Anexos
Glossário
Sobre o Autor
05/11/2015
curso básico de C
Anexos (hide text)
©2003 Prof. Carlos Gonçalves
70
Glossário: ASCII
Acrônimo de American Standard Code for
Information Interchange. Um esquema de
codificação que atribui valores numéricos
às letras, números sinais de pontuação e
alguns símbolos especiais.
 O ASCII tem 256 códigos divididos em dois
conjuntos: básico e estendido com 128
códigos cada.
 O ASCII permite que computadores e
programas troquem informações entre si.
05/11/2015
curso básico de C

Voltar
©2003 Prof. Carlos Gonçalves
71
Glossário: Meta-Programas
Programas-tradutores:


05/11/2015
curso básico de C

Interpretadores fazem a interpretação de cada
instrução do programa fonte executando-a
dentro de um ambiente de programação: Basic
e AutoLISP são exemplos.
Compiladores fazem a tradução de todas as
instruções do programa fonte gerando um
programa executável. Estes programas
executáveis (*.exe, *.bin) podem ser
executados fora dos ambientes de
programação: C e Pascal são exemplos.
Voltar
©2003 Prof. Carlos Gonçalves
72
Glossário: Sintaxe Estruturada e
P. Estruturada

05/11/2015
curso básico de C

Pode-se considerar como precursores da Programação
Estruturada (PE) dois pesquisadores, C. Bohm e G. Jacopini,
que publicaram um paper, primeiro na Itália e depois na
Communications of the ACM, USA, demonstrando que
qualquer programa poderia ser construído usando-se apenas
3 estruturas básicas: seqüência, seleção e iteração.
A expressão “programação estruturada” foi usada pela 1ª vez
em 1969 por Edsger Dijkstra no paper “Structured
programming”, in Software Engineering 1969, Bruxelas:
NATO Scientific Affairs Division. O comando GOTO favorecia
a desorganização dos programas, além de obscurecer sua
estrutura, já que aumentava a “distância entre a
representação estática do programa e seu processo
dinâmico”, gerando um baixo nível de semântica.
Voltar
©2003 Prof. Carlos Gonçalves
73






05/11/2015
curso básico de C
Glossário: Objetivos da PE
Resolver a crise de software, proporcionando uma disciplina
de programação, pois:
Os programas até então eram feitos ad hoc, dificultando seu
uso em vários sistemas de computadores.
Os programas até então eram feitos ad hoc, dificultando seu
uso em vários sistemas de computadores.
Os programas até então eram feitos ad hoc, dificultando seu
uso em vários sistemas de computadores.
Produção de software era onerosa.
Os testes de programas ocupavam cerca de 50% do projeto
de software.
Os erros são mais críticos nos sistemas atuais, pois o usuário
a partir da década de 70, tornou-se menos tolerante a
software com falhas, o que não occorria no início da era da
computação.
©2003 Prof. Carlos Gonçalves
74
Glossário: Objetivos da PE
Número de
erros
descobertos
por unidade de
tempo
Curva de
detecção de
erros
tempo
05/11/2015
curso básico de C

©2003 Prof. Carlos Gonçalves

Os erros duravam para
sempre em grandes
sistemas, e.g., numa
estatística da IBM, um de
seus engenheiros informou
que “cada nova versão do
OS/360 da IBM possuía mil
erros”.
A manutenção tornou-se
muito cara, pois cerca de
50%, ou mais, do
orçamento das
organizações iam para
manutenção dos sistemas
existentes.
75
Glossário: Objetivos da PE
Melhorar a confiabilidade dos programas
 Aumentar a legibilidade dos programas
 Minimizar a complexidade
 Simplificar a manutenção
 Aumentar a produtividade do programador
 Estabelecer uma metodologia de
programação
 Reduzir o custo de programação
05/11/2015
curso básico de C

©2003 Prof. Carlos Gonçalves
76

Esta apresentação foi
elaborada e desenvolvida
pelo Prof. Carlos
Gonçalves (DEINF/UFMA),
a quem pertence todos os
direitos autorais.

Webpage:
www.deinf.ufma.br/~cav;
http://cavg.vila.bol.com.br;
(mirror)

05/11/2015
curso básico de C
Sobre o autor
emails:
[email protected];
[email protected];
©2003 Prof. Carlos Gonçalves
77