UNIVERSIDADE DO VALE DO RIO DOS SINOS - UNISINOS

CINCIAS EXATAS E TECNOLGICAS

Disciplina: Linguagem de Programao C

Prof Viviane Todt

Argumentos do main(), alocao dinmica, recurso

Argumentos do main()
possvel passar informaes para a funo main() via argumentos da linha de comando.
Argumento da linha de comando informao que segue o nome do programa na linha de
comando do sistema operacional.
Ex.: void main(int argc, char *argv[])
Argumentos especiais
argc
argv
Contm o nmero um ponteiro para uma matriz de ponteiros para caractere. Cada elemento desta matriz aponta
de argumentos da para um argumento da linha de comando. Todos os argumentos da linha de comando so
linha de comando. strings. Se necessrio, o programa pode converter a string para um nmero no formato
Deve ser inteiro.
adequado (ex.: atoi(string)).
Cada argumento deve ser separado por um espao ou caractere de tabulao (na linha de
comando).
argv[0] contm o nome do programa.

Teoricamente, pode-se ter at 32.767 argumentos, mas a maioria dos sistemas operacionais
no permite mais do que alguns poucos. Geralmente, usa-se esses argumentos para indicar o nome
de um arquivo ou uma opo. O uso dos argumentos da linha de comando d aos seus programas
uma aparncia profissional e facilita o uso do programa em arquivos de lote (batch files).
Os nomes argc e argv so tradicionais, porm arbitrrios. Em geral, pode-se dar quaisquer
nomes a esses dois parmetros.
Ex1.: programa que imprime Ola e um nome na tela
#include <stdio.h>
#include <stdlib.h>
void main(int argc,char *argv[])
{
if(argc!=2)
{
printf("Voce esqueceu de digitar o nome.\n");
exit(1);
}
printf("ola %s",argv[1]);
}

Ex2.: programa que imprime um valor (at zero) na tela, caso display seje 1
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
void main(int qtde_argum, char *vetor_arg[])
{ int disp, count;
if(qtde_argum<2)
{ printf("Voce deve digitar o valor a contar.\n");
exit(1); }
if(qtde_argum==3 && !strcmp(vetor_arg[2],"display")) disp=1;
else disp=0;
for(count=atoi(vetor_arg[1]);count>0;count--)
if(disp) printf("%d\n",count);
printf("terminou"); }

Alocao dinmica
o meio pelo qual um programa pode obter memria enquanto est em execuo.
Existem dois mtodos de um programa em C armazenar informaes na memria principal
do computador:
Armazenamento dos dados alocado do espao da pilha do computador. Exige que o
programador saiba, de antemo, a quantidade de armazenamento necessria para todas as
situaes em que o programa possa se encontrar. Entretanto, algumas vezes, necessrio
ajustar as necessidades de armazenamento como resposta a eventos que s sero
conhecidos durante a execuo do programa;
Armazenamento para a informao alocado da memria livre (heap) em tempo de
execuo.
Um programa C compilado cria e usa quatro regies, logicamente distintas na memria, que
possuem funes especficas: pilha, heap, variveis globais e cdigo do programa.
Pilha

Heap
Variveis Globais
Cdigo do programa

Variveis Locais

Memria livre para alocao

rea de armazenamento permanente/uso, tambm, pelas
variveis locais estticas

