Escolar Documentos
Profissional Documentos
Cultura Documentos
INTRODUÇÃO À LINGUAGEM C
Bibliografia.
CDD 004.22
Nenhuma parte desta publicação pode ser reproduzida, por qualquer meio, sem a
prévia autorização.
SUMÁRIO
1 Introdução 11
1.1 Linguagens de Máquina, Linguagens de Montagem, e Linguagens de Alto-Nível 11
1.2 A História do C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.3 A Biblioteca padrão C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.4 Características de C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.5 C e C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.6 O compilador GCC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2 Estrutura de um programa em C 17
2.1 Visão geral de um programa C . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.2 Um programa utilizando uma função . . . . . . . . . . . . . . . . . . . . . . . 19
3 Sintaxe 21
3.1 Identificadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.2 Tipos de variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.2.1 Tipos Básicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.3 Declaração e Inicialização de Variáveis . . . . . . . . . . . . . . . . . . . . . 23
3.4 Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.4.1 Operador de atribuição . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.4.2 Operadores Aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.4.3 Operadores relacionais e lógicos . . . . . . . . . . . . . . . . . . . . . 27
3.4.4 Precedência . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.4.5 Operador cast (modelador) . . . . . . . . . . . . . . . . . . . . . . . . 29
3.4.6 Operador sizeof . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
7 Manipulação de Strings 57
7.1 Função gets() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
7.2 Função puts() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
7.3 Função strcpy() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
7.4 Função strcat() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
7.5 Função strcmp() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
8 Ponteiros 61
8.1 Declarando Ponteiros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
8.2 Manipulação de Ponteiros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
8.3 Expressões com Ponteiros . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
8.4 Ponteiros para ponteiros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
8.5 Problemas com ponteiros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
9 Ponteiros e Matrizes 67
9.1 Manipulando Matrizes através de Ponteiros . . . . . . . . . . . . . . . . . . . 68
9.2 String e Ponteiros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
9.3 Matrizes de Ponteiros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
10 Funções 71
10.1 Função sem Retorno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
10.2 Função com Retorno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
10.3 Parâmetros Formais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
10.3.1 Chamada por Valor . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
10.3.2 Chamada por Referência . . . . . . . . . . . . . . . . . . . . . . . . . 73
10.4 Classe de Variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
10.4.1 Variáveis locais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
10.4.2 Variáveis Globais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
10.4.3 Variáveis Estáticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
10.5 Funções com Matrizes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
10.5.1 Passando Parâmetros Formais . . . . . . . . . . . . . . . . . . . . . . 78
10.5.2 Alterando os Valores da Matriz . . . . . . . . . . . . . . . . . . . . . . 80
15 Exercícios 97
15.1 Capítulo 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
15.2 Capítulo 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
15.3 Capítulo 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
15.4 Capítulo 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
15.5 Capítulo 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
15.6 Capítulo 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
15.7 Capítulo 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
15.8 Capítulos 8 e 9 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
15.9 Capítulo 10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
15.10Capítulo 11 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
15.11Capítulo 12 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
15.12Capítulo 13 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
15.13Capítulo 14 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
10.1 Inversão de uma string usando uma função que recebe um ponteiro . . . . . 72
10.2 Um codificador simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
10.3 Função com retorno de inteiro . . . . . . . . . . . . . . . . . . . . . . . . . . 74
10.4 Parâmetros formais de uma função . . . . . . . . . . . . . . . . . . . . . . . . 74
10.5 Passagem de valor de uma variável para uma função . . . . . . . . . . . . . 75
10.6 Função que utiliza passagem por referência . . . . . . . . . . . . . . . . . . . 75
10.7 Variáveis locais em uma função . . . . . . . . . . . . . . . . . . . . . . . . . . 76
10.8 Variáveis globais em um programa . . . . . . . . . . . . . . . . . . . . . . . . 77
10.9 Variáveis locais em uma função . . . . . . . . . . . . . . . . . . . . . . . . . . 77
10.10Função que utiliza uma matriz . . . . . . . . . . . . . . . . . . . . . . . . . . 78
10.11Função que opera sobre uma matriz utilizando um ponteiro . . . . . . . . . . 79
10.12Função que procura uma substring dentro de uma string . . . . . . . . . . . . 79
10.13Alterando valores de uma matriz . . . . . . . . . . . . . . . . . . . . . . . . . 80
1. Linguagens de máquina,
2. Linguagens de montagem,
+1300042774
+1400593419
+1200274027
LOAD BASEPAY
ADD OVERPAY
STORE GROSSPAY
Obviamente, linguagens de alto nível são muito mais desejáveis do ponto de vista dos
programadores que linguagens de máquina ou linguagens de montagem. C e C++ estão
entre as mais poderosas e mais largamente usadas linguagens de alto nível.
Introdução 13
1.2 A HISTÓRIA DO C
ria dos programadores em C aproveitam uma rica coleção de funções existentes, chamada
C Standard Library. Portanto, há realmente duas etapas para aprender o “mundo” C. A
primeira é aprender a própria linguagem C, e a segunda aprender como usar as funções da
biblioteca padrão C.
Neste curso, você será levado a usar a abordagem de construção de blocos (Building
block approach) para criar programas. Evite reinventar a roda. Use pedaços existentes —
isto é chamado reutilização de software e é a chave para o campo de desenvolvimento de
programas orientados ao objeto como veremos. Quando programando em C você usará
tipicamente os seguintes blocos de construção:
A vantagem de criar suas próprias funções é que você vai saber exatamente como
elas funcionam. Você poderá examinar o código C. A desvantagem é o tempo consumido
em esforço que leva do projeto ao desenvolvimento de novas funções.
Usar funções existentes evita reinventar a roda. No caso de funções padrão ANSI,
você sabe que elas são cuidadosamente escritas, e você sabe que por estar usando fun-
ções que são disponíveis em virtualmente todas as implementações ANSI C, seu programa
terá uma chance muito maior de ser portável.
1.4 CARACTERÍSTICAS DE C
• portabilidade
• modularidade
• recursos de baixo nível
• geração de código eficiente
• simplicidade
• facilidade de uso
• possibilidade de ser usada para os mais variados propósitos
• indicada para escrever compiladores, editores de textos, bancos de dados, etc.
Introdução 15
Como resultado, tem-se que C e C++ podem ser consideradas “padrões de indústria”
pelas empresas de desenvolvimento de software. Várias dessas empresas adotam estas
linguagens na maioria de seus projetos. Para o programador, o conhecimento da linguagem
C é de grande valor.
1.5 C E C++
Algumas vezes os iniciantes confundem o que é C++ e como difere de C. C++ é uma
versão estendida e melhorada de C que foi projetada para suportar programação orien-
tada a objetos (OOP). C++ contém e suporta toda a linguagem C e mais um conjunto de
extensões orientadas a objetos.
Por muitos anos ainda os programadores escreverão, manterão e utilizarão progra-
mas escritos em C, sem se preocuparem em utilizar os benefícios da orientação a objetos
proporcionados por C++, por isso o código escrito em C estará em uso por muitos anos
ainda.
Todos os programas utilizados como exemplo neste curso utilizam apenas funções da
linguagem C padrão ANSI (ANSI C), portanto recomendamos a utilização de um compilador
de C que funcione bem para programas que seguem este padrão. O compilador GCC é o
compilador de C do projeto GNU (http//:www.gnu.org), é gratuito e de código aberto.
O projeto GNU (Gnu’s Not Unix) foi proposto por Richard Stallman em 1983. Richard
Stallman é pesquisador do MIT e inventor do editor EMACS. O projeto teve início em 1984,
e a proposta era desenvolver um sistema operacional completo e livre, similar ao Unix: o
sistema GNU (GNU é um acrônimo recursivo que se pronuncia “guh-NEW” ou “guniw”).
Variações do sistema GNU, que utilizam o núcleo Linux, são hoje largamente utilizadas;
apesar desses sistemas serem normalmente chamados de “Linux”, eles são mais precisa-
mente chamados Sistemas GNU/Linux.
O desenvolvimento do GCC é uma parte do Projeto GNU, com o objetivo de melhorar
o compilador usado no sistema GNU incluindo a variante GNU/Linux. O trabalho de desen-
volvimento do GCC usa um ambiente aberto de desenvolvimento e suporta muitas outras
plataformas com o propósito de promover um compilador de primeira linha (world-class) que
seja otimizado continuamente, de reunir um grande time de desenvolvedores, de assegurar
que o GCC e o sistema GNU trabalhem em múltiplas arquiteturas e diversos ambientes, e
de atender a muitos outros testes e mais características de GCC.
16 EDITORA - UFLA-FAEPE - Introdução à Linguagem C
Em Abril de 1999, o egcs steering committee foi indicado pelo FSF como o mantenedor
oficial GNU para GCC. Naquele tempo GCC foi renomeado para “GNU C Compiler” e para
“GNU Compiler Collection” e recebeu uma nova missão.
Atualmente GCC contém aplicações para C, C++, Objective C, Chill, Fortran, e Java
bem como bibliotecas para estas linguagens (libstdc++, libgcj,...).
Uma versão do compilador GCC pode ser obtida no ftp do curso de Ciência da Com-
putação da UFLA1 . Obtenha uma cópia do compilador e instale em seu computador.
De posse do GCC instalado e configurado (independente de sua portagem ou ambi-
ente), para compilar um programa denominado nome.c, execute a seguinte linha de co-
mando:
onde nome é o nome dado ao programa. Com isso, o arquivo nome.c será compilado
gerado um executável nome.exe (em ambientes Linux, a extensão ‘.exe’ é desnecessá-
ria).
1
ftp://ftp.comp.ufla.br/pub/
2
ESTRUTURA DE UM PROGRAMA EM C
/* Estrutura de um programa em C */
# include <arquivo_cabecalho.h>
int main ( )
{
declaração de variáveis
instrução_1;
instrução_2;
função_1(variáveis);
instrução_3;
-
-
}
int função_1 (variáveis)
{
declaração de variáveis
instrução_1;
instrução_2;
-
-
return (INT);
}
/* programa exemplo 01 */
# include <stdio.h>
main ( )
{
printf("Alo, Mundo!");
}
Isto indica ao computador para utilizar o compilador GCC para compilar o programa
exemp_01.c escrito em C e dar ao arquivo executável gerado o nome de exemp_01. Ao
final, rode o programa.
A função printf já está programada dentro de stdio.h, e é utilizada para escrever
mensagens na tela do computador. As funções pré-programadas devem ser escritas em
letras minúsculas.
Modifique este programa para escrever outra mensagem além de “Alo, Mundo!”.
no nosso exemplo é chamado pelo comando gcc. Essa ação desencadeia uma seqüência
de etapas, cada qual traduzindo a codificação do usuário para uma forma de linguagem de
nível inferior, que termina com o executável criado pelo lincador.
Edição
(módulo fonte em C)
Pré−Processamento
(novo fonte expandido)
Compilação
(arquivo objeto)
Lincagem
(executável)
Execução
/* programa exemplo 02 */
# include <stdio.h>
main ( )
{
int num, quad;
printf("Envie um numero inteiro: ");
scanf("%d",&num);
quad = quadrado(num);
printf("\n Quadrado de %d é : %d", num, quad);
Modifique este programa para que ele calcule o cubo do número: crie uma função
cubo.
3
SINTAXE
Sintaxe são regras detalhadas para cada construção válida na linguagem C. Estas
regras estão relacionadas com os tipos, as declarações, as funções e as expressões.
Os tipos definem as propriedades dos dados manipulados em um programa.
As declarações expressam as partes do programa, podendo dar significado a um
identificador, alocar memória, definir conteúdo inicial, definir funções.
As funções especificam as ações que um programa executa quando roda. A deter-
minação e alteração de valores, e a chamada de funções de I/O são definidas nas expres-
sões.
As funções são as entidades operacionais básicas dos programas em C, que por
sua vez são a união de uma ou mais funções executando cada qual o seu trabalho. Há
funções básicas que estão definidas na biblioteca C. As funções printf( ) e scanf( ) por
exemplo, permitem respectivamente escrever na tela e ler os dados a partir do teclado. O
programador também pode definir novas funções em seus programas, como rotinas para
cálculos, impressão, etc.
Todo programa C inicia sua execução chamando a função main( ), sendo obrigatória
a sua declaração no programa principal.
Comentários no programa são colocados entre /* e */ não sendo considerados na
compilação. Os comentários podem também ser colocados em uma linha, após o sinal //.
Cada instrução encerra com ; (ponto e vírgula) que faz parte do comando.
A Figura 3.1 mostra um exemplo de programa que utiliza estes conceitos básicos.
3.1 IDENTIFICADORES
São nomes usados para se fazer referência a variáveis, funções, rótulos e vários ou-
tros objetos definidos pelo usuário. O primeiro caracter deve ser uma letra ou um subli-
nhado. Os 32 primeiros caracteres de um identificador são significativos.
O C é “Case Sensitive”, isto é, os compiladores C entendem as letras maiúsculas e
minúsculas como sendo diferentes. Portando uma variável declarada como X1 será dife-
22 EDITORA - UFLA-FAEPE - Introdução à Linguagem C
# include <stdio.h>
main( ) /* função obrigatória */
{
char Nome[20];
printf("\n Alô! Qual é o seu nome ? ");
scanf("%s",Nome);
printf("\n Bom dia, %s ! \n",Nome);
}
rente de uma variável declarada com x1, uma variável chamada Tempo será diferente de
TEMPO, tempo e TeMPo. Os comandos básicos do C devem ser escritos sempre com
minúsculas (if, for, switch, etc.), caso contrário, o compilador não irá interpretá-los como
sendo comandos, mas como variáveis. O C possui outros comandos e palavras reservada
que são todos escritos em letras minúsculas. A Tabela 3.1 apresentada uma lista com as
palavras reservadas do padrão ANSI C.
Quando você declara um identificador, dá a ele um tipo. Os tipos principais podem ser
colocados dentro da classe do tipo de objeto de dado. Um tipo de objeto de dados deter-
mina como valores de dados são representados, que valores pode expressar, e que tipo de
operações você pode executar com estes valores. Os nomes dos identificadores As variá-
veis, identificadores, no C podem ter qualquer nome se duas condições forem satisfeitas: o
nome deve começar com uma letra ou sublinhado (_) e os caracteres subsequentes devem
Sintaxe 23
ser letras, números ou sublinhado (_). Há apenas mais duas restrições: o nome de uma
variável não pode ser igual a uma palavra reservada, nem igual ao nome de uma função
declarada pelo programador, ou pelas bibliotecas do C. Variáveis de até 32 caracteres são
aceitas.
215 = 32.768
216 = 65536
231 = 2.147.483.648
232 = 4.294.967.298
tipo_da_variável lista_de_variáveis;
As variáveis da lista de variáveis terão todas o mesmo tipo e deverão ser separadas
por vírgula. Como o tipo default do C é o int, quando vamos declarar variáveis int com
algum dos modificadores de tipo, basta colocar o nome do modificador de tipo. Assim um
long basta para declarar um long int.
Há três lugares nos quais podemos declarar variáveis. O primeiro é fora de todas as
funções do programa. Estas variáveis são chamadas variáveis globais e podem ser usadas
24 EDITORA - UFLA-FAEPE - Introdução à Linguagem C
Inteiros
char [0, 128) igual a signed char ou unsigned char
signed char [−128, 128) inteiro de pelo menos 8 bits
unsigned char [0, 256) mesmo que signed char sem negativos
short (2−15 , 215 ) inteiro de pelo menos 16 bits; tamanho pelo
menos igual a char
unsigned short [0, 216 ) mesmo tamanho que short sem negativos
int (2−15 , 215 ) inteiro de pelo menos 16 bits; tamanho pelo
menos igual a short
unsigned int [0, 216) mesmo tamanho que int sem negativos
long (2−31 , 231 ) inteiro com sinal de pelo menos 32 bits; tama-
nho pelo menos igual a int
unsigned log [0, 232 ) mesmo tamanho que long sem valores nega-
tivos
Ponto Flutuante
float [3.4E − 38, 3.4E + 38] pelo menos 6 dígitos de precisão decimal
double (1.7E −308, 1.7E +308) pelo menos 10 dígitos decimais e precisão
maior que do float
long double (1.7E −308, 1.7E +308) pelo menos 10 dígitos decimais e precisão
maior que do double
a partir de qualquer lugar no programa. Pode-se dizer que, como elas estão fora de todas
as funções, todas as funções as vêem. O segundo lugar no qual se pode declarar variáveis
é no início de um bloco de código de uma função. Estas variáveis são chamadas locais e só
têm validade dentro do bloco no qual são declaradas, isto é, só a função à qual ela pertence
sabe da existência desta variável. O terceiro lugar onde se pode declarar variáveis é na lista
de parâmetros de uma função. Mais uma vez, apesar de estas variáveis receberem valores
externos, são conhecidas apenas pela função onde são declaradas.
As regras que regem onde uma variável é válida chamam-se regras de escopo da
variável. Há mais dois detalhes que devem ser ressaltados. Duas variáveis globais não
podem ter o mesmo nome. O mesmo vale para duas variáveis locais de uma mesma função.
Já duas variáveis locais, de funções diferentes, podem ter o mesmo nome sem perigo algum
de conflito.
Sintaxe 25
Podemos inicializar variáveis no momento de sua declaração. Para fazer isto podemos
usar a forma geral
Isto é importante pois quando o C cria uma variável ele não a inicializa. Isto significa
que até que um primeiro valor seja atribuído à nova variável ela tem um valor indefinido e
que não pode ser utilizado para nada. Nunca presuma que uma variável declarada vale
zero ou qualquer outro valor. Exemplos de inicialização podem ser vistos na Figura 3.2.
char ch=’D’;
int count=0;
float pi=3.1416;
# include <stdio.h>
main()
{
char c;
unsigned char uc;
int i;
unsigned int ui;
float f;
double d;
printf("char %d",sizeof(c));
printf("unsigned char %d",sizeof(uc));
printf("int %d",sizeof(i));
printf("unsigned int %d",sizeof(ui));
printf("float %d",sizeof(f));
printf("double %d",sizeof(d));
}
3.4 OPERADORES
x = y = z = 2.45;
Operador Ação
+ Soma (inteira e ponto flutuante)
- Subtração ou Troca de sinal (inteira e ponto flutuante)
* Multiplicação (inteira e ponto flutuante)
/ Divisão (inteira e ponto flutuante)
% Resto de divisão (de inteiros)
++ Incremento (inteiro e ponto flutuante)
-- Decremento (inteiro e ponto flutuante)
O C possui operadores unários e binários. Os unários agem sobre uma variável ape-
nas, modificando ou não o seu valor, e retornam o valor final da variável. Os binários usam
duas variáveis e retornam um terceiro valor, sem alterar as variáveis originais. A soma é
um operador binário pois pega duas variáveis, soma seus valores, sem alterar as variáveis,
e retorna esta soma. Outros operadores binários são os operadores - (subtração), *, / e
%. O operador - como troca de sinal é um operador unário que não altera a variável sobre
a qual é aplicado, pois ele retorna o valor da variável multiplicado por -1.
Os operadores de incremento e decremento são unários que alteram a variável sobre
a qual estão aplicados. O que eles fazem é incrementar ou decrementar de um a variável
sobre a qual estão aplicados. Então
x++;
x--;
Sintaxe 27
x = x+1;
x = x-1;
x = 23;
y = x++;
x = 23;
y = ++x;
i += 2; −→ i = i+2;
x *= y+1; −→ x = x*(y+1);
d -= 3; −→ d = d - 3;
A Figura 3.4 apresenta um programa simples que utiliza operadores aritméticos sobre
números inteiros, e a Figura 3.5 apresenta um programa para fazer a conversão de medidas
em pés para metros, utilizando operações sobre números em ponto flutuante.
A função scanf( ) é utilizada para ler um valor numérico do teclado do computador.
# include <stdio.h>
main()
{
int x, y;
x =10; y = 3;
printf("%d\n", x/y);
printf("%d\n", x%y);
}
#include <stdio.h>
/* Conversão de pés para metros. */
main()
{
float pes, metros;
printf("Informe o número de pés: ");
scanf("%f", &pes); /* lê um float */
metros = pes * 0.3048; /* conversão de pés para metros */
printf("%f pes é %f metros\n", pes, metros);
}
relacionais lógicos
> maior que && and (E)
>= maior ou igual || or (OU)
< menor ! not (NÃO)
<= menor ou igual
== igual
!= não igual
Sintaxe 29
# include <stdio.h>
main()
{
int i,j;
printf("digite dois números: ");
scanf("%d%d", &i, &j);
printf("%d == %d é %d\n", i, j, i==j);
printf("%d != %d é %d\n", i, j, i!=j);
printf("%d <= %d é %d\n", i, j, i<=j);
printf("%d >= %d é %d\n", i, j, i>=j);
printf("%d < %d é %d\n", i, j, i<j);
printf("%d > %d é %d\n", i, j, i> j);
}
/* Maior de Dois */
# include <stdio.h>
main( )
{
int x=2, y=3, produto;
if ((produto = x*y) > 0) printf("é maior");
}
3.4.4 Precedência
Sintaxe: (tipo)expressão
Podemos forçar uma expressão a ser de um determinado tipo usando o operador
cast. Um exemplo pode ser visto na Figura 3.8. Nesse exemplo, se não fosse utilizado o
30 EDITORA - UFLA-FAEPE - Introdução à Linguagem C
modelador (float) sobre a variável i, o programa imprimiria “1/3 = 0”, pois, ele faria primeiro
a divisão de inteiros (1/3) resultando 0, e depois a conversão do resultado para float.
# include <stdio.h>
main( )
{
int i=1;
printf(" %d/3 é: %f ", i, (float) i/3);
}
O operador sizeof retorna o tamanho em bytes da variável, ou seja, do tipo que está
em seu operando. É utilizado para assegurar a portabilidade do programa. O operador
sizeof é usado para se saber o tamanho de variáveis ou de tipos. Ele retorna o tamanho
do tipo ou variável em bytes. Mas porque usá-lo se sabemos, por exemplo, que um inteiro
ocupa 2 bytes? Devemos usá-lo para garantir portabilidade. O tamanho de um inteiro pode
depender do sistema para o qual se está compilando. O sizeof é chamado um operador
porque ele é substituído pelo tamanho do tipo ou variável no momento da compilação. Ele
não é uma função. O sizeof admite duas formas:
sizeof nome_da_variável
sizeof (nome_do_tipo)
Sintaxe 31
As Figuras 4.1, 4.2, 4.3, 4.4, 4.5 e 4.6 apresentam vários exemplos de utilização da
função printf em programas simples.
1
Input/Output: entrada/saída
34 EDITORA - UFLA-FAEPE - Introdução à Linguagem C
#include <stdio.h>
main( )
{
printf("Este é o numero dois: %d", 2);
printf("%s está a %d milhões de milhas \n do sol", "Vênus", 67);
}
#include <stdio.h>
main( )
{
printf("\n%2d",350);
printf("\n%4d",350);
printf("\n%6d",350);
}
#include <stdio.h>
main( )
{
printf("\n%4.2f", 3456.78);
printf("\n%3.2f", 3456.78);
printf("\n%3.1f", 3456.78);
printf("\n%10.3f", 3456.78);
}
#include <stdio.h>
main( )
{
printf("\n%10.2f %10.2f %10.2f", 8.0, 15.3, 584.13);
printf("\n%10.2f %10.2f %10.2f", 834.0, 1500.55, 4890.21);
}
#include <stdio.h>
main( )
{
printf("\n%04d", 21);
printf("\n%06d", 21);
printf("\n%6.4d", 21);
printf("\n%6.0d", 21);
}
#include <stdio.h>
main( )
{
printf("%d %c %x %o\n", ’A’, ’A’, ’A’, ’A’);
printf("%c %c %c %c\n", ’A’, 65, 0x41, 0101);
}
A lista de argumentos deve consistir nos endereços das variáveis. C oferece um ope-
rador para tipos básicos chamado operador de endereço e referenciado pelo símbolo & que
retorna o endereço do operando. Um exemplo de programa que utiliza a função scanf é
visto na Figura 4.7.
Operador de endereço &:
A memória do computador é dividida em bytes, e são numerados de 0 até o limite
da memória. Estas posições são chamadas de endereços. Toda variável ocupa uma certa
localização na memória, e seu endereço é o primeiro byte ocupado por ela.
36 EDITORA - UFLA-FAEPE - Introdução à Linguagem C
#include <stdio.h>
main( )
{
int num;
printf("Digite um número: ");
scanf("%d",&num);
printf("\no número é %d",num);
printf("\no endereço e %u",&num);
}
#include <stdio.h>
main( )
{
char ch;
ch = getchar();
printf("%c \n",ch);
}
Essa função escreve na tela o argumento de seu caractere na posição corrente. Veja
um exemplo na Figura 4.9.
Há inúmeras outras funções de manipulação de char complementares às que foram
vistas, como isalpha(), isupper(), islower(), isdigit(), isspace(), toupper(), tolower().
Funções Básicas da Biblioteca C 37
# include <stdio.h>
main( )
{
char ch;
printf("digite uma letra minúscula : ");
ch = getchar( );
putchar(toupper(ch));
putchar(’\n’);
}
5.1 IF
Sintaxe:
if (condição) comando;
else comando;
#include <stdio.h>
main( )
{
int a,b;
printf("digite dois números:");
scanf("%d%d",&a,&b);
if (b) printf("%d\n",a/b);
else printf("divisão por zero\n");
}
No exemplo da Figura 5.1, são pedidos dois números inteiros, a e b, e depois será
impresso o valor a/b somente se b for diferente de zero. Se b for igual a zero, será indicada
condição falsa para o comando if, e será executado o comando alternativo (else), sendo
impressa a mensagem de erro.
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
main( )
{
int num,segredo;
srand(time(NULL));
segredo = rand( )/100;
printf("Qual e o numero: ");
scanf("%d",&num);
if (segredo == num)
{
printf("Acertou!");
printf("\nO numero e %d\n", segredo);
}
else printf ("Errou, tente outra vez! \n");
}
Na Figura 5.1, havia apenas uma instrução a ser executada após a verificação do
comando if, portanto, não era necessário utilizar-se chaves. Na Figura 5.2, havia um bloco
de dois comandos a serem executados após o if, portanto, este conjunto de instruções deve
ser escrito dentro de um bloco que inicia com abre-chaves e finaliza com fecha-chaves.
5.2 IF-ELSE-IF
Sintaxe:
if (condição) comando;
else if (condição) comando;
Em uma estrutura if-else-if são colocadas várias opções que serão testadas uma de
cada vez, começando pela 1 e continuando a testar até que seja encontrada uma expressão
cujo resultado seja diferente de zero. Neste caso o programa executa a declaração corres-
pondente. Só uma declaração será executada, ou seja, só será executada a declaração
equivalente à primeira condição que for diferente de zero. A última declaração (default) é a
que será executada no caso de todas as condições serem falsas e é opcional.
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
main( )
{
int num,segredo;
srand(time(NULL));
segredo = rand( )/100;
printf("Qual e o numero: ");
scanf("%d", &num);
if (segredo == num)
{
printf("Acertou!");
printf("\nO numero e %d\n", segredo);
}
else if (segredo < num) printf ("Errado, muito alto!\n");
else printf ("Errado, muito baixo!\n");
}
#include <stdio.h>
main( )
{
int x, y, max;
printf("Entre com dois números: ");
scanf("%d, %d", &x, &y);
max = (x>y) ? x : y;
printf("max = %d\n", max);
}
5.4 SWITCH
Sintaxe:
switch(variável){
case constante1:
seqüência de comandos;
break;
case constante2:
seqüência de comandos;
break;
default:
seqüência de comandos;
}
#include <stdio.h>
main ( )
{
char x;
printf("1. Inclusão \n");
printf("2. Alteração \n");
printf("3. Exclusão \n");
printf(" Digite sua opção: ");
x = getchar( );
switch(x) {
case ’1’:
printf("escolheu inclusão\n");
break;
case ’2’:
printf("escolheu alteração\n");
break;
case ’3’:
printf("escolheu exclusão\n");
break;
default:
printf("opção inválida\n");
}
}
conjunto de comandos por um número pré determinado de vezes. As Figuras 5.6 e 5.7
apresentam dois exemplos simples de utilização do comando de repetição for.
O for é o primeiro de uma série de três comandos para se trabalhar com loops (laços
de repetição). Os outros são o while e o do-while. Os três compõem a segunda família
de comandos de controle de fluxo. Podemos pensar nesta família como sendo a dos
comandos de repetição controlada.
Em sua forma mais simples, a incialização é um comando de atribuição que o compi-
lador usa para estabelecer a variável de controle do loop. A condição é uma expressão de
relação que testa a variável de controle do loop contra algum valor para determinar quando
o loop terminará. O incremento define a maneira como a variável de controle do loop será
alterada cada vez que o computador repetir a seqüência de comandos.
O comando for executa a inicialização incondicionalmente e testa a condição. Se
a condição for falsa ele não faz mais nada. Se a condição for verdadeira ele executa a
44 EDITORA - UFLA-FAEPE - Introdução à Linguagem C
#include <stdio.h>
main( )
{
int x;
for(x=1; x<100; x++) printf("%d\n",x);
}
#include <stdio.h>
main()
{
int x, xq;
printf ("\n\t Numero Quadrado \n\n");
for(x=1; x<100; x++)
{
xq = x*x;
printf("\t %d %d \n", x, xq);
}
}
instrução (no primeiro exemplo printf) ou um bloco de instruções, faz o incremento e volta
a testar a condição. Ele fica repetindo estas operações até que a condição seja falsa.
O primeiro exemplo mostra um loop for que executa apenas um comando, e o se-
gundo exemplo executa um bloco com dois comandos, tendo, portanto, que ser escrito
entre chaves.
Uma aplicação muito utilizada para laços de repetição é para o cálculo de séries nu-
méricas. Por exemplo, o número π pode ser calculado utilizando-se a série abaixo.
1 1 1
S =1− 3
+ 3 − 3 + ···
3 5 7
Esta série é calculada para os N primeiros inteiros, sendo N um número determinado
pelo usuário. Quanto maior N, melhor a precisão obtida. Depois calcular o valor de S,
calcula-se π:
√
3
π= 32 × S
Estruturas de Controle de Fluxo 45
#include <stdio.h>
#include <math.h>
main( )
{
int N, n, sinal;
float S, x;
printf(" \n Envie o numero de termos ");
scanf(" %d ",&N);
S = 1;
x = 1;
sinal = 1;
for (n = 1; n < N; n++)
{
x +=2;
sinal = sinal;
S = S + (float)sinal/(x*x*x);
}
S = exp((1./3)*log(32*S));
printf("\n\n O valor de PI eh %f, para os %d", S, N);
printf("primeiros termos \n");
}
No exemplo apresentado na Figura 5.8, as funções exp() e log() fazem parte da bi-
blioteca math.h e são utilizadas para se calcular uma exponencial be . Neste caso b = 32*S
e e = 1./3. Observe que é necessário colocar-se o ponto depois de 1, na fração, para que
o resultado seja um número em ponto flutuante, caso contrário será calculado o quociente
inteiro de 1/3 que resulta no valor zero.
A linguagem C permite que se utilize mais de uma variável no controle do laço de
repetição for. É permitido também omitir-se qualquer um dos elementos do for, isto é, se
não quisermos uma inicialização, por exemplo, poderemos omiti-la. Vejamos os exemplos
das Figuras 5.9 e 5.10.
1
Versões recentes do GCC requerem que o parâmetro -lm seja passado quando o programa utiliza a
biblioteca math.h: gcc -lm pi.c -o pi
46 EDITORA - UFLA-FAEPE - Introdução à Linguagem C
#include <stdio.h>
main( )
{
int x,y;
for (x = 0, y = 0; x+y<100; ++x,++y) printf("%d ", x+y);
}
Um uso interessante para o for é o loop infinito, como nenhuma das três definições
são obrigatórias, podemos deixar a condição em aberto, como visto na Figura 5.10. Outra
forma usual do for é o for aninhado, ou seja, um for dentro de outro, como visto nas
Figuras 5.11 e 5.12.
#include <stdio.h>
main( )
{
for ( ; ; ) printf ("loop infinito\n");
}
#include <stdio.h>
main( )
{
int linha,coluna;
for(linha=1; linha<=24; linha++)
{
for(coluna=1; coluna<40; coluna++) printf("-");
putchar(’\n’);
}
}
#include<stdio.h>
main( )
{
int i, j, k, temp;
printf("\t i i^2 i^3 i^4 \n");
for ( i=1;i<10; i++) /* laço externo: define o numero base */
{
for ( j=1; j<5; j++) /* primeiro nível do aninhamento */
{
temp = 1;
for ( k=0; k<j; k++) /* laço mais interno: eleva a j */
{
temp = temp*i;
}
printf("%9d",temp);
}
printf("\n");
}
}
Figura 5.12: Programa que exibe uma tabela das quatro primeiras potências dos números de 1 a 9
5.6 WHILE
# include <stdio.h>
main( )
{
char ch;
while (ch != ’a’) ch = getchar( );
}
#include <stdio.h>
main( )
{
int x, xq;
printf ("\n\t Numero Quadrado \n\n");
x = 1;
while (x < 100)
{
xq = x*x;
printf("\t %d %d \n", x, xq);
x++;
}
}
5.7 DO-WHILE
Sintaxe:
do
{comando; }
while(condição);
Também executa comandos repetitivos, mas neste caso, a condição só será testada
depois que o conjunto de instruções tiver sido executado pelo menos uma vez. As Figu-
ras 5.15 e 5.16 apresentam exemplos de utilização do laço do-while.
A principal diferença entre os comandos while e do-while é que no segundo o con-
junto de instruções do bloco deverá ser executado pelo menos uma vez, obrigatoriamente,
enquanto no primeiro (while) pode acontecer do bloco de instruções não ser executado
nenhuma vez.
Estruturas de Controle de Fluxo 49
#include <stdio.h>
main( )
{
int x, xq;
printf ("\n\t Numero Quadrado \n\n");
x = 1;
do {
xq = x*x;
printf("\t %d %d \n", x, xq);
x++;
}
while (x <100);
}
5.8 BREAK
Quando o comando break é encontrado em qualquer lugar do corpo do for, ele causa
seu término imediato. O controle do programa passará então imediatamente para o código
que segue o loop. Veja o exemplo da Figura 5.17.
5.9 CONTINUE
Algumas vezes torna-se necessário “saltar” uma parte do programa, para isso utiliza-
mos o continue. O comando continue força a próxima iteração do loop — pula o código
que estiver em seguida. Um exemplo é apresentado na Figura 5.18.
50 EDITORA - UFLA-FAEPE - Introdução à Linguagem C
# include <stdio.h>
main( )
{
char ch;
printf("1. inclusão\n");
printf("2. alteração\n");
printf("3. exclusão\n");
printf("4. sair\n");
printf(" Digite sua opção:");
do {
ch=getchar();
switch(ch)
{
case ’1’: printf("escolheu inclusao\n"); break;
case ’2’: printf("escolheu alteracao\n"); break;
case ’3’: printf("escolheu exclusao\n"); break;
case ’4’: printf("sair\n");
}
}
while(ch != ’1’ && ch != ’2’ && ch != ’3’ && ch != ’4’);
}
main( )
{
char ch;
for( ; ; )
{
ch = getchar( );
if (ch == ’a’) break;
}
}
# include <stdio.h>
main( )
{
int x;
for(x = 0; x<100; x++)
{
if (x%2) continue;
printf ("%d\n", x);
}
}
A matriz é um tipo de dado usado para representar uma certa quantidade de variáveis
que são referenciadas pelo mesmo nome. Consiste em locações contíguas de memória. O
endereço mais baixo corresponde ao primeiro elemento. A matriz é um conjunto ordenado
de dados que possuem o mesmo tipo.
float exemplo[20];
o C irá reservar 4 × 20 = 80 bytes. Estes bytes são reservados de maneira contígua. Neste
exemplo, os dados serão indexados de 0 a 19. Para acessá-los escrevemos:
exemplo[0]
exemplo[1]
.
.
exemplo[19]
exemplo[30]
exemplo[103]
54 EDITORA - UFLA-FAEPE - Introdução à Linguagem C
Por quê? Porque o C não verifica se o índice que você usou está dentro dos limites
válidos. Este é um cuidado que o programador deve tomar. Se o programador não tiver
atenção com os limites de validade para os índices ele corre o risco de ter dados sobres-
critos ou de ver o computador travar. Vários erros sérios (bugs) terríveis podem surgir. As
Figuras 6.1, 6.2 e 6.3 apresentam programas que utilizam matrizes unidimensionais.
#include <stdio.h>
main( )
{
int x[10];
int t;
for(t=0;t<10;t++)
{
x[t] = t*2;
printf ("%d\n", x[t]);
}
}
Os vetores de dados podem ser inicializados como os dados de tipos simples, mas
somente como variáveis globais. Quando for inicializar uma matriz local sua classe deve
ser static. Veja um exemplo na Figura 6.5.
A verificação de limites não é feita pela linguagem, nem mensagem de erros são
enviadas, o programa tem que testar os limites das matrizes. Na Figura 6.6 é apresentado
Matrizes 55
#include <stdio.h>
main ( )
{
int num[100];
int count=0;
int totalnums;
do
{
printf ("\nEntre com um numero (-999 p/ terminar): ");
scanf ("%d",&num[count]);
count++;
}
while (num[count-1] != -999);
/* verifica quantos números foram digitados */
totalnums = count -1;
/* retira a contagem do número 999 */
printf ("\n\n\n\t Os números que você digitou foram:\n\n");
for (count = 0; count < totalnums; count++)
printf (" %d", num[count]);
}
#include <stdio.h>
main( )
{
int notas[5], i, soma;
for (i = 0; i<5; i++)
{
printf("Digite a nota do aluno %d: ", i );
scanf("%d", ¬as[i] );
}
soma = 0;
for( i = 0; i<5; i++) soma = soma + notas[i];
printf("Media das notas: %d.", soma/5);
}
# include <stdio.h>
main ( )
{
int x[10][10];
int t, p=0;
for( t = 0; t<10; t++,p++)
{
x[t][p] = t*p;
printf("%d\n", x[t][p] );
}
}
#include <stdio.h>
main( )
{
int i;
static int x[10] ={0,1,2,3,4,5,6,7,8,9};
for(i=0; i<10; i++) printf("%d\n", x[i] );
}
um programa que causará problemas ao computador durante sua execução porque o índice
da matriz erro, dentro do laço de for, excederá o tamanho da matriz (que é 10).
# include <stdio.h>
main( )
{
int erro[10], i;
for( i = 0; i<100; i++)
{
erro[i]=1;
printf (" %d\n ", erro[i] );
}
}
Em C não existe um tipo de dado string, no seu lugar é utilizado uma matriz de
caracteres. Uma string é uma matriz tipo char que termina com ’\0’. Por essa razão uma
string deve conter uma posição a mais do que o número de caracteres que se deseja. O
caractere ’\0’ tem o código numérico 00, portanto pode-se verificar o final de uma string
procurando o valor numérico zero armazenado na matriz de caracteres. Constantes strings
são uma lista de caracteres que aparecem entre aspas, não sendo necessário colocar o ’\0’,
que é colocado pelo compilador. A Figura 7.1 mostra um programa simples para operação
com strings.
#include <stdio.h>
#include <string.h>
main( )
{
static char re[] = "lagarto";
// um vetor de caracteres de 8 posições
puts(re);
puts(&re[0]);
// uma variável do tipo matriz (ou vetor ) é referenciada
putchar(’\n’);
// como o endereço de sua primeira posição.
}
Sintaxe: gets(nome_matriz);
58 EDITORA - UFLA-FAEPE - Introdução à Linguagem C
É utilizada para leitura de uma string através do dispositivo padrão, até que a tecla
<ENTER> seja pressionada. A função gets() não testa limites na matriz em que é chamada.
A Figura 7.2 apresenta um programa simples que utiliza a função gets.
# include <stdio.h>
main()
{
char str[80];
gets(str);
printf("%s",str);
}
Sintaxe: puts(nome_do_vetor_de_caracteres);
Escreve o seu argumento no dispositivo padrão de saída (vídeo), coloca um ’\n’ no fi-
nal. Reconhece os códigos de barra invertida. A Figura 7.3 apresenta um programa simples
que utiliza a função puts.
# include <stdio.h>
# include <string.h>
main()
{
puts("mensagem");
}
# include <stdio.h>
# include <string.h>
main()
{
char str[20];
strcpy(str,"alo");
puts(str);
}
#include <string.h>
#include <stdio.h>
main()
{
char um[20], dois[10];
strcpy (um, "bom");
strcpy (dois," dia");
strcat (um, dois); // une a string dois à string um
printf ("%s\n", um);
}
main( )
{
char s[80];
printf("Digite a senha:");
gets(s);
if (strcmp(s,"laranja")) printf("senha inválida\n");
else printf("senha ok!\n") ;
}
tipo_do_ponteiro *nome_da_variável;
É o asterisco (*) que faz o compilador saber que aquela variável não vai guardar um
valor mas sim um endereço para aquele tipo especificado. Vamos ver exemplos de decla-
rações:
int *pt;
char *temp, *pt2;
que é apenas declarada). Isto significa que eles apontam para um lugar indefinido. Este
lugar pode estar, por exemplo, na porção da memória reservada ao sistema operacional do
computador. Usar o ponteiro nestas circunstâncias pode levar a um travamento do micro, ou
a algo pior. O ponteiro deve ser inicializado (apontado para algum lugar conhecido) antes
de ser usado! Isto é de suma importância!
Para atribuir um valor a um ponteiro recém-criado poderíamos igualá-lo a um valor de
memória. Mas, como saber a posição na memória de uma variável do nosso programa?
Seria muito difícil saber o endereço de cada variável que usamos, mesmo porque estes
endereços são determinados pelo compilador na hora da compilação e relocados na exe-
cução. Podemos então deixar que o compilador faça este trabalho por nós. Para saber o
endereço de uma variável basta usar o operador &. Veja o exemplo:
int count;
int *pt;
pt = &count;
Desde que os ponteiros são variáveis, eles podem ser manipulados tal como as variá-
veis. Se py e px são ponteiros para inteiros, então podemos fazer a declaração:
py = px;
A Figura 8.1 apresenta um programa que exemplifica a utilização de ponteiros para
acessar um variável x.
Ponteiros 63
#include <stdio.h>
main( )
{
int x,*px,*py;
x = 9;
px = &x;
py = px;
printf("x= %d\n",x);
// imprime o valor de x
printf("&x= %d\n",&x);
// endereço da variável x, que é igual ao conteúdo de px
printf("px= %d\n",px);
// valor de px, que é o endereço de x
printf("*px= %d\n",*px);
// conteúdo da variável apontada por px, isto é, valor de x
printf("*py= %d\n",*py);
// imprime valor de x, pois py = px
}
No exemplo da Figura 8.2, os parênteses são necessários, pois sem eles px seria
incrementado em vez do conteúdo que é apontado, porque os operadores * e ++ são avali-
ados da direita para esquerda.
# include <stdio.h>
main()
{
int x, *px;
x = 1;
px = &x;
printf("x= %d\n", x);
printf("px= %u\n", px);
printf("*px+1= %d\n", *px+1);
printf("px=%u\n", px);
printf("*px= %d\n", *px);
printf("*px+=1= %d\n", *px+=1);
printf("px= %u\n",px);
printf("(*px)++=%d\n", (*px)++);
printf("px= %u\n",px);
printf("*(px++)= %d\n", *(px++));
printf("px= %u\n",px);
printf("*px++-=%d\n", *px++);
printf("px= %u\n", px);
}
Um ponteiro para um ponteiro é uma forma de indicação múltipla. Num ponteiro nor-
mal, seu valor é o endereço da variável desejada. Quando se trata de ponteiros para pon-
teiros, o primeiro ponteiro contém o endereço do segundo, que aponta para a variável de-
sejada. A Figura 8.3 apresenta um programa exemplo.
# include <stdio.h>
main( )
{
int x,*p,**q;
x=10;
p=&x;
q=&p;
printf("%d",**q);
}
int *p;
x = 10;
*p = x;
Neste trecho de programa, o ponteiro p não foi inicializado, não recebeu nenhum
endereço, portanto o valor 10 foi colocado em uma posição aleatória e desconhecida de
memória. A conseqüência desta atribuição é imprevisível.
66 EDITORA - UFLA-FAEPE - Introdução à Linguagem C
9
PONTEIROS E MATRIZES
nome_da_variável[índice]
Isto pode ser facilmente explicado desde que você entenda que a notação acima é
absolutamente equivalente a se fazer:
*(nome_da_variável+índice)
pa = &a[0];
/*passa o endereço inicial do vetor a para o ponteiro pa */
pa = a;
/* é a mesma coisa de pa=&a[0];*/
x = *pa;
/*passa o conteúdo de a[0] para x */
# include <stdio.h>
main( )
{
int i = 0;
char t[10];
static char s[ ] = "abobora";
while (t[i] = s[i]) i++;
printf("%s\n",t);
}
# include <stdio.h>
main( )
{
char *ps,*pt, t[10], s[10];
strcpy (s,"abobora");
ps = s;
pt = &t[0];
while(*ps) *pt++ = *ps++;
printf("%s", t );
}
Sendo um ponteiro para caractere char *texto, podemos atribuir uma constante string
para texto, que não é uma cópia de caracteres, somente ponteiros são envolvidos. Neste
caso a string é armazenada como parte da função em que aparecem, ou seja, como cons-
tante. Um exemplo é visto na Figura 9.3.
#include <stdio.h>
main( )
{
char *al = "conjunto";
char re[ ] = "simples";
puts (al);
puts (&re[0]); /* ou puts(re); */
for( ; al; al++) putchar(*al);
putchar(’\n’);
}
int *x[10];
Para atribuir o endereço de uma variável inteira chamada var ao terceiro elemento da
matriz de ponteiros pode-se fazer um comando de atribuição simples:
x[2] = &var;
Neste caso, a matriz x contém ponteiros para variáveis inteiras, e o endereço da va-
riável var foi armazenado na posição 2 da matriz de ponteiros (x). Para verificar o conteúdo
de var pode-se utilizar o ponteiro armazenado em x:
*x[2];
#include <stdio.h>
main( )
{
char *erro[2];
erro[0] = "arquivo nao encontrado\n";
erro[1] = "erro da leitura\n";
for( ;*erro[0]; ) printf("%c", *erro[0]++);
}
Uma função é uma unidade autônoma de código do programa e é projetada para cum-
prir uma tarefa particular. Geralmente os programas em C consistem em várias pequenas
funções. A declaração do tipo da função é obrigatória no GCC. Os parâmetros de recepção
de valores devem ser separados por vírgulas.
Sintaxe: tipo nome(parâmetros){ comandos}
Uma função pode retornar apenas um valor para o programa que a chamou, e este
valor deve ser do tipo especificado no cabeçalho da função, é o tipo da função. O nome
da função deverá sempre iniciar com uma letra, e normalmente é escrito em minúsculas. Às
vezes, os programadores iniciantes usam nomes com letras maiúsculas para não correrem
o risco de usar nome igual ao de alguma função já definida em alguma biblioteca existente
no compilador que está sendo usado. Por exemplo, pode-se definir uma função com o nome
Printf, escrita com P maiúsculo, para diferenciar da função printf da biblioteca stdio.h. Os
parâmetros são valores de variáveis que serão passados pelo programa para a função.
Além da variável de retorno nenhum outro valor pode ser retornado pela função para o
programa que a chamou.
Quando uma função não retorna um valor para a função que a chamou ela é declarada
como void. No exemplo da Figura 10.1 a função inverso escreve a string vet em ordem
reversa (do último para o primeiro caracter).
Quando o código da função é escrito após a linha de comando que a chamará pela
primeira vez, deve-se escrever uma linha de anúncio da existência desta função, antes do
início da função main. Este anúncio de função é chamado de protótipo. Na verdade o
protótipo pode ser colocado em outro lugar, desde que seja antes da primeira chamada à
função.
A Figura 10.2 apresenta um outro exemplo de função sem retorno.
72 EDITORA - UFLA-FAEPE - Introdução à Linguagem C
#include <stdio.h>
void inverso(char *s ); /* protótipo de função */
main( )
{
char *vet = "abcde";
inverso(vet);
}
Figura 10.1: Inversão de uma string usando uma função que recebe um ponteiro
Quando o programador quiser que a função envie um valor para o programa que
a chamou, ele deverá declarar um tipo diferente de void para a função. A Figura 10.3
apresenta um exemplo de programa que utiliza uma função que recebe dois valores inteiros
(base, expoente) e retorna um inteiro (i) que é igual à base elevada ao expoente.
Observe que no loop for da função elevado não foi feita a inicialização da variável de
controle, mas esta variável é o expoente que já foi passado como parâmetro. O loop vai
parar de ser executado quando a variável expoente atingir o valor zero, que funciona como
o valor lógico falso.
A função elevado da Figura 10.3 modifica o valor da variável expoente que lhe foi
passada pela função main, mas esta modificação não afeta a variável e da função main,
pois expoente é apenas uma cópia de e, e as variáveis de uma função só existem dentro
desta, não sendo reconhecidas por outra função.
Quando uma função utiliza argumentos, então ela deve declarar as variáveis que acei-
taram os valores dos argumentos, sendo essas variáveis os parâmetros formais. Veja um
Funções 73
#include<stdio.h>
void code (char *s);
main( )
{
char letras[26];
printf("\n\n Insira uma frase a ser codificada ");
printf("(máximo de 25 caracteres). \n");
scanf("%s", letras);
code( letras );
}
void code( char *s ) /* Codifica as letras */
{
char ch;
do
{
ch = *s++;
printf("%c", ch+1); /* desloca o alfabeto uma posição */
} while(ch);
}
exemplo na Figura 10.4, onde são declarados os parâmetros formais string, um ponteiro
que contém o endereço do início de uma string, e caractere, uma variável do tipo char.
A função pertence neste exemplo vai procurar um certo caractere dentro de uma
string. Se for encontrado, retorna o valor 1, senão, retorna 0.
Quando se deseja que uma função modifique valores das variáveis do programa que
a chamou, deve-se passar para a função não a variável, mas o seu endereço na memória
do computador. Isto é feito utilizando-se ponteiros. No exemplo da Figura 10.6 a função
74 EDITORA - UFLA-FAEPE - Introdução à Linguagem C
#include <stdio.h>
int elevado(int base, int expoente );
main( )
{
int b,e;
printf("Digite a base e expoente x, y : ");
scanf("%d,%d", &b, &e);
printf("valor = %d\n", elevado(b,e));
}
int elevado(int base, int expoente)
// são passados dois inteiros como parâmetros
{
int i;
if ((expoente<0) || (!base)) return 0;
i =1;
for( ; expoente; expoente--) i = base*i;
return i; // retorna o inteiro i para a função main
}
Uma função pode chamar outras funções, mas o código que compreende o corpo de
uma função (bloco entre { }) está escondido do resto do programa, ele não pode afetar nem
ser afetado por outras partes do programa, a não ser que o código use variáveis globais.
Existem três classes básicas de variáveis: locais, estáticas e globais.
Funções 75
#include <stdio.h>
int Sqr( int x );
main( )
{
int t =10;
printf("%d eh o quadrado de %d", Sqr(t),t);
}
int Sqr(int x)
{
x = x*x; /* Modificação no valor de x não altera t */
return(x);
}
#include <stdio.h>
void troca (int *a, int *b );
main( )
{
int x=10, y=20;
troca(&x,&y);
printf("x=%d y=%d\n", x, y);
}
void troca (int *a, int *b)
// *a e *b são ponteiros que recebem os endereços de x e y
{
int temp;
temp = *a;
*a = *b;
*b = temp;
}
As variáveis que são declaradas dentro de uma função são chamadas de locais. Na
realidade todas as variáveis declaradas dentro de um bloco { } podem ser referenciadas
apenas dentro deste bloco. Elas existem apenas durante a execução do bloco de código
no qual estão declaradas. O armazenamento de variáveis locais por default é feito na pilha,
76 EDITORA - UFLA-FAEPE - Introdução à Linguagem C
assim sendo uma região dinâmica. A Figura 10.7 apresenta um exemplo de função que
utiliza variáveis locais.
#include <stdio.h>
void linha (int x);
main( )
{
int tamanho;
printf ("Digite o tamanho: ");
scanf ("%d", &tamanho);
linha (tamanho);
}
void linha(int x)
{
int i;
for( i = 0; i <= x; i++) putchar(95);
/* A variável i na função linha
não é reconhecida pela função main.*/
}
São conhecidas por todo programa e podem ser usadas em qualquer parte do código.
Permanecem com seu valor durante toda execução do programa. Deve ser declarada fora
de qualquer função e até mesmo antes da declaração da função main. Fica numa região
fixa da memória própria para esse fim. Um exemplo é visto na Figura 10.8.
Sendo a variável cont declarada fora de qualquer função do programa, ela será uma
variável global, sendo, portanto reconhecida pelos três blocos de programa (main, func1,
func2). A modificação do valor de cont em func2, resulta na modificação do mesmo cont
em func1. Logo, func1 irá escrever o valor 109 (e não 100) para cont.
# include <stdio.h>
void func1( ), func2( );
int cont;
main( )
{
cont = 100;
func1( );
}
void func1( )
{
int temp;
temp = cont;
func2( );
printf ("temp é = %d", temp);
printf ("cont é = %d", cont);
}
void func2( )
{
int cont;
for(cont =1; cont<10; cont++) printf(" . ");
}
#include <stdio.h>
main( )
{
int i;
static int x[10] = {0,1,2,3,4,5,6,7,8,9};
for(i=0; i<10; i++) printf (" %d \n ", x[i]);
}
e que queiramos passá-la como argumento de uma função func(). Podemos declarar
func() das três maneiras seguintes:
Veja que, nos três casos, teremos dentro de func() um int* chamado matrx. Note que,
no caso de estarmos passando uma matriz para uma função, teremos de passá-la através
de um ponteiro. Isto faz com que possamos alterar o valor desta matriz dentro da função.
A Figura 10.10 apresenta um exemplo de função que trabalha com uma matriz.
#include <stdio.h>
void mostra (int num[ ] );
main( )
{
int t[10], i;
for ( i = 0; i < 10; i++) t[i] = i;
mostra(t);
}
void mostra ( int num[ ] )
{
int i;
for( i = 0; i < 10; i++ ) printf ("%d", num[i]);
}
A função mostra, da Figura 10.10, poderia ter sido escrita utilizando-se um ponteiro
na passagem de parâmetros, conforme se vê na Figura 10.11.
Funções 79
Figura 10.11: Função que opera sobre uma matriz utilizando um ponteiro
A Figura 10.12 apresenta um exemplo de função que recebe dois ponteiros como
argumentos e retorna um inteiro. Ela retorna o índice de início de uma substring dentro de
uma string ou -1, se nenhuma correspondência for encontrada. Verifique que existem duas
declarações return, o que é perfeitamente possível em C, visto que a função terminará
quando passar pela primeira linha contendo return. Sem o uso da segunda declaração
return, uma variável temporária e código extra precisariam ser usados.
Figura 10.12: Função que procura uma substring dentro de uma string
80 EDITORA - UFLA-FAEPE - Introdução à Linguagem C
#include <stdio.h>
void maiusc (char *string );
main( )
{
char s[80];
gets(s);
maiusc(s);
}
void maiusc (char *string)
{
register int t;
for( t = 0; string[t]; t++)
{
string[t] = toupper ( string[t] );
printf ("%c", string[t] );
}
}
#include <stdio.h>
int main( int argc, char *argv[ ] )
{
if (argc != 2)
{
printf("falta digitar o nome\n");
exit(0);
}
printf("alo %s", argv[1]);
}
Este programa, depois de compilado, deverá ser chamado na linha de comando como
NomePrograma NomeUsuário. Então ele escreverá na tela do computador a mensagem:
“alo NomeUsuário”.
O programa da Figura 11.2 deve ser chamado na linha de comando como NomePro-
grama 3 display, para que seja apresentada na tela a contagem 3, 2, 1, e seja emitido um
sinal sonoro (o correspondente ASCII do número 7). Se não for digitado o número 3 e a
palavra display, a contagem não será apresentada.
82 EDITORA - UFLA-FAEPE - Introdução à Linguagem C
#include <stdio.h>
int main( int argc, char *argv[ ] )
{
int disp, cont;
if (argc<2)
{
printf("falta digitar o valor para contagem\n");
exit(0);
}
if (argc==3 && !strcmp(argv[2],"display")) disp = 1;
else disp = 0;
for(cont = atoi( argv[1] ); cont; --cont)
if(disp) printf("%d", cont);
printf("%c", 7);
}
12.1 ESTRUTURAS
Ao manusearmos dados muitas vezes deparamos com informações que não são fá-
ceis de armazenar em variáveis escalares como são os tipos inteiros e pontos flutuantes,
mas na verdade são conjuntos de coisas. Este tipo de dados são compostos com vários
dos tipos básicos do C. As estruturas permitem uma organização dos dados dividida em
campos e registros. Para se acessar cada elemento de uma estrutura, escreve-se o nome
da variável que tem aquele tipo de estrutura, coloca-se um ponto e o nome do elemento que
se deseja, como no exemplo da Figura 12.1, onde se referencia cada elemento da variável
que tem a estrutura do tipo lapis.
Como ocorre com as variáveis, as estruturas também podem ser referenciadas por
ponteiros. Assim, definindo-se por exemplo o ponteiro *p para a estrutura acima (lapis),
pode-se usar a sintaxe (*p).dureza. Porém, para referenciar o ponteiro há ainda outra
sintaxe, através do operador -> , como por exemplo, p -> dureza.
12.2 UNIÕES
Uma declaração union determina uma única localização de memória onde podem
estar armazenadas várias variáveis diferentes. A declaração de uma união é semelhante à
declaração de uma estrutura:
union nome_da_union
{
tipo_1 nome_1;
tipo_2 nome_2;
...
tipo_n nome_n;
} variáveis_union;
84 EDITORA - UFLA-FAEPE - Introdução à Linguagem C
# include <stdio.h>
struct lapis { int dureza; char fabricante; int numero; };
main( )
{
int i;
struct lapis p[3], C;
C.dureza = 1;
C.fabricante = ’H’;
C.numero = 19;
p[0].dureza = 2;
p[0].fabricante = ’F’;
p[0].numero = 482;
p[1].dureza = 0;
p[1].fabricante = ’G’;
p[1].numero = 33;
p[2].dureza = 3;
p[2].fabricante = ’E’;
p[2].numero = 107;
union angulo
{
float graus;
float radianos;
};
Nela, temos duas variáveis (graus e radianos) que, apesar de terem nomes dife-
rentes, ocupam o mesmo local da memória. Isto quer dizer que só gastamos o espaço
equivalente a um único float. Uniões podem ser feitas também com variáveis de diferentes
tipos. Neste caso, a memória alocada corresponde ao tamanho da maior variável no union.
Veja o exemplo da Figura 12.3.
union numero
{
char Ch;
int I;
float F;
};
Após a declaração da union, podemos declarar as variáveis deste tipo dentro do corpo
do programa. Numa declaração como esta, em que variáveis de tipos diferentes ocupam
o mesmo espaço na memória, deve-se ter muito cuidado na sua utilização. O exemplo da
Figura 12.4 mostra como utilizar a union numero em um programa.
No programa da Figura 12.4 deve-se tomar cuidado para, quando se escrever um valor
inteiro na variável N, não tentar acessá-lo como ponto flutuante. Deve-se ter cuidado para
não se misturar os tipos de dados escritos e acessados na variável do tipo union.
12.3 ENUMERAÇÕES
#include <stdio.h>
union numero
{
char Ch;
int I;
float F;
};
main (void)
{
union numero N; // declara a variável N que é uma union numero
N.I=123;
printf ("%d",N.I);
N.F=123;
printf ("%f",N.F);
return 0;
}
#include <stdio.h>
enum dias_da_semana { Dom, Seg, Ter, Qua, Qui, Sex, Sab };
int main ( )
{
enum dias_da_semana d1,d2;
d1 = Seg;
d2 = Sex;
if (d1 == d2)
// são comparados os inteiros correspondentes a Seg e Sex
{
printf ("O dia eh o mesmo.");
}
else
{
printf ("São dias diferentes.");
}
return 0;
}
No sistema de entrada e saída ANSI é definido o tipo “ponteiro de arquivo”. Este não
é um tipo propriamente dito, mas uma definição usando o comando typedef. Esta definição
está no arquivo cabeçalho stdio.h ou stdlib.h dependendo do seu compilador. Podemos
declarar um ponteiro de arquivo da seguinte maneira:
FILE *p;
p será então um ponteiro para um arquivo. É usando este tipo de ponteiro que vamos
poder manipular arquivos no C.
O nome_do_arquivo determina qual arquivo deverá ser aberto. Este nome deve ser
válido no sistema operacional que estiver sendo utilizado. O modo de abertura diz à função
fopen() que tipo de uso você vai fazer do arquivo. A Tabela 13.1 mostra os valores de modo
válidos.
Poderíamos então, para abrir um arquivo binário, escrever:
90 EDITORA - UFLA-FAEPE - Introdução à Linguagem C
#include <stdio.h>
main ( )
{
FILE *fp;
char ch;
int nu, *pn;
pn = ν
fp = fopen("teste.dat", "w");
printf("Entre com os numeros para gravar e 0 para sair: ");
scanf("%d", &nu);
while(nu)
{
fprintf (fp,"%d ", nu);
scanf("%d", &nu);
}
fclose(fp);
fp = fopen("teste.dat", "r");
while(!feof(fp))
{
fscanf( fp,"%d ", &nu);
printf( "%d", nu);
}
}
FILE *fp;
fp = fopen ("exemplo.bin","wb");
if (!fp)
printf ("Erro na abertura do arquivo.");
A condição !fp testa se o arquivo foi aberto com sucesso porque no caso de um erro
a função fopen() retorna um ponteiro nulo (NULL).
Esta função aborta a execução do programa. Pode ser chamada de qualquer ponto
no programa e faz com que o programa termine e retorne, para o sistema operacional, o
Noções de Manipulação de Arquivos 91
Modo Significado
"r" Abre um arquivo para leitura
"w" Cria um arquivo para escrita
"a" Acrescenta dados no fim do arquivo (“append”)
"rb" Abre um arquivo binário para leitura
"wb" Cria um arquivo binário para escrita
"ab" Acrescenta dados binários no fim do arquivo
"r+" Abre um arquivo para leitura e escrita
"w+" Cria um arquivo para leitura e escrita
"a+" Acrescenta dados ou cria uma arquivo para leitura e escrita
"r+b" Abre um arquivo binário para leitura e escrita
"w+b" Cria um arquivo binário para leitura e escrita
"a+b" Acrescenta dados ou cria uma arquivo binário para leitura e es-
crita
"rt" Abre um arquivo texto para leitura
"wt" Cria um arquivo texto para escrita
"at" Acrescenta dados no fim do arquivo texto
"r+t" Abre um arquivo texto para leitura e escrita
"w+t" Cria um arquivo texto para leitura e escrita
"a+t" Acrescenta dados ou cria uma arquivo texto para leitura e escrita
É importante que se perceba que se deve tomar o maior cuidado para não se “perder”
o ponteiro do arquivo. “Perder” neste caso seria se atribuir um valor de um outro ponteiro
92 EDITORA - UFLA-FAEPE - Introdução à Linguagem C
#include <stdio.h>
main (void)
{
FILE *fp;
/* Comandos... */
/* Comandos ... */
return 0;
}
qualquer ao ponteiro de arquivo (perdendo assim o valor original). É utilizando este ponteiro
que vamos poder trabalhar com o arquivo. Se perdermos o ponteiro de um determinado
arquivo não poderemos nem fechá-lo. O ponteiro fp passado à função fclose() determina
o arquivo a ser fechado. A função retorna zero no caso de sucesso.
Além das funções fprintf e fscanf vista no exemplo inicial, outras funções existem
no padrão ANSI para se escrever e se ler em arquivos. Aqui serão citadas brevemente as
funções putc, getc, e a função feof que verifica o se o arquivo chegou ao final.
13.2.1 putc
Toda vez que estamos trabalhando com arquivos, há uma espécie de posição atual no
arquivo. Esta posição, gerenciada pelo compilador, é a posição de onde será lido ou escrito
o próximo caracter. Normalmente, num acesso seqüencial a um arquivo, não temos que
mexer nesta posição pois quando lemos um caractere a posição no arquivo é automatica-
Noções de Manipulação de Arquivos 93
mente atualizada. Num acesso randômico teremos que mexer nesta posição (ver fseek()).
Protótipo:
13.2.2 getc
Retorna um caracter lido do arquivo. Protótipo:
13.2.3 feof
EOF (“End of file”) indica o fim de um arquivo. Às vezes, é necessário verificar se um
arquivo chegou ao fim. Para isto podemos usar a função feof(). Ela retorna não-zero se o
arquivo chegou ao EOF, caso contrário retorna zero. Seu protótipo é:
#include <stdio.h>
main( )
{
int *p, t;
p=(int *) malloc(40*sizeof(int));
if (!p) printf("memoria insuficiente\n");
else
{
for(t=0; t<40; ++t) *(p+t) = t;
for(t=0; t<40; ++t) printf("%d ", *(p+t));
free(p);
}
}
#include <stdio.h>
main( )
{
int i,quant;
float max,min,*p;
printf ("quantidade de numeros:\n");
scanf("%d", &quant);
if ( !( p = (float*) malloc((quant+1)*sizeof(float))) )
{
printf ("sem memoria\n");
exit(1);
}
printf ("digite %d numeros:\n", quant);
for ( i = 1; i <= quant; i++) scanf ("%f", (p+i));
max = *(p+1);
for ( i = 2; i <= quant; i++)
{
if (*(p+i) >= max) max = *(p+i);
}
printf("O maior e :%f \n", max);
free(p);
}
15.1 CAPÍTULO 1
1. Procurar em livros e/ou guias de referência da Linguagem C quais são as funções das
seguintes bibliotecas: string.h e math.h. Anotar o nome de todas as funções com seus
respectivos tipos de retorno e seus argumentos.
2. Dizer o que fazem as seguintes funções da biblioteca stdio.h: getchar, putc, puts.
15.2 CAPÍTULO 2
1. Editar o programa da Figura 15.1 e fazer sua compilação. Executar o programa e dizer
o que ele faz.
Para escrever os dois números pedidos pelo programa, pode-se digitar o primeiro, um
espaço, digitar o segundo, e pressionar <ENTER>. Pode-se também digitar <ENTER>
após cada número.
15.3 CAPÍTULO 3
Dizer o que o programa faz. Explicar (comentar) o que faz cada linha. Explique porque
a variável Dias é inteira e Anos é float.
2. Modifique o programa anterior para que sejam requisitados o dia, o mês e o ano atuais,
o dia, o mês e o ano de nascimento do usuário, e então seja calculado e anunciado o
número de dias vivido pelo usuário.
15.4 CAPÍTULO 4
2. Modifique o programa para que todos os números sejam impressos com quatro alga-
rismos antes do ponto decimal e três algarismos após.
15.5 CAPÍTULO 5
5. O seno de um ângulo qualquer (dado em radianos) pode ser calculado pela série
abaixo.
A3 A5 A7
senA = A − 6
+ 120
− 5040
+ ···
6. Reescrever o programa anterior para que o seno do ângulo seja calculado até que o
módulo do último termo da série seja menor que 0,00001.
100 EDITORA - UFLA-FAEPE - Introdução à Linguagem C
#include<stdio.h>
main( )
{
int opcao;
int valor;
printf("Converter:\n");
printf(" 1: decimal para hexadecimal\n");
printf(" 2: hexadecimal para decimal\n");
printf(" 3: decimal para octal\n");
printf(" 4: octal para decimal\n");
printf("informe a sua opção:");
scanf("%d", &opcao);
if(opcao==1) {
printf("informe um valor em decimal:");
scanf("%d", &valor);
printf("%d em hexadecimal é : %x", valor, valor);
}
if(opcao==2) {
printf("informe um valor em hexadecimal:");
scanf("%x", &valor);
printf("%x em decimal é: %d", valor, valor);
}
if(opcao==3){
printf("informe um valor em decimal:");
scanf("%d", &valor);
printf("%d em octal é: %o", valor, valor);
}
if(opcao==4){
printf("informe um valor em octal:");
scanf("%o", &valor);
printf("%o em decimal é: %d", valor, valor);
}
}
/* Identificação de triângulos */
Início
Ler A, B, C (reais, lados do triângulos)
Se A < (B+C) e B < (A+C) e C < (A+B)
/* verifica se é triângulo */
Então
Se A = B e B = C
Então Imprima (Triângulo Equilátero)
Senão
Se A = B ou A = C ou B = C
Então Imprima (Triângulo Isóceles)
Senão Imprima (Triângulo Escaleno)
FimSe
FimSe
FimSe
Fim
15.6 CAPÍTULO 6
1. Fazer um programa em Linguagem C que leia uma matriz de dimensões NxM, e cal-
cule a sua transposta. Ao final o programa apresentará a matriz e sua transposta na
tela do computador.
15.7 CAPÍTULO 7
#include <stdio.h>
#include <string.h>
main( )
{
char st1[11], st2[11], st3[21], ch ;
int i, j;
printf ("\n Envie uma string de ate 10 caracteres ");
gets(st1);
printf ("\n Envie outra string de ate 10 caracteres ");
gets(st2);
for ( i = 0; st1[i]; i++) st3[i] = st1[i];
for ( j = 0; st2[j]; j++) st3[i+j] = st2[j];
j = j+i;
puts (st3);
for ( i = j; i ; i-- )
{
ch = st3[i-1];
putchar (ch);
putchar (’\n’);
}
puts ("\n");
}
Explique porque as strings st1 e st2 devem ter no máximo 10 caracteres se os respec-
tivos vetores foram declarados com 11 posições.
15.8 CAPÍTULOS 8 E 9
2. Refazer o programa do cálculo das médias dos alunos, Capítulo 6 (Figura 6.3, utili-
zando ponteiros para o cálculo das médias e para a apresentação dos resultados.
Exercícios 103
15.9 CAPÍTULO 10
1. Fazer uma função em C que concatena duas strings. Utilize o nome StrCat para esta
função, para não confundir com como strcat() da biblioteca string.h.
#include <stdio.h>
#include <math.h>
main( )
{
float r,res;
printf("Informe o raio: ");
scanf("%f", &r);
res=area(r);
printf("A área é: %f\n", res);
}
4. Modifique o programa anterior para que ele repita os cálculo para diferentes raios
enviados pelo usuário. Deverá ser utilizado um loop do-while onde, ao final será per-
guntado ao usuário se deseja novo cálculo. O loop será repetido até que o usuário
responda N (não).
5. Fazer uma função em C que calcule o fatorial de um número passado como parâmetro.
15.10 CAPÍTULO 11
15.11 CAPÍTULO 12
15.12 CAPÍTULO 13
15.13 CAPÍTULO 14
[4] PLAUGER, P.J. e BRODIE J. Standart C: guia de referência básica, São Paulo,
Mcgraw-Hill, 1991. 306p.
[5] HANCOCK, Les e KRIEGER, Morris. Manual de Linguagem C, Rio de Janeiro, Cam-
pus,1985. 182p.
[7] CHILDT, Herbert. Turbo C: Guia do Usuário, São Paulo, McGraw-Hill, 1988, 414p.