linguagem C basico

Prévia do material em texto

curso básico de C
*
Clique para editar o estilo do título mestre
Clique para editar o estilo do subtítulo mestre
*
*
Fundamentos da 
Linguagem C
Prof. Carlos Gonçalves
email: cavg@pop.com.br
DEINF - CCET - UFMA
São Luís, MA
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Menu
TÓPICOS
Pré-Requisitos
Da aprovação
Bibliografia e recursos
Fundamentos de Linguagens
A Linguagem C
Estruturas de Dados Homogêneas
Ponteiros
Anexos
Sobre
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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.)
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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:
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
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Datas das Avaliações
1a. Prova: dd/mmm/2003
2a. Prova: dd/mmm/2003
3a. Prova: dd/mmm/2003
Reposição: dd/mmm/2003
Final: dd/mm/2003!
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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 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.
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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 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.
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Objetivos do Curso
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.
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Sobre as Linguagens de Programação
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.
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
L.P.: Exemplos de Códigos: BASIC
Pseudo-código
leia(num)
para n de 1
 até 10 passo 1 faça
	 tab¬num*n
	 imprima(tab)
	fim-para;
BASIC
10 input num
20 for n=1 to 10
 step 1
30 let tab=num*n
40 print chr$(tab)
50 next n
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
L.P.: Exemplos de Códigos: FORTRAN
Pseudo-código
leia(num)
para n de 1
 até 10 passo 1 faça
	 tab¬num*n
	 imprima(tab)
	fim-para;
FORTRAN 77
 read (num)
 do 10 n=1,10
 tab=num*n
 write(tab)
10 continue 
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
L.P.: Exemplos de Códigos: Assembly
Pseudo-código
leia(num)
para n de 1
 até 10 passo 1 faça
	 tab¬num*n
	 imprima(tab)
	fim-para;
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 
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
L.P.: Exemplos de Códigos: C
Pseudo-código
leia(num)
para n de 1
 até 10 passo 1 faça
	 tab¬num*n
	 imprima(tab)
	fim-para;
C
scanf(&num);
for(n=1;n<=10;n++){
 tab=num*n;
 printf(”\n %d”, tab);
	}; 
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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. 
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. 
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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. 
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. 
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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). 
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
A Linguagem C: Considerações
É 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.
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
A Linguagem C: Características
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 usandoinstruções em Assembly. Por esta razão o C é a linguagem preferida dos programadores de aplicativos. 
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
A Linguagem C: Características
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.
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Linguagem C: Histórico-1/2
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.
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Linguagem C: Histórico-2/2
~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++.
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Estrutura dos programas em 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.
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Exemplo: Um Programa em C-1/3
/* *******************************************************************
Programa: e0101.cpp
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
	float inf, sup; // intervalo que contem a raiz procurada
	
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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
 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
 } while( (sup-inf) > PREC && i < MAX); // enquanto intervalo gde
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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
}; // 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++ 
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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 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 
+ - * / \ = | & ! ? # % ( ) { } [ ] _ ‘ “ . , : < > 
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
C: Normas Gerais (cont.)
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++ 
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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 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.
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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 é 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: 
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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;
};
Note-se que o (;) é um terminador de comandos em C.
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
C: Normas Gerais: Estrutura de Controle: Repetição (while)
Pseudo-linguagem
enquanto condição faça 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).
C
while(condição){ 
 bloco;
};
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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;
};
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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 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.curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
C: Normas Gerais: Estrutura de Controle: Repetição (for)-3/3
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");
}
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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 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++;
}
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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.
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;
}
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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 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. 
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
C: Funções do Usuário: Declaração
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);
	} 
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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 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));}
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
C: Funções do Usuário: Declarada Antes de main()
#include <conio.h>
#include <stdio.h>
float media2(float a, float b){
float med;
 med = (a + b) / 2.0;
 return(med);}
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);}
Função declarada e definida pelo usuário.
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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 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.
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Estruturas de Dados Homogêneas: Vetores
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. 
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Estruturas de Dados Homogêneas: Vetores-(cont.)
Tem-se, então na memória o seguinte arranjo: 
 
 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!
li+1
li
ls
li+2
ls-1
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Estruturas de Dados Homogêneas: Vetores-(cont.)
Exemplo: Vetor de notas de uma turma: 
 notas
 
 
 
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.
1
0
22
2
21
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Vetores: Iniciação - (cont.)
Veja exemplos de declarações e inicializações de vetores a seguir.
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...
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Vetores: Observações
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.
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Matrizes: Conceito e Definição
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.
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Matrizes: Declaração
A sintaxe para declaração de vetores multidimensionais é:
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.
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Matrizes: Exemplo de Declaração
Seja:
	float notas[3][5];
Isto resultará na seguinte estrutura bidimensional na RAM (teoricamente falando):
	 notas
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Matrizes: Iniciação imediata
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
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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:
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!
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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:
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 depoisdo 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. 
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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:
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. 
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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
	... }
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Matrizes: Passagem para as Funções – (cont.)
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.
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Ponteiros: Definição e Conceito
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.
Memória
Endereços
Variável
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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.
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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:
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) 
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Ponteiros: Declaração – (cont.)
Exemplo: Veja as seguintes instruções:
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. 
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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:
o operador de endereço: & 
o operador de conteúdo: * 
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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:
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". 
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Ponteiros: Operador & - Exemplo
Exemplo: Para se atribuir a um ponteiro o endereço de uma variável escreve-se: 
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). 
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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: 
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. 
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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.
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Ponteiros e Vetores 
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]). 
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Ponteiros e Vetores – (cont.)
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. 
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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: 
nome é o nome do vetor de caracteres e,
tam seu tamanho.
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Ponteiros e Strings – (cont.)
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çõescom 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).
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Ponteiros: Sugestões Finais
A fim de complementar as informações contidas nesta apresentação, sugere-se a 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.
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Anexos (hide text)
Anexos
Glossário
Sobre o Autor
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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.
Voltar
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Glossário: Meta-Programas
Programas-tradutores:
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
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Glossário: Sintaxe Estruturada e P. Estruturada
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
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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. 
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Glossário: Objetivos da PE
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. 
Curva de detecção de erros
Número de erros descobertos por unidade de tempo
tempo
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
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 
curso básico de C
*
*©2003 Prof. Carlos Gonçalves 
*
Sobre o autor
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)
emails: cavg@bol.com.br; cavg@pop.com.br;