Leandro Almeida
[email protected]

Parâmetros são utilizados em computação
para possibilitar a construção de
subprogramas genéricos.

Parâmetros Formais
◦ Parâmetros formais são as variáveis declaradas no
cabeçalho do subprograma.

Parâmetros Reais
◦ Parâmetros reais são as variáveis passadas no
instante da chamada do subprograma.

Exemplo:
Parâmetros Formais
Parâmetros Reais



No instante da chamada do subprograma, o
parâmetro formal recebe uma cópia do valor
do parâmetro real correspondente.
Alterações feitas nos parâmetros formais não
refletem nos parâmetros reais
correspondentes.
Caracteriza-se por ser um mecanismo de
entrada de dados para o subprograma.

Exemplo:

Organizacao da memória (variável inteira)
int x;
(0xFF02)x
0000000

Organizacao da memória (variável inteira)
int x;
x = 5;
(0xFF02)x
5



Ponteiros (ou apontadores) são variáveis que,
ao invés de guardar um dado (valor), guardam
um endereço de memória, associada a outra
variável;
Dessa forma, ponteiros fazem referência a
outra variável;
x 0x3287AB
Exemplo:
0x3287AB

Abstração:
x
4

Sintaxe:
◦ Variáveis que são ponteiros são representadas da
seguinte forma: tipo *nome_variavel;
◦ Exemplo:
int *x;
x
NULL

Sintaxe:
◦ Variáveis que são ponteiros são representadas da
seguinte forma: tipo *nome_variavel;
◦ Exemplo:
int *x;
int y = 5;
x
(0xAD036)y
NULL
5

Sintaxe:
◦ Variáveis que são ponteiros são representadas da
seguinte forma: tipo *nome_variavel;
◦ Exemplo:
int *x;
int y = 5;
x = &y;
x
(0xAD036)y
0xAD036
5

Toda declaração de ponteiros, inicia o ponteiro
com o valor default NULL;
int *x;

(0x3847CD)x
NULL
É sempre bom testar se o ponteiro não é NULL
antes de acessá-lo;
if (x != NULL) {
...
}

x – representa o endereço armazenado no
ponteiro;
int *x;
printf(“Endereco da variavel x: %d”,&x);
printf(“Endereco guardado em x: %d”,x);

Atribuição de ponteiros.
◦ Só podemos jogar dentro do ponteiro um endereço;
int *x;
int y = 35;
x = &y;

(0x3847CD)x
(0x32496)y
0x32496
35
*x – representa o conteúdo final do ponteiro;
int *x;
printf(“Conteudo final de x: %d”,*x);
*x = 28;
printf(“Conteudo final de x: %d”,*x);

O que acontece no seguinte programa?
#include <stdio.h>
#include <conio.h>
main()
{
int y = 5;
int *x;
x = &y;
printf("Valor armazenado na variavel y: %d\n", y);
printf("Endereco de y: %d\n",&y);
printf("Valor do conteudo do ponteiro x: %d\n",*x);
printf("Valor do endereco armazenado no ponteiro x: %d\n", x);
printf("Valor do endereco de x: %d\n",&x);
printf("\n\nAlterando o valor armazenado na variavel x\n");
*x = *x + 1;
printf("\nNovo valor do conteudo do ponteiro x: %d\n",*x);
printf("Valor do endereco armazenado no ponteiro x: %d\n", x);
printf("Valor via y: %d\n",y);
getche();
}


Caracteriza-se por ser um mecanismo de
comunicação bidirecional com o
subprograma, ou seja, é um mecanismo de
entrada e saída de dados.
Qualquer modificação feita em um parâmetro
formal implica em alteração no parâmetro
real correspondente.


Na passagem por referência utiliza-se um
tipo de dados especial chamado ponteiro,
que representa o endereço da variável
passada por parâmetro. Representado pelo *
após o tipo da variável e antes do seu nome.
Exemplo:

