Introdução a Linguagem C

Estrutura de Dados
Prof. Gustavo Willam Pereira
Créditos:
Profa. Juliana Pinheiro Campos
ESTRUTURAS DE DADOS
Ementa
Introdução à Linguagem C.
Recursividade.
Alocação dinâmica de memória.
Conceito de tipos abstratos de dados.
Listas
Pilhas
Filas
Árvores.
Implementação de tipos abstratos de dados.
CONCEITOS BÁSICOS
Estruturas de dados:
Forma particular de armazenamento e
organização dos dados em um computador de
modo que possam ser recuperados e usados
posteriormente de forma eficiente.
Alguns tipos de estruturas são adequadas a
diferentes tipos de aplicação, destinando-se a
tarefas específicas.
CONCEITOS BÁSICOS
Estruturas de dados e algoritmos:
Algoritmo: É um conjunto determinado de instruções
(ações) que quando seguidas desempenham uma tarefa
particular.
As estruturas de dados estão altamente relacionadas
aos algoritmos que as manipulam:
Algoritmos e estruturas de dados devem ser
consideradas como unidades distintas e
complementares.
A escolha de um algoritmo a ser utilizado depende da
representação e da estrutura dos dados.
CONCEITOS BÁSICOS
Estruturas de dados estáticas e dinâmicas:
Estáticas: A alocação de memória para essas
estruturas é realizada antes que o programa entre
em execução. Não oferece suporte adequado para
inserção e remoção de elementos dinamicamente.
• Homogêneas: vetores e matrizes
• Heterogêneas: tipos estruturados (registros)
Dinâmicas: A alocação de memória para essas
estruturas é realizada durante a execução do
programa, conforme a necessidade.
• Listas, filas, pilhas, árvores, etc.
ESTRUTURAS DE DADOS
Linguagem C
C é uma linguagem de programação compilada,
estruturada e de alto nível.
É uma das linguagens de programação mais
populares.
Oferece acesso a endereços de variáveis
A história de C
C nasceu na década de 70.
Seu inventor, Dennis Ritchie, implementou-o
pela primeira vez usando um DEC PDP-11
rodando o sistema operacional UNIX.
C é derivado de uma outra linguagem: o B,
criado por Ken Thompson.
B, por sua vez, veio da linguagem BCPL,
inventada por Martin Richards.
7
A história de C
Dados históricos:
– 1969 - Desenvolvimento do UNIX (num PDP 7 em
linguagem Assembly);
– 1969 - Desenvolvimento da linguagem BCPL, próxima do
Assembly;
– 1970 - Desenvolvimento da linguagem B, sucessora da
anterior (o B é a 1ª letra de BCPL);
– 1971 - Primeiro desenvolvimento da linguagem C,
sucessora da anterior (o C é a 2ª letra de BCPL);
– 1973 - O sistema operativo UNIX é reescrito em
linguagem C;
– 1978 - Primeira edição do livro The C Programming
Language, Kernighan & Ritchie;
– 1983-1988 - Definição do ANSI C;
8
História das Linguagens de
Programação
CONCEITOS BÁSICOS
A linguagem C:
Linguagem “convencional”
Devemos reservar uma área na memória para
armazenar cada dado.
Um programa em C é constituído de diversas
funções pequenas, independentes entre si.
Função principal (main) –automaticamente executada
após o programa ser carregado.
Tempo de vida e visibilidade das variáveis:
Variáveis locais;
Variáveis globais;
ESTRUTURAS DE DADOS
Ambiente de Desenvolvimento Integrado
Dev C++: Ambiente gratuito para programação
em C e C++.
http://www.bloodshed.net/devcpp.html
Microsoft Visual C++ Express Edition
http://www.microsoft.com/visualstudio/en-us/products/2010editions/visual-cpp-express
CONCEITOS BÁSICOS
Linguagem C x Linguagem Pascal:
Comando
Pascal
C
Comentários
{ comentario}
/* comentario */
Identificadores
Não é case sensitive
É case sensitive
Definição de tipos
type
typedef
Declaração de inteiros
integer
int
Declaração de caracter char
char
Boolean
Boolean – tratado
como true ou false
Não há – tratado como
0 ou 1
Real
real
Float ou double
Tipos enumerados
type a = (vermelho,
verde, azul)
enum a {vermelho,
verde, azul};
CONCEITOS BÁSICOS
Linguagem C x Linguagem Pascal:
Comando
Pascal
C
Vetores
Limites definidos pelo
programador. Ex:
var a = array[1..10] of
integer;
Começa da posição 0 e
vai até n – 1 (sendo n o
tamanho do vetor). Ex:
int a[10];
Strings
Tipo pré-definido
tratado internamente
como array.
O tipo string não é
definido. Deve-se criar
um vetor de char.
Registros
record
struct
Atribuição
:=
=
CONCEITOS BÁSICOS
Linguagem C x Linguagem Pascal:
Operadores
Pascal
C
Aritméticos
+, -, *, /, div, mod
+, -, *, /, %, ++, --
Relacionais
>, <, >=, <=, =, <>
>, <, >=, <=, ==, !=
Lógicos
and , or
&& , ||
Atribuições especiais
Não há
+=, -=, *=, /=, %=
CONCEITOS BÁSICOS
Linguagem C x Linguagem Pascal:
Estruturas de controle
Pascal
C
if cond then stmt else stmt
if (cond) stmt else stmt
while cond do stmt
while (cond) stmt
repeat stmt until cond
do stmt while (cond)
for id := expr to expr do stmt
for (expr; cond; expr) stmt
case expr of expr : stmt; ... expr :
stmt; else: stmt; end
switch (expr) { case expr : stmt; ...
case expr : stmt; default: stmt }
CONCEITOS BÁSICOS
Linguagem C x Linguagem Pascal:
Exemplo de programa que imprime “Olá Mundo!”
Pascal
Program ola;
Begin
writeln(“Olá mundo!”);
end.
C
#include <stdio.h>
int main()
{
printf(“Olá mundo!”);
}
CONCEITOS BÁSICOS
Declaração e inicialização de variáveis:
Valores constantes:
int a, b;
float c;
c = 5.3;
int a = 10;
a = b + 13
a = b + 12.5;
a = b + 12.5f;
// sem sufixo, é real do tipo double
// real do tipo float exige sufixo f ou F
Variáveis com valores indefinidos:
int a, b, c;
a = 2;
c = a + b;
ERRO: b tem lixo!!!
CONCEITOS BÁSICOS
Operadores:
Aritméticos:
Atribuição:
incremento (++), decremento (--);
Relacionais:
simples (=) ,compostos (+=, -=, *=, /=, %=);
De incremento e decremento:
adição (+) , subtração (-) , multiplicação (*) , divisão (/),
módulo (%);
menor que (<), maior que(>), menor ou igual que (<=), maior
ou igual que (>=), igual (==), diferente (!=).
Lógicos:
e/and (&&), ou/or (||), negação/not (!)
CONCEITOS BÁSICOS
Exemplos de utilização de operadores:
Quais serão os valores armazenados nas variáveis a, b, c?
int a;
double b, c;
a = 3.5;
b = a / 2.0;
c = 1/3 + b;
Resposta: a = 3, b = 1.5, c = 1.5.
CONCEITOS BÁSICOS
Exemplos de utilização de operadores:
x%2;
// operador % se aplica somente a operandos inteiros
a = 5;
// o valor resultante é o valor atribuído
y = x = 5;
x *= y + 1;
// var op= expr var = var op (expr)
x = n++; x = ++n;
// incrementa em uma unidade o valor de n
int c = 23, d = c + 4;
a = (c < 20) || (d > c); // armazena o valor 1 em a
b = (c < 20) && (d > c);
// armazena o valor 0 em b
Operadores
•Operadores Combinados
x = x op y; x op= y;
Expressão Normal
Expressão Simplificada
a = a + b;
a+=b;
a = a - b;
a-=b;
a = a * b;
a*=b;
a = a / b;
a/=b;
a = a % b;
a%=b;
CONCEITOS BÁSICOS
Operador
sizeof
Retorna o número de bytes de um determinado
tipo.
Exemplo:
…
int x = sizeof(int);
printf("Número de bytes ocupado pelo inteiro tipo inteiro é: %i \n", x);
...
sizeof(int) retorna 2 ou 4 dependendo do inteiro natural da
máquina
CONCEITOS BÁSICOS
Conversão de tipos
Operador cast: operador de molde de tipo
Exemplo
…
int a;
a = (int) 3.5;
printf("a = %i", a);
…
O valor impresso de a é 3 porque o valor 3.5 foi convertido
para inteiro
Operador de Modelagem
Exemplo de operador de modelagem
/* Exemplo utilizando moldagem (cast) */
#include <stdio.h>
void main(void)
{
int dividendo=10, divisor=3;
float quociente=0.0;
quociente = (float)dividendo / divisor;
printf("%d/%d = %.2f\n", dividendo, divisor, quociente);
getchar();
}
CONCEITOS BÁSICOS
Entradas e saídas básicas
As operações de entrada e saída em C são feitas
com o uso de funções.
Para utilizar essas funções é necessário incluir o
protótipo das funções no código. Para isso, devese incluir a biblioteca:
#include <stdio.h>
CONCEITOS BÁSICOS
Entradas e saídas básicas
Função printf:
Possibilita a saída de valores em um formato específico.
printf(formato, lista de constantes/variáveis/expressões);
Deve existir um especificador de formato
correspondente (Ex: %c, %d, %f, %s,…)
Ex: printf(“Inteiro: %d, real: %f”, 5, 3.4);
Função scanf:
Permite capturar valores fornecidos via teclado pelo
usuário do programa e armazená-los em variáveis.
scanf(formato, lista de endereços das variáveis…);
Ex: int n;
scanf(“%d”, &n);
OUTROS COMANDOS DE ENTRADA
A tabela a seguir exibe outras funções que podem
ser utilizadas para entrada de dados, ou seja funções
de leitura:
Função
Operação
getchar ( )
lê um caractere; espera por <enter>
getche(),getch()
lê um caractere ; não espera por <enter>
gets ( )
lê uma string via teclado
puts ( )
Imprime uma string na tela
27
scanf e printf
Tabela contendo códigos de formatação para printf e
scanf:
Código
printf
scanf
%d
imprime um inteiro
decimal
lê um inteiro decimal
%f
ponto decimal flutuante
lê um numero com ponto
flutuante
%s
string de caracteres
lê uma string de caracteres
%c
um único caractere
lê um único caractere
%p
imprime um ponteiro
lê um ponteiro
%%
imprime % na tela
28
CONCEITOS BÁSICOS
Linguagem C
Exemplo de programa que lê e Mostra Idade
C
#include <sdtio.h>
#include <conio.h>
void main()
{
clrscr();
int idade;
char nome[30];
printf(“Digite sua Idade: “);
scanf(“%d”,&idade);
printf(“Seu Nome: “);
scanf(“%s”,nome); /* Strings não utilizar ‘&’ na leitura */
printf(“%s sua idade e %d anos. \n”, nome, idade);
}
O tamanho e precisão do campo
• O tamanho do campo indica quantas posições da saída
serão utilizados para exibir o valor correspondente à um
especificador de formato.
• O tamanho do campo é determinado colocando-se um
número entre o % e o caracter indicador do formato.
– Por exemplo, %5d indica que o valor a ser impresso vai
ocupa 5 posições na tela.
• Por padrão, as posições em excesso são preenchidas com
brancos e o valor é alinhado à direita do campo.
30
O tamanho e precisão do campo
• Se o tamanho do campo for precedido por um
símbolo - (menos), então o valor será alinhado à
esquerda do campo.
• Se o tamanho do campo for precedido com o
símbolo 0 (zero), então as posições excedentes são
preenchidas com zeros.
• Sempre que o tamanho do campo for insuficiente
para exibir o valor solicitado, este tamanho é
ignorado. Desta forma um valor nunca é truncado.
31
O tamanho e precisão do campo
•
Para valores em ponto-flutuante, pode-se definir o número de
casas decimais a serem impressas, colocando-se o um ponto
(.) e outro número depois do tamanho do campo.
–
•
Por exemplo, o formato %10.2f, exibe o valor em pontoflutuante com duas casas decimais, dentro de um campo de
tamanho 10.
Se esta mesma lógica for utilizada com strings (formato %s), o
valor antes do ponto continua indicando a tamanho do campo,
porém a segunda parte limitará o número máximo de
caracteres da string a serem impressos.
32
CONCEITOS BÁSICOS
Controle de fluxo: C provê as construções
fundamentais de controle de fluxo necessárias para
programas bem estruturados.
Tomadas de decisão:
if(expr) {
if (expr){
OU
bloco de comandos 1
bloco de comandos 2
...
ou
}
}
...
}
else {
bloco de comandos 1
Operador condicional:
condicao ? expressao1 : expressao2;
CONCEITOS BÁSICOS
Controle de fluxo:
Construções com laços:
while (expr)
{
bloco de comandos
…
}
for (expr_inicial; expr_booleana; expr_de_incremento)
ou
{
bloco de comandos
…
}
CONCEITOS BÁSICOS
Controle de fluxo:
Construções com laços:
do
{
bloco de comandos
…
} while (expr_booleana);
ou
OBS: O bloco de comandos será executado pelo
menos uma vez.
CONCEITOS BÁSICOS
Controle de fluxo:
Interrupções com break:
Quando utilizado dentro de um laço, interrompe e
termina a execução do mesmo.
Interrupções com continue:
Quando utilizado dentro de um laço, interrompe a
execução e passa para a próxima iteração.
ou
CONCEITOS BÁSICOS
Controle de fluxo:
Seleção:
switch(expr){
case op1:
Inteiro ou uma constante caractere
…
break;
case op2:
Se break for omitido, a execução do caso
continua com os comandos do caso seguinte.
…
break;
default:
…
break;
}
ou
Executado quando expr for diferente de todos
os casos enumerados.
CONCEITOS BÁSICOS
Exercícios:
1) Implemente um programa que faz a conversão
de um valor de temperatura na escala Celsius
para a Fahrenheit – formula: F = C × 1,8 + 32.
2) Faça um programa para calcular o Índice de
Massa Corporal (IMC) e, com base no resultado,
informar a categoria à qual o indivíduo pertence,
de acordo com a tabela mostrada abaixo. O IMC
é definido como a relação entre o “peso” e a
altura ao quadrado. A altura deve ser dada em
metros e o peso em kg. O IMC é calculado de
acordo com a fórmula dada a seguir e as
categorias são definidas pelos limites abaixo:
CONCEITOS BÁSICOS
Exercícios:
3) Escreva um programa que faça uma contagem
regressiva usando while a partir do número digitado
pelo usuário. O programa deve fazer isso enquanto o
valor digitado for positivo.
CONCEITOS BÁSICOS
Exercícios:
4) Escreva um algoritmo em C que determine o
conceito da nota do estudante de acordo com
seu valor
Nota maior ou igual a 90 => “A”
Nota no intervalo de 80 a 89 => “B”
Nota no intervalo de 70 a 79 => “C”
Nota no intervalo de 60 a 69 => “D”
Para as demais notas “R”
CONCEITOS BÁSICOS
Funções
Funções é o mecanismo adequado para codificar
tarefas específicas.
Vantagens:
Facilita a codificação: codificar diversas funções
pequenas é mais fácil que codificar uma única maior.
Funções específicas podem ser facilmente reutilizadas
em outros códigos.
Tipo geral
tipo_retornado nome_da_função (lista de parâmetros...)
{
corpo da função
}
CONCEITOS BÁSICOS
Funções
tipo_retornado nome_da_função (lista de parâmetros...)
{
}
corpo da função
tipo_retornado = void
indica o não retorno de um valor
tipo_retornado = int, char, float, …
retorna um valor do tipo
definido
tipo_retornado = int*, char*, …
retorna um ponteiro para int, char, …
OBS: Funções retornam um único valor!
CONCEITOS BÁSICOS
Funções
tipo_retornado nome_da_função (lista de parâmetros...)
{
corpo da função
}
nome_da_função: identificador da função no programa.
lista de parâmetros: declarações de variáveis que serão usadas na
função.
corpo da função: instruções que serão executadas quando a
função for chamada.
CONCEITOS BÁSICOS
Exemplos de funções
void imprimeMensagem() {
printf(“Ola Mundo!”);
}
float calculaMedia(float a, float b) {
float media = 0;
media = (a + b)/2;
return media;
}
CONCEITOS BÁSICOS
Funções
C exige que se coloque o protótipo da função
antes de ela ser chamada.
Protótipo: consiste na repetição da linha de sua
definição seguida do caractere “;”. Não há
necessidade de indicar o nome dos parâmetros,
só os tipos.
A transferência de dados entre funções é feita
com o uso de parâmetros e do valor de retorno da
função chamada.
CONCEITOS BÁSICOS
Chamada à função (tipo geral)
identificador(listaDeArgumentos);
ATENÇÃO: tipo_retornado definido!
ESTRUTURAS DE DADOS
Chamada à função (exemplos)
…
imprimeMensagem();
…
float a = 10.5;
float b = 13.5;
float c;
c = calculaMedia(a,b);
…
printf("Media = %f", calculaMedia(10.5, 13.5));
…
ESTRUTURAS DE DADOS
Passagem
Exemplo:
de parâmetros por valor
int main(){
float a = 10.5;
float b = 3.5;
float m = calculaMedia(a,b);
...
}
Escopo: função main
float calculaMedia(float c, float d){
float media = 0;
media = (c + d)/2;
return media;
}
a
10.5
E0
b
3.5
E4
m
7
Retorna média
calculada
Escopo: função média
c=a
d=b
c
10.5
E250
d
3.5
E254
média 7
ESTRUTURAS DE DADOS
Exemplo: Cálculo do fatorial
#include <stdio.h>
int main(void) {
int fat(int n){
int n = 5;
int f = 1, i;
int r;
for(i = n; n!=0; n-- )
r = fat(n);
f*=n;
printf("Fatorial de %d = %d \n", n, r);
return f;
system("pause");
}
return 0;
}
No final da função fat, o parâmetro n tem valor igual a zero. No entanto, a saída
do programa será: Fatorial de 5 = 120. O valor da variável n não mudou no
programa principal porque o valor de n passado é atribuído ao parâmetro da função
chamada.
ESTRUTURAS DE DADOS
Passagem de parâmetros por valor
Uma função pode retornar um tipo de valor para a
função que chama.
Muitas vezes, é necessário transferir mais do que
um valor para a função que chama, e isso não
pode ser feito com o retorno explícito de valores.
Ex: função que calcula a soma e o produto de dois
números.
ESTRUTURAS DE DADOS
Ponteiros
Ponteiros são variáveis que armazenam
valores de endereços de memória.
Declaração de variável do tipo ponteiro :
tipo *nome;
tipo: tipo do valor armazenado no endereço de memória
nome: identificador do ponteiro
Ex:
int a;
int *p;
Variável de nome a que pode armazenar valores
inteiros. Automaticamente, reserva-se um espaço na
memória suficiente para armazenar valores inteiros.
Variável de nome p que pode armazenar endereços
de memória em que existe um valor inteiro
armazenado.
ESTRUTURAS DE DADOS
Ponteiros
Operador unário * (conteúdo de)
Acessa o conteúdo do endereço de
memória armazenado pela variável
ponteiro.
Operador unário & (endereço de)
Resulta no endereço da posição da
memória reservada para a variável.
ESTRUTURAS DE DADOS
Ponteiros
Exemplos
int a; // variável simples
int *p; // ponteiro para inteiro
Pilha de execução
p
-
a
-
108
104
ESTRUTURAS DE DADOS
Ponteiros
Exemplos
int a; // variável simples
int *p; // ponteiro para inteiro
a = 5;
p = &a;
*p = 6;
Pilha de execução
Dizemos que p aponta para a, por isso
o nome ponteiro.
p
a
104
6
-5
108
104
ESTRUTURAS DE DADOS
Ponteiros
Exemplos
Outra representação:
Podemos desenhar setas,
sinalizando que uma variável
do tipo ponteiro aponta para
uma determinada área de
memória, em vez de criar
valores fictícios para os
endereços de memória.
Pilha de execução
p
a
6
ESTRUTURAS DE DADOS
Ponteiros
int main(){
int a, b, *p;
a = 2;
Erro: Variável p não inicializada!
*p = 3;
b = a + (*p);
printf(“%d”, b);
return 0;
}
Só podemos preencher o conteúdo de um ponteiro se ele tiver
sido devidamente inicializado (apontar para um espaço de
memória para o qual já se prevê o armazenamento de
valores do tipo em questão).
ESTRUTURAS DE DADOS
#include <stdio.h>
int main()
{
int a;
// a é um inteiro
int *aPtr; // aPtr é um apontador p/ um inteiro
a = 7;
aPtr = &a;
// aPtr aponta para o endereço de a
printf("O endereço de a : %p \n" , &a );
printf("O endereço de a : %p \n" , aPtr );
printf("O endereço de aPtr : %p \n" , &aPtr);
}
printf("O valor de a : %d \n" , a) ;
printf("O valor de a : %d \n" , *aPtr) ;
system("pause");
return 0;
ESTRUTURAS DE DADOS
Passagem de parâmetros por referência
É quando é passado o endereço de uma variável
como parâmetro.
Se vai passar o endereço de uma variável, deve existir uma
variável do tipo ponteiro para recebê-la.
Ex: 5) Função para calcular a soma e o produto de
dois números.
Toda vez que desejarmos alterar um valor de uma
variável da função que chama dentro da função
chamada, devemos passar o endereço da variável.
ESTRUTURAS DE DADOS
Passagem de parâmetros por referência
Exercício: 6) Implemente uma função para trocar
os valores entre duas variáveis dadas.
Para que os valores das variáveis da função
principal sejam alterados dentro da função
auxiliar que faz a troca, precisamos passar
para a função os endereços das variáveis.
A relação entre ponteiros e arrays
Em C++ arrays e ponteiros estão intimamente relacionados e podem
ser usados de maneira quase intercambiável.
Um nome de array pode ser encarado como um ponteiro constante.
Os ponteiros podem ser usados para fazer qualquer operação
envolvendo indexação de arrays.
Ex: int b[ 5 ];
int *bPtr;
bPtr = b; ou bPtr = &b[ 0 ]; // bPtr aponta para b[ 0 ]
Expressões com ponteiros e aritmética de
ponteiros
Ponteiros são operandos válidos em expressões
aritméticas
Porém nem todos os operadores usados nestas
expressões são válidos com variáveis do tipo ponteiro
Um conjunto limitado de operações pode ser executado
com ponteiros
Um ponteiro pode ser incrementado (++)
Um ponteiro pode ser decrementado (--)
Um inteiro pode ser somando a um ponteiro (+ ou +=)
Um inteiro pode ser subtraído de um ponteiro (- ou - =)
Um ponteiro pode ser subtraído de outro
Expressões com ponteiros e aritmética
de ponteiros
Variável ponteiro vPtr podendo ser inicializada como vPtr = v; ou
vPtr = &v [0];
Na aritmética convencional teríamos : 3000 + 2 = 3002
Na aritmética de ponteiros teremos vPtr = vPtr + 2;
//aqui o ponteiro é incrementado pelo tamanho do objeto inteiro al
qual o ponteiro se refere.
O número de bytes depende do tipo de dado do objeto
O resultado de vPtr = vPtr + 2; // produziria 3008 (3000 + 2 * 4)
Expressões com ponteiros e aritmética de
ponteiros
Se um ponteiro esta sendo incrementado ou decrementado por um,
podem ser usados os operadores de incremento (++) e
decremento (- -);
Ex: ++vPtr ou vPtr++ // incrementa o ponteiro para apontar para
// a próxima posição do array.
Ex: --vPtr ou vPtr-- // decrementa o ponteiro para apontar para o
// elemento precedente do array.
Variáveis ponteiros que apontam para o mesmo array podem ser
subtraídas umas das outras.
Ex: vPtr aponta para a posição 3000 e v2Ptr aponta para a posição
3008, o comando
X = v2Ptr – vPtr; //atribuiria a x o número de elementos de array de
//vPtr até v2Ptr, neste caso 2.
#include <stdio.h>
void bubbleSort( int *array, const int size );
void swap( int* element1Ptr, int* element2Ptr);
int main()
{
const int arraySize = 10;
int a[] = {2,6,4,8,10,12,89,68,45,37};
int i;
bubbleSort( a, arraySize );
// sort the array
printf("\nData items in ascending order\n");
for ( i = 0; i < arraySize; i++ )
printf("%5d", a[i]);
system("pause");
}
return 0;
void bubbleSort( int *array, const int size )
{
int pass, j;
for(pass = 0; pass < size - 1; pass++)
for (j = 0; j < size - 1; j++ )
if ( array[ j ] > array[ j + 1 ] )
swap( &array[ j ], &array[ j + 1 ] );
}
void swap(int* element1Ptr,
int* element2Ptr)
{
int aux;
aux = *element1Ptr;
*element1Ptr = *element2Ptr;
*element2Ptr = aux;
}
ESTRUTURAS DE DADOS
Variáveis globais
Uma variável global é declarada fora do corpo
das funções e é visível a todas as funções
subseqüêntes.
As variáveis globais não são armazenadas na
pilha de execução e existem enquanto o
programa estiver sendo executado.
O uso de variáveis globais deve ser feito com
critério, pois podemos criar um alto grau de
interdependência entre as funções.
ESTRUTURAS DE DADOS
Variáveis estáticas
As variáveis estáticas são armazenadas na área
de memória estática.
As variáveis estáticas continuam existindo
mesmo antes ou depois de a função ser
executada. Porém, uma variável estática
declarada dentro de uma função só é visível
dentro dessa função.
Uma utilização interessante é quando se necessita
recuperar o valor de uma variável atribuída na última
vez em que a função foi executada.
ESTRUTURAS DE DADOS
Variáveis estáticas
Ex: Função para imprimir números reais. Ela
imprime um número por vez, separando-os por
espaço em branco e coloca, no máximo, 5
números por linha.
void imprime (float a)
{
static int n = 1;
printf(“ %f “, a);
if((n%5) == 0)
printf(“\n”);
}
n++;
ESTRUTURAS DE DADOS
Variáveis estáticas
Variáveis globais também podem ser declaradas
como estáticas. Nesse caso, não podem ser
acessadas por funções definidas em outros
arquivos.
Funções também podem ser declaradas como
estáticas, não podendo ser acessadas por funções
definidas em outros arquivos.
Exercicios
1) Implemente uma função que retorne a soma dos n primeiros
números naturais ímpares. Essa
função deve obedecer ao protótipo:
int soma_impares (int n);
Ex: Para n = 2 → soma = 1 + 3 = 4.
Para n = 3 → soma = 1 + 3 + 5 = 9, etc.
2) Implemente uma função que retorne uma aproximação do valor
de pi de acordo com a fórmula de Leibniz:
A função deve obedecer ao seguinte protótipo, em que n indica o
número de termos que devem ser usados para avaliar o valor de
pi:
double pi(int n);
Exercicios
3) Escreva uma função potencia (base, expoente) que,
quando chamada, retorna base^expoente.
Por exemplo, potencia (3, 4) = 3 * 3 * 3 * 3.
Assuma que expoente é um inteiro maior ou igual a 1.
4) Escreva um programa que lê 10 notas digitadas pelo
usuário, armazena estas notas em um arranjo de
tamanho 10. Imprime a soma, e a média das notas, a
maior e a menor nota. Depois seu programa deve
exibir as notas dos alunos em ordem crescente.
Exercicios
4 – Para cada um dos seguintes itens, escreva um
único comando para executar a tarefa indicada.
Assuma que as variáveis de ponto flutuante number1
e number2, foram declaradas e que number1 foi
inicializado com 7,3.
Declare a variável fPtr como um ponteiro para um
objeto do tipo double.
Atribua o endereço da variável number1 a variável
ponteiro fPtr
Imprima o valor do objeto apontado por fPtr
Atribua o valor do objeto apontado por fPtr a variável number2
Imprima o valor de number2
Imprima o endereço de number1
Imprima o endereço armazenado em fPtr.
O valor impresso é o mesmo que o endereço de number1 (sim/não)
Exercicios
5 - Escreva um programa completo em C, que
declara um registro Aluno com os seguintes
dados (Matricula, Nome, Curso).
Implemente o construtor da classe para inicializar os
dados.
Implemente um método (função) para entrada
de dados e um método para impressão de dados.
No programa principal declare um vetor para
armazenar 10 alunos, implemente um menu com as
seguintes opções:
1 – Cadastrar Aluno
2 – Imprimir listagem de todos os alunos
3 – Sair