Fundamentos da Linguagem C

Fundamentos da Linguagem C
Prof. Carlos Gonçalves DEINF - CCET - UFMA São Luís, MA

Menu Pré-Requisitos Da aprovação Bibliografia e recursos
TÓPICOS Pré-Requisitos Da aprovação Bibliografia e recursos Fundamentos de Linguagens A Linguagem C Estruturas de Dados Homogêneas Ponteiros Anexos Sobre ©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.) ©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 ©2003 Prof. Carlos Gonçalves

Datas das Avaliações 1a. Prova: dd/mmm/2003 2a. Prova: dd/mmm/2003
Reposição: dd/mmm/2003 Final: dd/mm/2003! ©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. ©2003 Prof. Carlos Gonçalves

Bibliografia e Recursos: Internet
Sites na Internet — ou ainda (para acesso exterior a UFMA) — Site do Prof. da disciplina, inclui lista de exercícios, apostilas e tutoriais, links, e outras informações atualizadas. 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. 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

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. ©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. ©2003 Prof. Carlos Gonçalves

L.P.: Exemplos de Códigos: BASIC
Pseudo-código leia(num) para n de 1 até 10 passo 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 ©2003 Prof. Carlos Gonçalves

L.P.: Exemplos de Códigos: FORTRAN
Pseudo-código leia(num) para n de 1 até 10 passo 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 ©2003 Prof. Carlos Gonçalves

L.P.: Exemplos de Códigos: Assembly
Pseudo-código leia(num) para n de 1 até 10 passo 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 ©2003 Prof. Carlos Gonçalves

L.P.: Exemplos de Códigos: C
Pseudo-código leia(num) para n de 1 até 10 passo 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); }; ©2003 Prof. Carlos Gonçalves

Tipos de Linguagens: Baixo Nível
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. 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

Tipos de Linguagens: Alto Nível
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. 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

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

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. ©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 usando instruções em Assembly. Por esta razão o C é a linguagem preferida dos programadores de aplicativos. ©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. ©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. ©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++. ©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. ©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 ( ). Ultima Revisao: 16/06/97 ******************************************************************* */ #define MAX // numero maximo de iteracoes #define PREC // 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 ©2003 Prof. Carlos Gonçalves

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 ©2003 Prof. Carlos Gonçalves

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++ ©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 + - * / \ = | & ! ? # % ( ) { } [ ] _ ‘ “ . , : < > ©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++ ©2003 Prof. Carlos Gonçalves

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

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

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. ©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; }; ©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; }; ©2003 Prof. Carlos Gonçalves

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

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++; } ©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; ©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. ©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); ©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));} ©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. ©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. ©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. ©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 li+1 li+2 ls-1 ls ©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. 7,0 6,7 7,8 ... 8,0 6,6 1 2 21 22 ©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... ©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. ©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. ©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. ©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 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

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 0,0 8.4 0,1 7.4 0,2 5.7 0,3 5.6 0,4 7.7 1,0 6.9 1,1 2.7 1,2 4.9 1,3 4.5 1,4 8.7 2,0 2,1 6.4 2,2 8.6 2,3 2,4 9.1 ©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! ©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 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

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. ©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 ... } ©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. ©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. Endereços Variável 1000 1003 1001 1002 1004 1005 Memória ©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. ©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) ©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. ©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: * ©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". ©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). ©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. ©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. ©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]). ©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. ©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. ©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çõ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

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. ©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 ©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 ©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 ©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. 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

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. ©2003 Prof. Carlos Gonçalves

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 ©2003 Prof. Carlos Gonçalves

Fundamentos da Linguagem C

Apresentações semelhantes

Apresentação em tema: "Fundamentos da Linguagem C"— Transcrição da apresentação:

Apresentações semelhantes

Sobre projeto

Feedback

Login

Autorizar-se através da rede social:

Fundamentos da Linguagem C

Apresentações semelhantes

Apresentação em tema: "Fundamentos da Linguagem C"— Transcrição da apresentação:

Apresentações semelhantes

Sobre projeto

Feedback