Crie um programa na linguagem C que define
a estrutura de um carro, altere seus dados
através de uma função (use passagem por
referência e o operador ->) bem como use
outra função para exibir os membros da
struct.
#include <stdio.h>
#include <conio.h>
typedef struct
{
char modelo[30];
float potenciaMotor;
int anoFabricacao,
numPortas;
}CARRO;
void Exibe(CARRO car)
{
printf("\n\tExibindo carro\n");
printf("Modelo: %s\n", car.modelo);
printf("Motor: %.1f\n", car.potenciaMotor);
printf("Ano: %dn", car.anoFabricacao);
printf("%d portas\n", car.numPortas);
}
void Preenche(CARRO *car)
{
printf("Modelo do carro: ");
gets( car->modelo );
printf("Motor: ");
scanf("%f", &car->potenciaMotor);
printf("Ano: ");
scanf("%d", &car->anoFabricacao);
printf("Numero de portas: ");
scanf("%d", &car->numPortas);
}
main(void)
{
CARRO fusca;
Preenche(&fusca);
Exibe(fusca);
getche();
}
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
typedef struct {
char Rua[100], Bairro [20], Cidade [20];
int num, cep;
} tipo_endereco;
typedef struct { int mat, serie, irmao;
char nome[20];
float mens;
tipo_endereco ender;
} tipo_aluno;
int preencher(tipo_aluno A[20])
{
int qa, i, resp;
qa =0;
if (A[qa].irmao == 1)
A[qa].mens = A[qa].mens*0.8;
printf("\n digite o endereco: ");
printf("\n Rua : ");
fflush(stdin);
gets(A[qa].ender.Rua);
printf("\n Bairro: ");
fflush(stdin);
gets(A[qa].ender.Bairro);
printf("\n Cidade : ");
fflush(stdin);
gets(A[qa].ender.Cidade);
printf("\n numero: ");
;
scanf("%d",&A[qa].ender.num);
printf("\n cep: ");
do{
printf("Colegio Legal\n");
printf("\n\nCadastro de Alunos\n\n");
printf("\nMatricula.: ");
scanf("%d",&A[qa].mat);
printf("\nNome......: ");
fflush(stdin);
gets(A[qa].nome);
printf("\nSerie(1-4): ");
scanf("%d",&A[qa].serie);
printf("\nIrmao na escola(1-sim/0-nao):");
scanf("%d",&A[qa].irmao);
switch(A[qa].serie){
scanf("%d",&A[qa].ender.cep);
case 1: A[qa].mens = 110; break;
qa++;
case 2: A[qa].mens = 130; break;
printf("\n\nDeseja cadastrar outro aluno(1-sim/0-nao)? ");
case 3: A[qa].mens = 160; break;
scanf("%d",&resp);
case 4: A[qa].mens = 170; break;
}
}while ((resp == 1) && (qa <20));
return qa;
}
void relatorio_geral(tipo_aluno v_alunos[20],int q )
{
int j;
printf("Colegio Legal\n");
printf("\n\nRelatorio Geral\n");
printf("\n________________________________");
printf("\nMat.\tNome\tSerie\tIrmao\tMens.\tRua\tBairro\tCidade\tNumero\tCep");
printf("\n________________________________");
for(j = 0; j < q; j++)
{
printf("\n %5d %-10s %5d %5d %5.2f %-10s %-10s %-10s %5d %5d ",
v_alunos[j].mat, v_alunos[j].nome, v_alunos[j].serie,
v_alunos[j].irmao, v_alunos[j].mens, v_alunos[j].ender.Rua,
v_alunos[j].ender.Bairro, v_alunos[j].ender.Cidade,
v_alunos[j].ender.num, v_alunos[j].ender.cep);
printf("\n_______________________________");
}
}
main(){
int qa;
tipo_aluno alunos[20];
qa=preencher(alunos);
relatorio_geral(alunos,qa);
printf("\nTecle enter para sair...");
getche();
}

Escreva um programa que:
◦ Possua uma função que recebe como parâmetros um vetor de inteiros v, o
número de elementos dele N e ponteiros para variáveis nas quais devem
ser armazenados os valores maximo e minimo do vetor. Sua assinatura
deve ser:
 void maximoMinimo(int v[], int N, int *maximo, int *minimo){ }
◦ Outra função que retorne via ponteiros a média, mediana e desvio padrão
do vetor passado como parâmetro.
◦ Escreva também o main para usar essas funções.
#include <stdio.h>
#include <math.h>
void info(int v[], int N, float *media, int *mediana, float *dpadrao)
void ordena_crescente (int vet[], int tam)
{
{
int i, soma=0;
register int i, j; // indexadores.
int aux;
float vdev=0;
// variavel auxiliar.
for(i=0; i<N; i++)
for (i = 0; i < (tam - 1); i++)
soma+=v[i];
for (j = i + 1; j < tam; j++)
if (vet[i] > vet[j])
*media = (float)soma/N;
{
aux = vet[i];
ordena_crescente(v,N);
vet[i] = vet[j];
vet[j] = aux;
*mediana = v[N/2];
}
}
soma=0;
void maximoMinimo(int v[], int N, int *maximo, int *minimo)
for(i=0; i<N; i++)
{
vdev+=(v[i]-(*media))*(v[i]-(*media));
int i;
*maximo = v[0];
*dpadrao = sqrt(vdev/N);
*minimo = v[0];
for (i=1; i<N; i++)
{
if(v[i]>*maximo)
*maximo = v[i];
if(v[i<*minimo])
*minimo=v[i];
}
}
}
main()
{
int vetor[100], vmediana, vmax, vmin, tam, i;
float desvio, vmedia;
do{
printf("\nDigite o tamanho do vetor: ");
scanf("%d",&tam);
}while(tam<2 || tam>100);
for(i=0; i<tam; i++)
{
printf("\nDigite o valor da pos. %d:", i+1);
scanf("%d",&vetor[i]);
}
maximoMinimo(vetor,tam,&vmax,&vmin);
printf("\nO maximo eh: %d \nO valor minimo eh: %d", vmax, vmin);
info(vetor,tam,&vmedia,&vmediana,&desvio);
printf("\nMedia do vetor: %f", vmedia);
printf("\nMediana do vetor: %d", vmediana);
printf("\nDesvio padrao do vetor: %f", desvio);
}