Nota: a disposio exata de seu programa pode variar de compilador para compilador e de
ambiente para ambiente. A Figura anterior mostra conceitualmente como seu programa aparece na
memria.
A memria necessria para o programa e para as variveis globais fixa durante a execuo
do programa. Sob alguns casos relativamente extremos, a pilha pode coincidir com o heap. O fato
de o heap poder se esgotar implica que um pedido de alocao de memria pode falhar (e, de fato,
falha).
Pilha possui diversos usos durante a execuo do programa. Contm o endereo de retorno
das chamadas de funo, os argumentos para funes e variveis locais.
Heap regio de memria livre que seu programa pode usar, via funes de alocao
dinmica de C, em aplicaes como listas encadeadas e rvores. Embora o tamanho do heap seja
desconhecido, ele geralmente contm uma quantidade razoavelmente grande de memria livre.
Principais funes de alocao dinmica:
<stdlib.h> contm os prottipos para essas funes
malloc(size)
Requisita memria (heap). Devolve um ponteiro para o primeiro byte de uma
regio de memria de tamanho size que foi alocada no heap. Caso no haja memria suficiente no
heap para satisfazer a solicitao, malloc() devolve um ponteiro nulo. Voc deve sempre verificar
se o valor devolvido no um ponteiro nulo, antes de utiliz-lo. A tentativa de usar um ponteiro
nulo resultar geralmente em uma quebra do sistema.
free(ptr) Libera memria (heap). Devolve ao heap a memria apontada por ptr, tornando a
memria disponvel para alocao futura.
O fragmento de cdigo abaixo aloca 1000 bytes de memria:
char *p;
p=malloc(1000); /* aps a atribuio, p aponta para o primeiro dos 1000 bytes de memria
livre*/
O prximo exemplo aloca espao para 50 inteiros:
int *p;
p=malloc(50*sizeof(int));
Como o heap no infinito, sempre que alocar memria, voc deve testar o valor devolvido
por malloc(), antes de usar o ponteiro, para estar certo de que no nulo. Usar um ponteiro nulo
quase certamente travar o computador. Ex.:
if(!(p=malloc(100))
{
printf(sem memoria\n);
exit(1);
}
Ateno: nunca use free() com um argumento invlido, pois isto destruiria a lista de memria livre.
3

Ex.: aloca espao para um vetor de 5 posies, sendo que cada posio do tipo int.
#include <stdio.h>
#include <stdlib.h>
void main()
{
int *vet,*aux,i;
vet=(int *)malloc(sizeof(int)*5);
if(vet==NULL)
{ printf("Falta memoria!\n");
exit(0); }
for(i=0;i<5;i++)
{ printf("Forneca um valor:\n");
scanf("%d",&vet[i]);
}
printf("Valores digitados:\n");
for(i=0;i<5;i++)
printf("%d ",vet[i]);
free(vet); }

Exerccios de fixao:
1) Criar um programa em C que receba uma string atravs da linha de comando do sistema
operacional e a escreva de trs para frente (usar argumentos do main()).
2) Elaborar um programa em C que aloque dinamicamente espao para um vetor de nmeros
reais, cujo tamanho ser definido pelo usurio em tempo de execuo do programa.
3) Reelaborar o programa do item [2], de tal forma que os nmeros sejam armazenados em uma
matriz de tamanho definido em tempo de execuo.
3) Criar um programa em C que aloque dinamicamente espao para uma varivel definida como
INFO. O programa deve obter valores para essa varivel e, aps, imprimir o seu contedo. No
final, deve-se liberar a memria alocada.
struct{ char *nome;
int idade;
char *profissao;
}info;

Recurso
Em C, funes podem chamar a si mesmas.
A funo recursiva se um comando no corpo da funo a chama, ou seja, recurso o
processo de definir algo em termos de si mesmo e , algumas vezes, chamado de definio circular.
Quando uma funo chama a si mesma, novos parmetros e variveis locais so alocados na
pilha e o cdigo da funo executado com essas novas variveis. Uma chamada recursiva no faz
uma nova cpia da funo; apenas os argumentos so novos. Quando cada funo recursiva retorna,
as variveis locais e os parmetros so removidos da pilha e a execuo recomea do ponto da
chamada funo dentro da funo.
Ao escrever funes recursivas, voc deve ter um comando if em algum lugar para forar a
funo a retornar sem que a chamada recursiva seja executada.
Ex.: programa que calcula o fatorial de um nmero inteiro.
#include <stdio.h>
fatorial(int); /*prototipo*/
void main()
{ fatorial(6);}
fatorial(int n)
{
int resp;

/* recursiva*/

if(n==1) return(1);
resp=fatorial(n-1)*n; /*chamada recursiva*/
printf("%d ",resp);
return(resp);
}
Consulte o captulo 6 (Recurso) do livro: C
Completo e Total de Herbert Schildt.