Sei sulla pagina 1di 77

Fundamentos da

curso básico de C

Linguagem C
Prof. Carlos Gonçalves
email: cavg@pop.com.br
DEINF - CCET - UFMA
São Luís, MA
17/09/2018

1
Menu
TÓPICOS

Pré-Requisitos
curso básico de C

Da aprovação
Bibliografia e recursos
Fundamentos de Linguagens
A Linguagem C
Estruturas de Dados Homogêneas
Ponteiros
Anexos
17/09/2018

Sobre

©2003 Prof. Carlos Gonçalves 2


Requisitos
 Disciplina: Introdução à Computação (60 h)
 Acesso a um computador PC
curso básico de C

 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.)
17/09/2018

©2003 Prof. Carlos Gonçalves 3


Da Aprovação na Disciplina
 Freqüência: Presença em 75% da carga
horária
curso básico de C

 Média igual ou acima de 7,0 nos testes


feitos
 As notas serão assim atribuídas:
 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
17/09/2018

depurando exercícios da lista dada


©2003 Prof. Carlos Gonçalves 4
Datas das Avaliações

 1a. Prova: dd/mmm/2003


curso básico de C

 2a. Prova: dd/mmm/2003


 3a. Prova: dd/mmm/2003
Reposição: dd/mmm/2003
 Final: dd/mm/2003!
17/09/2018

©2003 Prof. Carlos Gonçalves 5


Bibliografia e Recursos: Livros
 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
curso básico de C

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.
17/09/2018

 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
 Sites na Internet
 http://www.deinf.ufma.br/~cav — ou ainda (para acesso
exterior a UFMA) — http://cavg.vila.bol.com.br. Site do
curso básico de C

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.
17/09/2018

©2003 Prof. Carlos Gonçalves 7


Objetivos do Curso
 Conceituar as linguagens de programação.
 Tipos de linguagens: alto e baixo nível,
curso básico de C

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á-
17/09/2018

los e depurá-los.
©2003 Prof. Carlos Gonçalves 8
Sobre as Linguagens de
Programação
 Um programa de computador é um
conjunto de instruções que representam um
curso básico de C

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.
17/09/2018

©2003 Prof. Carlos Gonçalves 9


L.P.: Exemplos de Códigos:
BASIC
Pseudo-código BASIC
leia(num) 10 input num
curso básico de C

para n de 1 20 for n=1 to 10


até 10 passo 1 step 1
faça 30 let tab=num*n
tabnum*n 40 print chr$(tab)
imprima(tab) 50 next n
fim-para;
17/09/2018

©2003 Prof. Carlos Gonçalves 10


L.P.: Exemplos de Códigos:
FORTRAN
Pseudo-código FORTRAN 77
leia(num) read (num)
curso básico de C

para n de 1 do 10 n=1,10
até 10 passo 1 tab=num*n
faça write(tab)
tabnum*n 10 continue
imprima(tab)
fim-para;
17/09/2018

©2003 Prof. Carlos Gonçalves 11


L.P.: Exemplos de Códigos:
Assembly
Pseudo-código Assembly (Intel 8088)
MOV CX,0
leia(num)
curso básico de C

IN AX,PORTA
para n de 1 MOV DX,AX
até 10 passo 1 LABEL:
faça INC CX
MOV AX,DX
tabnum*n
MUL CX
imprima(tab) OUT AX, PORTA
fim-para; CMP CX,10
JNE LABEL
17/09/2018

©2003 Prof. Carlos Gonçalves 12


L.P.: Exemplos de Códigos: C
Pseudo-código C
leia(num) scanf(&num);
curso básico de C

para n de 1 for(n=1;n<=10;n++)
até 10 passo 1 {
faça tab=num*n;
tabnum*n printf(”\n %d”,
imprima(tab) tab);
fim-para; };
17/09/2018

©2003 Prof. Carlos Gonçalves 13


Tipos de Linguagens: Baixo Nível
Baixo-Nível: São linguagens voltadas para a
máquina, isto é, são escritas usando-se as
curso básico de C

instruções do microprocessador do computador.


São genericamente chamadas de linguagens
Assembly ou de montagem.
 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
17/09/2018

são estruturados, tornando a programação bem mais difícil.

©2003 Prof. Carlos Gonçalves 14


Tipos de Linguagens: Alto Nível
Alto-Nível: São linguagens voltadas para o ser
humano. Em geral utilizam sintaxe estruturada
curso básico de C

tornando seu código mais legível. Necessitam de


compiladores ou interpretadores para gerar as
instruções do microprocessador.
 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
17/09/2018

por isso são mais lentas e ocupam mais memória.

©2003 Prof. Carlos Gonçalves 15


Linguagens de A. N. Quanto a
Aplicação

As linguagens de alto nível podem se


distinguir ainda quanto a sua
curso básico de C

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).
17/09/2018

©2003 Prof. Carlos Gonçalves 16


A Linguagem C: Considerações
 É uma linguagem de alto nível, genérica. Foi
desenvolvida por programadores para
curso básico de C

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
17/09/2018

linguagem C++ e Java.

©2003 Prof. Carlos Gonçalves 17


A Linguagem C: Características
 C é uma linguagem de alto nível com uma sintaxe
bastante estruturada e flexível tornando sua
curso básico de C

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.
17/09/2018

©2003 Prof. Carlos Gonçalves 18


A Linguagem C: Características
 C é uma linguagem estruturalmente simples e de
grande portabilidade. O compilador C gera códigos
curso básico de C

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.
17/09/2018

©2003 Prof. Carlos Gonçalves 19


Linguagem C: Histórico-1/2
 1970: Denis Ritchie desenha uma linguagem a
partir do BCPL nos laboratórios da Bell
curso básico de C

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.
17/09/2018

©2003 Prof. Carlos Gonçalves 20


Linguagem C: Histórico-2/2
 ~1990: A Borland International Co, fabricante de
compiladores profissionais escolhe o C e o Pascal
curso básico de C

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++.
17/09/2018

©2003 Prof. Carlos Gonçalves 21


Estrutura dos programas em C
 Um cabeçalho contendo as diretivas
de compilador onde se definem o
curso básico de C

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.
17/09/2018

©2003 Prof. Carlos Gonçalves 22


Exemplo: Um Programa em C-1/3
/* *******************************************************************
Programa: e0101.cpp
curso básico de C

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 // precisao da raiz
void main(){ // inicia programa principal...
float num // numero do qual se quer saber a raiz quadrada
float raiz; // aproximacao para raiz de num
17/09/2018

float inf, sup; // intervalo que contem a raiz procurada


©2003 Prof. Carlos Gonçalves 23
Exemplo: Um Programa em C-2/3
do{ printf("\n\nDigite um numero real positivo: ");
scanf("%f",&num;} while (num <= 1.0); // aceita somente num >1.0
curso básico de C

inf = 0.0; // inicializa intervalo inicial de busca


sup = num; i = 0; // inicializa contador
do{ // faca...
i = i + 1; // incrementa contador
raiz = 0.5 * (inf + sup); // faz estimativa de raiz
if(raiz*raiz > num){ // se chute foi alto...
sup = raiz; // baixa limite superior
}else{ // ...senao...
inf = raiz; }; // sobe limite inferior
17/09/2018

} 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
printf("Raiz: %f +- %f",raiz,PREC); // imprime o valor da raiz
curso básico de C

}; // 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++
17/09/2018

©2003 Prof. Carlos Gonçalves 25


C: Normas Gerais: Conjunto de
Caracteres Válidos
 Um programa-fonte em C é um texto não
formatado escrito em um editor de textos usando
curso básico de C

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
 + - * / \ = | & ! ? # % ( ) { } [ ] _
‘ “ . , : < >
17/09/2018

©2003 Prof. Carlos Gonçalves 26


C: Normas Gerais (cont.)
 Formação de identificadores: Ao contrário de outras
linguagens, C faz distinção na capitalização dos
curso básico de C

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++
17/09/2018

©2003 Prof. Carlos Gonçalves 27


C: Normas Gerais (cont.)
 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
curso básico de C

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
17/09/2018

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.)
 Entrada e saída de dados: existem várias
maneiras de fazer a leitura e escrita de
informações. No exemplo apresentado, printf é
curso básico de C

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:
17/09/2018

©2003 Prof. Carlos Gonçalves 29


C: Normas Gerais: Estruturas de
Controle: Decisão (if-else)
 Pseudo-linguagem  C
se condição então if(condição){
curso básico de C

bloco1 bloco 1;
senão }else{
bloco2 bloco 2;
fim-se; };

 Note-se que o (;) é um


terminador de
comandos em C.
17/09/2018

©2003 Prof. Carlos Gonçalves 30


C: Normas Gerais: Estrutura de
Controle: Repetição (while)
 Pseudo-linguagem  C
enquanto condição while(condição){
curso básico de C

faça bloco bloco;


fim-enquanto; };

 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).
17/09/2018

©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
curso básico de C

bloco
fim-para;

 C
for(inicialização;condição;incremento){
bloco;
};
17/09/2018

©2003 Prof. Carlos Gonçalves 32


C: Normas Gerais: Estrutura de
Controle: Repetição (for)-2/3
 Significado das expressões no laço for:
 inicialização: expressão que inicia a var. de
curso básico de C

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.
17/09/2018

©2003 Prof. Carlos Gonçalves 33


C: Normas Gerais: Estrutura de
Controle: Repetição (for)-3/3
 Exemplo de um laço que imprime inteiros
de 1 a 10:
curso básico de C

int my_int;
for (my_int = 1; my_int <= 10;
my_int++)
{
printf ("%d ", my_int);
printf("\n");
}
17/09/2018

©2003 Prof. Carlos Gonçalves 34


C: Normas Gerais: A flexibilidade
do laço for-1/2
 O construto for do C é altamente versátil,
podendo-se usar inclusive comandos vazios no
curso básico de C

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++;
17/09/2018

©2003 Prof. Carlos Gonçalves 35


C: Normas Gerais: A flexibilidade
do laço for-2/2
 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.
curso básico de C

 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;
}
17/09/2018

©2003 Prof. Carlos Gonçalves 36


C: Funções (ou sub-programas)
 As funções pré-definidas (built-in), são inerentes a
maioria das linguagens e no C temos várias, tais
curso básico de C

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.
17/09/2018

©2003 Prof. Carlos Gonçalves 37


C: Funções do Usuário:
Declaração
 De modo formal, a sintaxe de uma função é a
seguinte:
curso básico de C

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);
}
17/09/2018

©2003 Prof. Carlos Gonçalves 38


C: Funções do Usuário:
Chamada ou Ativação
 Depois de definirmos um função, podemos usá-la
dentro de um programa qualquer. Dizemos que
curso básico de C

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”,
17/09/2018

media2(num1,num2));}

©2003 Prof. Carlos Gonçalves 39


C: Funções do Usuário:
Declarada Antes de main()
#include <conio.h>
#include <stdio.h>
curso básico de C

Função
float media2(float a, float b){ declarada e
float med; definida pelo
med = (a + b) / 2.0; usuário.
return(med);}

void main(){
float num1, num2, med;
puts("Digite dois numeros: ");
scanf("%f %f", &num1, &num2);
med = media2(num1, num2); // chamada a funcao
17/09/2018

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.)
 A localização das funções num código C
podem variar. Existem basicamente duas
curso básico de C

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.
17/09/2018

©2003 Prof. Carlos Gonçalves 41


Estruturas de Dados
Homogêneas: Vetores
 Vetores são coleção de objetos que têm
mesma natureza, i.e., todos seus
curso básico de C

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.
17/09/2018

©2003 Prof. Carlos Gonçalves 42


Estruturas de Dados
Homogêneas: Vetores-(cont.)
 Tem-se, então na memória o seguinte
arranjo:
curso básico de C

...

li 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!
17/09/2018

©2003 Prof. Carlos Gonçalves 43


Estruturas de Dados
Homogêneas: Vetores-(cont.)
 Exemplo: Vetor de notas de uma turma:
notas
curso básico de C

7,0 6,7 7,8 ... 8,0 6,6

0 1 2 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
17/09/2018

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.
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...
17/09/2018

©2003 Prof. Carlos Gonçalves 45


Vetores: Observações
 Na linguagem C, devemos ter cuidado com os
limites de um vetor/matriz. Embora na sua
curso básico de C

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
17/09/2018

logicamente dentro do programa, pelo


programador.
©2003 Prof. Carlos Gonçalves 46
Matrizes: Conceito e Definição
 Matrizes são coleção de objetos que
têm mesma natureza, de forma similar
curso básico de C

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.
17/09/2018

©2003 Prof. Carlos Gonçalves 47


Matrizes: Declaração
 A sintaxe para declaração de vetores
multidimensionais é:
curso básico de C

 tipo nome[tam_1][tam_2]...[tam_N;
onde:
 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.
17/09/2018

©2003 Prof. Carlos Gonçalves 48


Matrizes: Exemplo de Declaração
 Seja:
float notas[3][5];
curso básico de C

 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


17/09/2018

©2003 Prof. Carlos Gonçalves 49


Matrizes: Iniciação imediata
 Seja: float notas[3][5]=
{{8.4,7.4,5.7,5.6,7.7},
curso básico de C

{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 0,2 0,3 0,4
8.4 7.4 5.7 5.6 7.7
1,0 1,1 1,2 1,3 1,4
6.9 2.7 4.9 4.5 8.7
2,0 2,1 2,2 2,3 2,4
17/09/2018

4.5 6.4 8.6 6.9 9.1


©2003 Prof. Carlos Gonçalves 50
Vetores: Passagem para as
Funções
 Sintaxe: Na passagem de vetores para funções
usamos a seguinte sintaxe:
curso básico de C

 nome_da_função(nome_do_vetor)
 onde:
 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!
17/09/2018

©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[]){
curso básico de C

... }
onde:
 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
17/09/2018

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
curso básico de C

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:
 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
17/09/2018

do vetor.

©2003 Prof. Carlos Gonçalves 53


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){
curso básico de C

// 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
17/09/2018

... }
©2003 Prof. Carlos Gonçalves 54
Matrizes: Passagem para as
Funções – (cont.)
 Programa Exemplo: O arquivo
e0706.cpp da apostila contém um
curso básico de C

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.
17/09/2018

©2003 Prof. Carlos Gonçalves 55


Ponteiros: Definição e Conceito
 Ponteiros são Endereços Variável
variáveis que contêm 1000 1003
curso básico de C

endereços. Neste
sentido, estas 1001
variáveis apontam
para algum 1002
determinado endereço
1003
da memória. Em geral,
o ponteiro aponta para 1004
o endereço de alguma
variável já declarada 1005
17/09/2018

no programa. Memória

©2003 Prof. Carlos Gonçalves 56


Ponteiros: Declaração
 Quando declara-se um ponteiro, deve-se declará-lo
com o mesmo tipo (int, char, etc.) do bloco a ser
curso básico de C

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.
17/09/2018

©2003 Prof. Carlos Gonçalves 57


Ponteiros: Declaração – (cont.)
 Sintaxe: A sintaxe da declaração de um ponteiro é
a seguinte:
curso básico de C

tipo_ptr *nome_ptr_1;
ou
tipo_ptr* nome_ptr_1, nome_ptr_2, ...;
 onde:
 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
17/09/2018

regras da seção 2.2.1)

©2003 Prof. Carlos Gonçalves 58


Ponteiros: Declaração – (cont.)
 Exemplo: Veja as seguintes instruções:
 int *p;
curso básico de C

 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
17/09/2018

lista serão declarados como ponteiros.

©2003 Prof. Carlos Gonçalves 59


Ponteiros: Operadores & e *

 Quando trabalhamos com ponteiros,


queremos fazer duas coisas basicamente:
curso básico de C

 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:
 o operador de endereço: &
 o operador de conteúdo: *
17/09/2018

©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
curso básico de C

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:
 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
17/09/2018

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:
curso básico de C

 int *p, val=5; // declaração de ponteiro e


variável
 p = &val; // 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).
17/09/2018

©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
curso básico de C

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:
 int *p = 0x3f8, val; // declaração de
ponteiro e variável
 val = *p; // atribuição
 Obs.: O operador conteúdo (*) somente pode ser
17/09/2018

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
curso básico de C

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.
17/09/2018

©2003 Prof. Carlos Gonçalves 64


Ponteiros e Vetores
 Em C, o nome de um vetor é tratado como o
endereço de seu primeiro elemento. Assim ao se
curso básico de C

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
17/09/2018

do endereço inicial vet[0]).


©2003 Prof. Carlos Gonçalves 65
Ponteiros e Vetores – (cont.)
 Do mesmo modo que se pode acessar o endereço
de cada elemento do vetor por ponteiros, também
curso básico de C

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.
17/09/2018

©2003 Prof. Carlos Gonçalves 66


Ponteiros e Strings
 Em C, uma string é um vetor
unidimensional de elementos caracteres
curso básico de C

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:
 nome é o nome do vetor de caracteres e,
17/09/2018

 tam seu tamanho.

©2003 Prof. Carlos Gonçalves 67


Ponteiros e Strings – (cont.)
 Observe que sendo um vetor, uma string pode ser
declarada também como um ponteiro. Aliás a
curso básico de C

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).
17/09/2018

©2003 Prof. Carlos Gonçalves 68


Ponteiros: Sugestões Finais
 A fim de complementar as informações
contidas nesta apresentação, sugere-se a
curso básico de C

leitura dos tópicos finais da apostila, “8.6-


Alocação Dinâmica de Memória” e “8.7-
Ponteiros 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.
17/09/2018

©2003 Prof. Carlos Gonçalves 69


curso básico de C Anexos (hide text)

Anexos

Glossário
Sobre o Autor
17/09/2018

©2003 Prof. Carlos Gonçalves 70


Glossário: ASCII
 Acrônimo de American Standard Code for
Information Interchange. Um esquema de
curso básico de C

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.
17/09/2018

Voltar
©2003 Prof. Carlos Gonçalves 71
Glossário: Meta-Programas
 Programas-tradutores:
 Interpretadores fazem a interpretação de cada
curso básico de C

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.
17/09/2018

Voltar
©2003 Prof. Carlos Gonçalves 72
Glossário: Sintaxe Estruturada e
P. Estruturada
 Pode-se considerar como precursores da Programação
Estruturada (PE) dois pesquisadores, C. Bohm e G. Jacopini,
curso básico de C

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
17/09/2018

dinâmico”, gerando um baixo nível de semântica.


Voltar
©2003 Prof. Carlos Gonçalves 73
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
curso básico de C

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
17/09/2018

computação.

©2003 Prof. Carlos Gonçalves 74


Glossário: Objetivos da PE
 Os erros duravam para
Curva de
Número de
detecção de
sempre em grandes
erros
sistemas, e.g., numa
curso básico de C

descobertos erros
por unidade de estatística da IBM, um de
tempo
seus engenheiros informou
que “cada nova versão do
OS/360 da IBM possuía mil
erros”.
tempo
 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.
17/09/2018

©2003 Prof. Carlos Gonçalves 75


Glossário: Objetivos da PE
 Melhorar a confiabilidade dos programas
 Aumentar a legibilidade dos programas
curso básico de C

 Minimizar a complexidade
 Simplificar a manutenção
 Aumentar a produtividade do programador
 Estabelecer uma metodologia de
programação
 Reduzir o custo de programação
17/09/2018

©2003 Prof. Carlos Gonçalves 76


Sobre o autor
 Esta apresentação foi
elaborada e desenvolvida
curso básico de C

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)
 emails:
cavg@bol.com.br;
cavg@pop.com.br;
17/09/2018

©2003 Prof. Carlos Gonçalves 77