Conteúdo - Prática de Programação

Constantes e Operadores em C
Apresentar os seguintes conceitos da linguagem C: constantes, operadores de

incremento e decremento, operadores aritméticos de atribuição e operador ternário
de decisão.
NESTE TÓPICO
NESTE TÓPICO
Constantes
Operadores Aritméticos de Atribuição

Exemplo 1
Exemplo 2
Referências
Marcar
tópico

Constantes
Constantes são dados que não sofrem nenhuma variação no decorrer do programa,
assim como é o mesmo para execuções diferentes no tempo. Podemos usar dados
constantes, por exemplo, em uma fórmula:
area = 3.1415 * (raio * raio);
Em linguagem C ao invés de usarmos o valor constante diretamente, podemos
associar um nome (identificador) a esse valor e no lugar do valor usar o nome
associado. Isso é conhecido como constante simbólica. O uso de um nome a um
valor constante aumenta a legibilidade do código-fonte e facilita a sua manutenção.
Para criarmos constantes simbólicas utilizamos a diretiva #define. Ela associa um
identificador a um texto da seguinte forma:
#define identificador texto
Quando o compilador da linguagem C encontra uma ocorrência do identificador
especificado ele substitui pelo texto associado.
As constantes simbólicas sempre devem ser especificadas no início do programa,
antes da função main(). Podemos especificar quantas constantes simbólicas
quisermos, sendo uma em cada linha, sem o ponto-e-vírgula no final.
O programa a seguir apresenta um exemplo de uso de constante simbólica. Ele lê o
valor do raio de uma circunferência, calcula e apresenta a área desta
circunferência. A fórmula é:
Sendo o valor de equivalente a 3,1415.
No programa, utilizamos uma constante simbólica (PI) para representar o valor
de ao invés de colocarmos o valor diretamente na fórmula, como feito na fórmula
apresentada no início desse texto. Embora não seja obrigatório, mas por estilo de
codificação, os identificadores de constantes simbólicas são definidos usando
letras maiúsculas. Com isso, podemos facilmente diferenciá-las das variáreis que
por convenção são definidas em letras minúsculas.
1. #include <stdio.h>
2. #include <stdlib.h>
3. // especificação da constante simbolica para o valor de Pi
4. #define PI 3.1415
5. main () {
6. // le o raio da circunferencia
7. float raio;
8. printf ("Raio: ");
9. scanf ("%f", &raio);
10. // calcula a area. Aqui usamos a constante simbolica especificada
11. float area = PI * (raio * raio);
12. // apresenta o valor da area
13. printf ("Area = %.2f\n\n", area);
14. system ("PAUSE");
15. }

Quando codificamos programa, frequentemente temos a necessidade de
escrevermos expressões na forma
variável = variável operador expressao.
Para facilitar, a linguagem C oferece um grupo de operadores que permite escrever
essas expressões de forma mais compacta. Os operadores aritméticos de atribuição
combinam, num único operador, uma operação aritmética e uma atribuição.
A forma geral é:
variavel op= expressao;
Que equivale a:
variavel = variável op (expressao);
Exemplos:
i += 2; equivale a i = i + 2;
x *= y + 1; equivale a x = x * (y + 1);
a %= b – c; equivale a a = a % (b – c);
A tabela abaixo apresenta expressões aritméticas e a sua forma compacta,
utilizando os operadores aritméticos de atribuição.

Expressão Forma Compacta
x=x+y x += y
x=x-y x -= y
x=x*y x *= y
x=x/y x /= y
x=x%y x %= y

Se uma expressão incrementa ou decrementa em 1 o valor de uma variável,
podemos então escrevê-la de uma forma ainda mais compacta. Para incrementar
usamos o operador ++ e para decrementar usamos o operador --. Esses operadores
são unários, isto é, atuam sobre uma única variável, e podemos usá-los de duas
formas:
 Forma prefixa: ++variavel, --variavel
 Forma posfxa: variavel++, variavel--
O trecho de código a seguir apresenta um exemplo de utilização dos operadores de

incremento e decremento.
A saída produzida pelo trecho de código será x = 6 y = 4.
1. ....
2. int x = 5, y = 5;
3. ++x;
4. --y;
5. printf ("x = %d y = %d", x, y);
6. ....
A diferença entre usar o operador na forma prefixa ou posfixa aparece somente

quando ele é utilizado em uma expressão. Na forma prefixa, a variável é alterada e,
depois, o seu valor é usado. Na forma posfixa, o valor da variável é usado e,
depois, ela é alterada. Para verificarmos a diferença, analise o trecho de código a
seguir.
A saída produzida pelo trecho de código será:
m=6
x=5
n=6
y=6
Os operadores de incremento e decremento não podem ser usados com valores
constantes, já que a instrução x++ equivale, de certa forma, a x = x + 1.
1. if (num > 0) {
2. abs = num;
3. }
4. else {
5. abs = -num;
6. }
Embora o operador ternário de decisão e o comando if-else sejam semelhantes, eles

não são iguais. O comando if-else indica quais as instruções se deve executar,
enquanto o operador ternário de decisão devolve sempre um resultado. Uma
vantagem do uso desse operador é que podemos utilizá-lo em qualquer contexto
em que uma expressão é permitida.
O programa a seguir apresenta um exemplo de utilização do operador ternário de
decisão. Ele lê um salário e calcula o seu reajuste. Se o salário for menor que R$
1.000,00 reajusta o salário em 15%. Caso contrário, reajusta o salário em 7%. O
valor do novo salário é apresentado na tela.
3. main () {
4. float salario;
5. // le o salário
6. printf ("Salario: ");
7. scanf ("%f", &salario);
8. // calcula o novo salario usando o operador ternario de decisao
9. salario = salario < 1000 ? salario * 1.15 : salario * 1.07;
10. // apresenta o novo salario
11. printf ("Novo Salario = %.2f\n\n", salario);
13. }
Exemplo 1
O programa a seguir faz a leitura do preço bruto de um produto e calcula o valor
do ICMS a ser pago (sabendo que o ICMS equivale a 18% do preço do produto).
Neste exemplo, foi utlizada uma constante simbólica para representar o percentual
do ICMS.
3.
4. // define uma constante simbolica para o valor do ICMS
5. #define ICMS 0.18
6.
7. main () {
8. float preco;
9. // le o preco do produto
10. printf ("Preco: ");
11. scanf ("%f", &preco);
12. // calcula o valor do icms
13. float valorICMS = preco * ICMS;
14. // apresenta o valor calculado
15. printf ("ICMS = R$ %.2f\n\n", valorICMS);
17. }
Exemplo 2
Neste exemplo, é feita a leitura de dois números inteiros e, em seguida, o maior
valor é apresentado na tela. Para tanto, foi utilizado o operador ternário de decisão.
3. main () {
4. int num1, num2, maior;
5. // le os dois numeros
6. printf ("Primeiro Numero: ");
7. scanf ("%d", &num1);
8. printf ("Segundo Numero: ");
9. scanf ("%d", &num2);
10.
11. // verifica qual o maior numero e atribui a variavel maior
12. // para isso é usado o operador ternario de decisao
13. maior = num1 > num2 ? num1 : num2;
14.
15. // apresenta o maior numero
16. printf ("Maior = %d\n\n", maior);
18. }
Agora que você já estudou essa aula acesse a plataforma AVA, resolva os
exercícios e verifique o seu conhecimento. Caso fique alguma dúvida, leve a
questão ao Fórum e divida com seus colegas e professor.
Conceitos iniciais, definição e

utilização de Vetores em C
Apresentar o conceito de variável indexada unidimensional (vetor) e aplicar tal
conceito utilizando a linguagem C.
NESTE TÓPICO
NESTE TÓPICO
Introdução
Definição
Declaração de Vetor
Referenciando um Elemento do Vetor

Vídeo
Lendo Dados para um Vetor
Acessando Dados de um Vetor
Exemplo 1
Exemplo 2
Exemplo 3
Exemplo 4
Referências
Marcar
tópico

Introdução
Na maioria da vezes, os dados são manipulados em variáveis simples, que são
capazes de armazenar um único valor. Existem casos em que precisamos
armazenar não um único valor, mas uma coleção de valores. Por exemplo,
queremos armazenar a média de cada aluno em uma disciplina. Seria muito
trabalhoso e de difícil manutenção criarmos uma variável para cada aluno da
turma.
Vetor, também conhecido como variável indexada unidimensional, é uma estrutura
de dados que permite o agrupamento de vários dados do mesmo tipo dentro de uma
mesma variável. Isso facilita o armazenamento e a manipulação de uma coleção de
dados do mesmo tipo.
Definição
Um vetor é uma coleção de variáveis do mesmo tipo que são referenciadas por um
único nome. Um vetor possui um tamanho, definido na sua declaração, e que nunca
se altera. O tamanho do vetor indica quanto elementos ele pode armazenar. Um
elemento (valor) armazenado em um vetor é acessado por meio de um índice.
Vetor é uma estrutura unidimensional (precisa somente de um índice para acessar
um elemento), estática (o tamanho deve ser pré-definido antes de sua utilização),
homogênea (todos os elementos devem ter o mesmo tipo de dados) e temporária (a
variável declarada como vetor só existe em tempo de execução).
Em C, os dados do vetor são armazenados de forma contígua na memória. A figura
a seguir apresenta a representação gráfica de um vetor.
Representação Gráfica de um Vetor
Declaração de Vetor
Como uma variável simples, um vetor deve ser declarado antes de sua utilização. A
declaração de um vetor é feita indicando o tipo de dado que o vetor irá armazenar,
o seu nome e o seu tamanho.
A forma geral de declaração de um vetor em linguagem C é:
tipo nome[tamanho];
Onde, tipo é um tipo qualquer de dados, nome é o nome pelo qual o vetor será
referenciado e tamanho é a quantidade de elementos que o vetor pode conter. Em
C, o primeiro elemento tem índice 0 e o último elemento tem índice tamanho-1. Os
índices são sempre representados por valores inteiros positivos.
Exemplos:
 Declaração de um vetor denominado números de 10 posições de valores
inteiros.
int numeros[10];
 Declaração de um vetor denominado notas de 15 posições de valores do tipo

float (real).
float notas[15];

Referenciando um Elemento do Vetor
Os elementos de um vetor devem ser referenciados de forma individualizada. Não
é possível referenciar todos os elementos ao mesmo tempo. Um elemento é
referenciado pelo nome do vetor seguido do índice onde o elemento está
armazenado entre colchetes.
O exemplo abaixo referencia o terceiro elemento do vetor denominado notas. O
terceiro elemento é referenciado pelo índice 2, já que o primeiro elemento tem
índice 0.
notas[2]
Podemos atribuir um valor a um elemento do vetor da seguinte forma:
notas[2] = 7.5;
O exemplo acima atribui o valor 7.5 ao terceiro elemento do vetor notas.

Vídeo
Lendo Dados para um Vetor
Imagine que temos um vetor denominado notas que pode armazenar 5 elementos
do tipo float. Queremos solicitar ao usuário que informe os dados para preencher
esse vetor. O trecho de código a seguir lê os dados que serão armazenados no
vetor.
1. int i;
2. for (i = 0; i < 5; i++) {
3. printf ("Digite a nota do aluno %d: ", i);
4. scanf ("%f", &notas[i]);
5. }
O laço for é usado para o processo de solicitar uma nota ao usuário e armazená-la
no vetor. No exemplo acima, esse processo é repetido 5 vezes. O valor informado
pelo usuário será armazenado na posição de índice do valor atual da variável i.
Geralmente, utilizamos a estrutura de repetição for para a manipulação do vetor.

Acessando Dados de um Vetor
Uma vez preenchido o vetor queremos manipular os seus elementos ou apresenta-
los na tela. Utilizando o vetor de notas preenchido na seção anterior, vamos agora
calcular a média das notas e também apresentar os elementos do vetor na tela.
Analise o seguinte trecho de código.
1. float soma = 0;
2. int i;
3. for (i = 0; i < 5; i++) {
4. // soma a variável o elemento de índice i do vetor
5. soma = soma + notas[i];
6. // apresenta o elemento de índice i do vetor
7. printf ("Nota %d = %.1f\n", i, notas[i]);
8. }
9. float media = soma / 5;
10. printf ("Media das notas = %.1f\n", media);
O trecho de código anterior utiliza o laço for para percorrer o vetor. Em cada
iteração do laço, um elemento do vetor de notas é somado a variável soma e
também o elemento somado é apresentado na tela. Ao final do laço é calculada a
média das notas e apresentada na tela.
Exemplo 1
A seguir, apresentamos um exemplo completo de um programa em linguagem C
que trabalha com vetor. O programa lê 5 notas e armazena-as em um vetor, calcula
a média aritmética e apresenta a média e os dados do vetor na tela.
3. main () {
4. // declaração do vetor
5. float notas[5];
6. int i;
7. // leitura dos dados para o vetor
8. for (i = 0; i < 5; i++) {
9. printf ("Digite a nota do aluno %d: ", i);
10. scanf ("%f", &notas[i]);
11. }
12. // calcula a soma das notas e apresenta cada nota na tela
13. float soma = 0;
14. for (i = 0; i < 5; i++) {
15. soma = soma + notas[i];
16. printf ("Nota %d = %.1f\n", i, notas[i]);
17. }
18. // calcula e apresenta a média das notas
19. float media = soma / 5;
20. printf ("Media das notas = %.1f\n", media);
22. }
Exemplo 2
Vamos estudar outro exemplo de utilização de vetor. O enunciado é: Criar um
programa que leia 8 elementos inteiros em um vetor A. Construir um vetor B do
mesmo tipo e tamanho com os elementos do vetor A multiplicados por 3. O
elemento B[0] recebe o elemento A[0] * 3, o elemento B[1] recebe o elemento
A[1] * 3 e assim por diante, até a posição 7 do vetor. Apresentar os elementos do
vetor B.
3. main () {
4. // declaração dos dois vetores
5. int A[8], B[8];
6. int i;
7. // leitura do vetor A
8. printf ("*** Informe os dados do vetor A ***\n");
9. for (i = 0; i < 8; i++) {
10. printf ("A[%d]: ", i);
11. scanf ("%d", &A[i]);
12. }
13. // cálculo do vetor B
14. for (i = 0; i < 8; i++) {
15. B[i] = A[i] * 3;
16. }
17. // apresentação dos elementos do vetor B
18. printf ("\n*** Dados do vetor B *** \n");
19. for (i = 0; i < 8; i++) {
20. printf ("B[%d] = %d\n", i, B[i]);
21. }
23. }
Exemplo 3
O programa a seguir armazena 10 elementos reais em um vetor e, depois, apresenta
seus valores na tela.
3. main () {
4. // declaração de um vetor de 10 elementos reais
5. float vetor[10];
6. int i;
8. printf ("*** Informe os valores para o vetor ***\n");
9. for (i = 0; i < 10; i++) {
10. printf ("Valor[%d]: ", i);
11. // não esquecer de colocar o & antes do nome do vetor
12. scanf ("%f", &vetor[i]);
13. }
14. // apresentação dos dados do vetor
15. printf ("\n\n*** Dados do vetor ***\n");
16. for (i = 0; i < 10; i++) {
17. printf ("%.2f\n", vetor[i]);
18. }
20. }
Exemplo 4
O programa a seguir faz a leitura de dois vetores (denominados A e B) com 20
elementos inteiros. No vetor C, cada elemento é calculado como a subtração de um
elemento do vetor A com um elemento correspondente do vetor B, ou seja, a
operação de processamento é baseada na operação C[I] = A[I] - B[I]. Ao final, os
elementos do vetor C são apresentados.
3. main () {
4. // declaração dos vetores
5. int A[20], B[20], C[20];
6. int i;
8. printf ("*** Informe os valores do vetor A ***\n");
9. for (i = 0; i < 20; i++) {
10. printf ("A[%d]: ", i);
11. scanf ("%d", &A[i]);
12. }
13. // leitura do vetor B
14. printf ("\n*** Informe os valores do vetor B ***\n");
15. for (i = 0; i < 20; i++) {
16. printf ("B[%d]: ", i);
17. scanf ("%d", &B[i]);
18. }
19. // calculo e impressao do vetor C
20. printf ("\n*** Valores do vetor C ***\n");
21. for (i = 0; i < 20; i++) {
22. C[i] = A[i] - B[i];
23. printf ("C[%d] = %d\n", i, C[i]);
24. }
25. printf ("\n\n");
27. }
Conceitos adicionais sobre vetores

em C
Apresentar conceitos adicionais sobre vetor e aplicar esses conceitos utilizando a
linguagem C.
NESTE TÓPICO
NESTE TÓPICO
Inicialização de Vetor

Exemplo 1
Uso da diretiva #define
Exemplo 2
Exemplo 3
Exemplo 4
Exemplo 5
Exemplo 6
Referências
Marcar
tópico

Inicialização de Vetor
Assim como uma variável simples, um vetor pode ser inicializado no momento de
sua declaração. Nesse caso, os valores iniciais devem ser fornecidos entre chaves e
separados por vírgula. O trecho de código a seguir mostra a declaração e
inicialização de um vetor de valores reais.
float moeda[5] = {1.00, 0.50, 0.25, 0.10, 0.05};
Os valores da inicialização são armazenados no vetor a partir da posição 0 na
ordem em que são fornecidos. Por exemplo, o valor 0.10 é armazenado em
moeda[3].
Os valores utilizados para a inicialização de vetor devem ser constantes. O uso de
variáveis causa erro de compilação.

Exemplo 1
que utiliza inicialização de vetor. O enunciado é: Criar um programa que leia uma
determinada quantia a ser retirada em um caixa eletrônico e apresente a quantidade
mínima de cédulas equivalente. As cédulas são de 50, 20 e 10. Utilizar sempre que
possível cédulas de maior valor. O valor da quantia a ser retirada deve ser múltiplo
de 10. Guardar em um vetor a quantidade de cada cédula. Apresentar os dados do
vetor de cédulas na tela.
3. main () {
4. // declaracao e inicializacao do vetor de cedulas
5. int cedulas[3] = {50, 20, 10};
6. // vetor que armazena a quantidade de cada cedula
7. int quantidade[3];
8. int i;
9. // leitura da quantia
10. int quantia;
11. printf ("Quantia: ");
12. scanf ("%d", &quantia);
13. // verifica se o valor da quantia é multiplo de 10
14. if (quantia % 10 != 0) {
15. printf ("O valor deve ser multiplo de 10!\n");
16. }
17. else {
18. // calcula a quantia de cada cedula
19. for (i = 0; i < 3; i++) {
20. quantidade[i] = quantia / cedulas[i];
21. quantia %= cedulas[i];
22. }
23. // apresenta a quantidade de cada cedula na tela
24. for (i = 0; i < 3; i++) {
25. printf ("R$ %d = %d\n", cedulas[i], quantidade[i]);
26. }
27. }
29. }
Uso da diretiva #define

A codificação de programas deve ser feita de forma que uma pequena alteração não
provoque grandes mudanças no código. Vamos estudar o seguinte programa, que lê
um vetor de 10 valores inteiros e apresenta os dados do vetor na tela.
3. main () {
4. int vetor[10];
5. int i;
6. for (i = 0; i < 10; i++) {
8. scanf ("%d", &vetor[i]);
9. }
10. printf ("\n*** Dados do vetor ***\n");
11. for (i = 0; i < 10; i++) {
12. printf ("%d ", vetor[i]);
13. }
16. }
Suponhamos agora que não queremos mais guardar 10 elementos e sim 15.
Teríamos que alterar todas as ocorrências do valor 10 que indica o tamanho do
vetor.
1. int vetor[10];
2.
3. for (i = 0; i < 10; i++)
4. {
5. for (i = 0; i < 10; i++)
6. {
Como se trata de um programa pequeno o trabalho não será muito, mas imagina se
o programa fosse de milhares de linhas de código.
A solução para esse problema está no uso de constantes simbólicas para especificar
o tamanho do vetor. Uma vez que o valor da constante simbólica é alterado ele é
propagado para todas as suas ocorrências.
Dessa forma, é possível declarar uma constante simbólica utilizando a
diretiva #define. Vamos agora usá-la para declarar uma constante simbólica que
corresponde ao tamanho do vetor. Analise a nova versão do programa.
3. // constante simbólica que representa o tamanho do vetor
4. #define TAM 10
5. main () {
6. int vetor[TAM];
7. int i;
8. for (i = 0; i < TAM; i++) {
11. }
13. for (i = 0; i < TAM; i++) {
15. }
18. }
Nessa nova versão declaramos uma constante simbólica denominada TAM e
associamos a ela o valor 10, que corresponde ao tamanho do vetor. Sempre que
quisermos referenciar o tamanho do vetor basta usarmos o nome da constante. No
programa acima, referenciamos o tamanho do vetor nas seguintes linhas:
1. int vetor[TAM];
2. for (i = 0; i < TAM; i++) {
3. for (i = 0; i < TAM; i++) {
Se quisermos agora modificar o nosso programa para que o vetor armazene 15

elementos basta modificarmos o valor associado a constante TAM. A alteração
ficaria assim:
#define TAM 15
O restante do código não precisa ser alterado.
Exemplo 2
Vamos estudar outro exemplo de utilização de vetor, agora usando constantes para
representar o tamanho do vetor. O enunciado é: Criar um programa que leia três
vetores (A, B e C) com 5 elementos inteiros cada. Construir um vetor D, sendo
esse a junção dos três outros vetores. Desta forma, D deve ter o triplo de elementos
dos outros 3 vetores. Apresentar os elementos do vetor D.
3. // declara uma constante para o tamanho dos vetores A, B, C
4. #define TAM_ABC 5
5. // declara uma constante para o tamanho do vetor D
6. #define TAM_D 15
7. main () {
8. // declaração dos vetores
9. int A[TAM_ABC], B[TAM_ABC], C[TAM_ABC], D[TAM_D];
10. int i;
12. printf ("*** Informe os valores do vetor A ***\n");
13. for (i = 0; i < TAM_ABC; i++) {
14. printf ("A[%d]: ", i);
15. scanf ("%d", &A[i]);
16. }
17. // leitura do vetor B
18. printf ("\n*** Informe os valores do vetor B ***\n");
19. for (i = 0; i < TAM_ABC; i++) {
20. printf ("B[%d]: ", i);
21. scanf ("%d", &B[i]);
22. }
23. // leitura do vetor C
24. printf ("\n*** Informe os valores do vetor C ***\n");
25. for (i = 0; i < TAM_ABC; i++) {
26. printf ("C[%d]: ", i);
27. scanf ("%d", &C[i]);
28. }
29. // criação do vetor D
30. for (i = 0; i < TAM_ABC; i++) {
31. D[i] = A[i];
32. D[i + 5] = B[i];
33. D[i + 10] = C[i];
34. }
35. // impressao do vetor D
36. printf ("\n*** Valores do vetor D ***\n");
37. for (i = 0; i < TAM_D; i++) {
38. printf ("D[%d] = %d\n", i, D[i]);
39. }
42. }
Exemplo 3
Neste programa é efetuado o cálculo de uma tabuada (1 ao 9) de um número
qualquer informado pelo usuário e os resultados são armazenados em um vetor. No
final do programa, os valores armazenados no vetor são apresentados.
3.
4. // constante que armazena o tamanho do vetor
5. #define TAM 9
6.
7. main () {
8. // declaracao do vetor
9. int tabuada[TAM];
10. int i;
11. // leitura de um numero
12. int num;
13. printf ("Numero: ");
14. scanf ("%d", &num);
15. // calculo e armazenamento da tabuada no vetor
16. for (i = 0; i < TAM; i++) {
17. tabuada[i] = num * (i + 1);
18. }
19. // impressao do vetor
21. for (i = 0; i < TAM; i++) {
22. printf ("Valor[%d] = %d\n", i, tabuada[i]);
23. }
25. }
Exemplo 4
Neste exemplo, o programa faz a leitura de um vetor A com 10 elementos
numéricos inteiros. Em seguida, é feito o cálculo do total de elementos ímpares
existentes no vetor e, também, o percentual do valor total de números ímpares em
relação à quantidade total de elementos armazenados no vetor.
1. include <stdio.h>
3.
5. #define TAM 10
6.
7. main () {
9. int vetor[TAM];
10. int i;
11. // leitura do vetor
12. for (i = 0; i < TAM; i++) {
15. }
16. // conta a quantidade de impares
17. int quantidade = 0;
18. for (i = 0; i < TAM; i++) {
19. if (vetor[i] % 2 != 0) {
20. quantidade++;
21. }
22. }
23. // calcula o percentual em relacao ao total de valores
24. float percentual = (float) quantidade / TAM;
25. printf ("Quantidade de impares = %d\n", quantidade);
26. printf ("Percentual = %.2f %%\n", percentual * 100);
28. }
Exemplo 5
Este programa inicializa um vetor A com os seguintes elementos 1, 3, 4, 2,5, 8, 7,
6, 9, 12, 15. Na sequência, um vetor B de mesmo tipo e dimensão, é construído
observando a seguinte lei de formação: “todo elemento do vetor A que for ímpar
deve ser multiplicado por 2; caso contrário, deve permanecer constante”. Por fim,
o vetor B é apresentado.
3.
5. #define TAM 11
6.
7. main () {
9. int A[TAM] = {1, 3, 4, 2, 5, 8, 7, 6, 9, 12, 15};
10. int B[TAM];
11. int i;
12. // criacao do vetor B
13. for (i = 0; i < TAM; i++) {
14. if (A[i] % 2 != 0) {
15. B[i] = A[i] * 2;
16. }
17. else {
18. B[i] = A[i];
19. }
20. }
21. // impressao do vetor B
22. printf ("\n*** Dados do Vetor B ***\n");
23. for (i = 0; i < TAM; i++) {
24. printf ("%d ", B[i]);
25. }
28. }
Exemplo 6
Neste exemplo, no programa é feita a leitura de um vetor de 12 elementos de
valores reais e, em seguida, o menor, o maior e a média dos valores lidos são
apresentados na tela.
3. #define TAM 12
4. main () {
5. // declaração do vetor
6. float numeros[TAM];
7. int i;
8. // leitura dos valores do vetor
9. printf ("*** Informe os valores do vetor ***\n");
10. for (i = 0; i < TAM; i++) {
12. scanf ("%f", &numeros[i]);
13. }
14. // assume inicialmente que primeiro elemento do vetor é o
15. // maior e menor valor
16. float menor = numeros[0];
17. float maior = numeros[0];
18. float soma = numeros[0];
19. // começa pelo segundo elemento já que o primeiro foi considerado
20. for (i = 1; i < TAM; i++) {
21. soma += numeros[i];
22. if (numeros[i] < menor) {
23. menor = numeros[i];
24. }
25. if (numeros[i] > maior) {
26. maior = numeros[i];
27. }
28. }
Conceitos iniciais, definição e
utilização de Matrizes em C
Apresentar o conceito de variável indexada com mais de uma dimensão (matriz) e
aplicar tal conceito utilizando a linguagem C.
NESTE TÓPICO
NESTE TÓPICO
Introdução

Definição
Declaração de Matriz
Referenciando um Elemento da Matriz
Lendo Dados para uma Matriz
Acessando Dados de uma Matriz
Exemplo 1
Exemplo 2
Exemplo 3
Exemplo 4
Referências
Marcar
tópico

Introdução
Estudaremos, agora, como criar uma variável indexada com mais de uma
dimensão. A linguagem C permite criar uma variável indexada com qualquer
número de dimensões. Esta aula tem como foco a criação de variáveis indexadas
com duas dimensões, também denominada matriz.

Definição
Uma matriz é uma coleção de dados do mesmo tipo parecido com uma tabela,
possuindo linhas e colunas. Como um vetor, ela possui um nome e os dados são
acessados por índices, representando a linha e a coluna respectivamente. Ela
também possui um tamanho de linhas e colunas, que deve ser especificado na
declaração da matriz.
Se M é uma matriz m x n, isto é, m é quantidade de linhas e n é a quantidade de
colunas, então suas linhas são indexadas de 0 a m-1 e suas colunas de 0 a n-1. Para
acessarmos um elemento particular de M, escrevemos M[i][j], onde i é o número
da linha e j o número da coluna. A figura a seguir apresenta a representação gráfica
de uma matriz bidimensional 3 x 5 de valores inteiros.
Declaração de Matriz
A declaração de uma matriz é feita indicando o tipo de dado que a matriz irá
armazenar, o seu nome e o tamanho de cada uma de suas dimensões.
A forma geral de declaração de uma matriz com várias dimensões em linguagem C
é:
tipo nome[dim1][dim2][dim3]...[dimN];
Para declararmos uma matriz de duas dimensões usamos a seguinte forma:
tipo nome[linhas][colunas];
Onde, tipo é um tipo qualquer de dados, nome é o nome pelo qual a matriz será
referenciada, linhas é a quantidade de linhas que a matriz pode conter e colunas é a
quantidade de colunas que a matriz pode conter. Em C, o primeiro elemento da
linha tem índice 0 e o último elemento tem índice linhas-1, da mesma forma, o
primeiro elemento da coluna tem índice 0 e o último elemento tem índice colunas-
1. O tamanho de linhas e colunas pode ser diferente.
Exemplos:
- Declaração de uma matriz denominada números de 10 linhas e 5 colunas de
valores inteiros.
int numeros[10][5];
- Declaração de uma matriz denominada valores de 15 linhas e 15 colunas de
valores do tipo float (real).
float valores[15][15];
Assim como um vetor, uma matriz pode ser inicializada no momento de sua
declaração. O trecho de código a seguir exemplifica a declaração e inicialização de
uma matriz 3 x 4 de elementos do tipo inteiro.
1. int matriz [3][4] = {

2. {1, 3, 5, 7},
3. {2, 4, 6, 8},
4. {1, 9, 2, 6},
5. };
Matrizes de duas dimensões são inicializadas da mesma forma que um vetor. Os

elementos que representam as linhas são colocados entre chaves depois do sinal de
igual e separados por vírgula. Cada elemento de uma linha é composto por chaves
e seus elementos internos separados por vírgulas.

Referenciando um Elemento da Matriz
Os elementos de uma matriz devem ser referenciados de forma individualizada.
Não é possível referenciar todos os elementos ao mesmo tempo. Um elemento é
referenciado pelo nome da matriz seguido do índice da linha entre colchetes e
depois o índice da coluna também entre colchetes. O exemplo abaixo referencia o
elemento da terceira linha e da segunda coluna de uma matriz. Lembre-se que os
índices começam pelo valor 0.
matriz[2][1];
Podemos atribuir um valor a um elemento da matriz da seguinte forma:
matriz[2][1] = 7;
O exemplo acima atribui o valor 7 ao elemento da terceira linha e da segunda
coluna da matriz.

Lendo Dados para uma Matriz
Imagine que temos uma matriz 3x4 denominada m que armazena elemento do tipo
int. Queremos solicitar ao usuário que informe os dados para preencher essa
matriz. O trecho de código a seguir lê os dados que serão armazenados na matriz.
1. int i, j; // i representa a linha e j representa a coluna

2. for (i = 0; i < 3; i++) { // vai de 0 até a quantidade de linhas - 1
3. for (j = 0; j < 4; j++) { // vai de 0 até a quantidade de colunas -1
4. printf ("m[%d][%d]: ", i, j);
5. scanf ("%d", &m[i][j]);
6. }
7. }
Na manipulação de vetor é utilizada uma única instrução de laço for. No caso de

matrizes com mais dimensões, deve ser utilizado o número relativo à quantidade de
dimensões. Dessa forma, uma matriz de duas dimensões deve ser controlada com
dois laços for. O laço mais externo (primeiro laço) é responsável por percorrer as
linhas e o laço mais interno (segundo laço) é responsável por percorrer as colunas.

Acessando Dados de uma Matriz
Uma vez preenchida a matriz queremos manipular os seus elementos ou apresenta-
los na tela. Utilizando a matriz m preenchida na seção anterior, vamos agora
calcular a soma dos seus elementos e também apresentar os elementos da matriz na
tela. Analise o seguinte trecho de código.
1. int soma = 0;
2. int i, j;
3. for (i = 0; i < 3; i++) {
4. for (i = 0; i < 4; i++) {
5. // soma a variável o elemento da linha i e coluna j
6. soma = soma + m[i][j];
7. // apresenta o elemento da linha i e coluna j
8. printf ("m[%d][%d] = %d\n", i, j, m[i][j]);
9. }
10. }
11. printf ("Soma = %d\n", soma);
Exemplo 1
que trabalha com matriz bidimensional. O programa cria uma matriz 3x4 de
valores inteiros e solicita os seus dados ao usuário, calcula a soma dos elementos
da matriz e apresenta os dados da matriz e a soma calculada.
3. // utiliza constante simbólica para definir a quantidade de linhas
4. #define LINHAS 3
5. // utiliza constante simbólica para definir a quantidade de colunas
6. #define COLUNAS 4
7. main () {
8. // declaração da matriz
9. int matriz[LINHAS][COLUNAS];
10. // i representa a linha e j representa a coluna
11. int i, j;
12. // leitura dos dados para a matriz
13. for (i = 0; i < LINHAS; i++) { // vai de 0 até a quantidade de linhas - 1
14. for (j = 0; j < COLUNAS; j++) { // vai de 0 até a quantidade de
colunas -1
15. printf ("matriz[%d][%d]: ", i, j);
16. scanf ("%d", &matriz[i][j]);
17. }
18. }
19. // calcula a soma dos valores e apresenta os dados da matriz
20. int soma = 0;
21. for (i = 0; i < LINHAS; i++) {
22. for (j = 0; j < COLUNAS; j++) {
23. soma += matriz[i][j];
24. printf ("%d ", matriz[i][j]);
25. }
26. printf ("\n");
27. }
28. printf ("\nSoma = %d\n", soma);
30. }
Exemplo 2
Vamos estudar outro exemplo de utilização de matriz. O enunciado é: Criar um
programa que crie e inicialize uma matriz de elementos inteiros de acordo com a
tabela abaixo. Apresentar os elementos da matriz na tela.
3 5 2 1 10
15 12 18 4 6
7 9 13 16 20

3. #define LINHAS 3
5. main () {
6. // declaração e inicialização da matriz
7. int matriz[LINHAS][COLUNAS] = {
8. {3, 5, 2, 1, 10},
9. {15, 12, 18, 4, 6},
10. {7, 9, 13, 16, 20}
11. };
12. // apresentação dos dados da matriz
13. int i, j;
14. printf ("*** Dados da Matriz ***\n\n");
15. for (i = 0; i < LINHAS; i++) {
16. for (j = 0; j < COLUNAS; j++) {
17. printf ("%2d ", matriz[i][j]);
18. }
19. printf ("\n");
20. }
22. }
Exemplo 3
Neste exemplo, o programa faz a leitura de uma matriz 5x5 de elementos inteiros,
calcula e apresenta a soma da diagonal principal. Além disso, apresenta, também,
os elementos da matriz.
3. #define LINHAS 5
5. main () {
6. // declara a matriz
7. int matriz[LINHAS][COLUNAS];
8. int i, j;
9. // lê os dados para a matriz
10. printf ("*** Informe os dados da matriz ***\n");
11. for (i = 0; i < LINHAS; i++) {
12. for (j = 0; j < COLUNAS; j++) {
13. printf ("Valor[%d][%d]: ", i, j);
14. scanf ("%d", &matriz[i][j]);
15. }
16. }
17. // calcula a soma da diagonal principal e
18. // apresenta os dados da matriz na tela
19. int soma = 0;
20. printf ("\n*** Dados da Matriz ***\n\n");
21. for (i = 0; i < LINHAS; i++) {
22. for (j = 0; j < COLUNAS; j++) {
23. printf ("%d ", matriz[i][j]);
24. // se o índice da linha é igual ao da coluna,
25. // então o elemento está na diagonal principal.
26. if (i == j) {
28. }
29. }
30. printf ("\n");
31. }
32. printf ("\nSoma = %d\n\n", soma);
34. }
Exemplo 4
Neste exemplo, o programa faz a leitura de uma matriz 5x3 de elementos reais,
calcula e apresenta a média dos valores que estão acima de 20,75; apresenta,
também, os elementos da matriz.
3. #define LINHAS 5
5. main () {
6. // declara a matriz
7. float matriz[LINHAS][COLUNAS];
8. int i, j;
9. // lê os dados para a matriz
10. printf ("*** Informe os dados da matriz ***\n");
11. for (i = 0; i < LINHAS; i++) {
12. for (j = 0; j < COLUNAS; j++) {
13. printf ("Valor[%d][%d]: ", i, j);
14. scanf ("%f", &matriz[i][j]);
15. }
16. }
17. // soma os elementos superiores a 20,75
18. // guarda a quantidade de elementos somados
19. // apresenta os dados da matriz na tela
20. float soma = 0;
21. int quantidade = 0;
22. printf ("\n*** Dados da Matriz ***\n\n");
23. for (i = 0; i < LINHAS; i++) {
24. for (j = 0; j < COLUNAS; j++) {
25. printf ("%.2f ", matriz[i][j]);
26. if (matriz[i][j] > 20.75) {
28. quantidade++;
29. }
30. }
31. printf ("\n");
32. }
33. float media = 0;
34. if (quantidade > 0) {
35. media = soma / quantidade;
36. }
37. printf ("\nMedia = %.2f\n\n", media);
39. }
Conceitos iniciais e manipulação de

Strings em C
Apresentar o conceito de strings e aplicar tal conceito utilizando a linguagem C.
NESTE TÓPICO
NESTE TÓPICO
Introdução
Definição
Declaração da String

Referenciando um Caractere da String
Lendo e Exibindo Dados para uma String
Funções para manipulação de Strings
Exemplo 1
Exemplo 2
Exemplo 3
Exemplo 4
Referências
Marcar
tópico

Introdução
No cotidiano sempre nos deparamos com frases, textos e palavras, os quais são
representados por seqüências (ou cadeias) de caracteres. Como exemplos, podemos
citar o envio de mensagens por correios eletrônicos, os editores de textos e os
programas de cadastro, onde os dados são representados textualmente.
Dentro do contexto de linguagens de programação, seqüências de caracteres são
denominadas strings.
A maioria das linguagens de programação permite a representação de cadeias de
caracteres. Dentre elas, podemos citar a linguagem Pascal, que possui um tipo de
dados específico chamado string para tal finalidade. A Linguagem C não possui
este tipo de dados e, por este motivo, é utilizado o conceito de vetores, os quais
permitem agupar, em uma só variável, vários caracteres.

Definição
Na Linguagem C, strings são representadas por vetores de caracteres e devem ser
terminadas, obrigatoriamente, pelo caractere nulo ( \0 ). Nesse caso, devemos
reservar uma adicional para o caractere, que indica o fim de cadeia. Na Figura
abaixo é mostrada a representação gráfica de uma string. Como queremos
representar a palavra “Uninove”, composta por 7 caracteres, o vetor deve ter
tamanho 8 para considerar o caractere nulo.

Declaração da String
Como uma variável simples, uma string deve ser declarada antes de sua utilização.
A declaração de uma string é feita indicando o tipo de dado como char, o seu nome
e o seu tamanho.
A forma geral de declaração de uma string em linguagem C é:
char nome [tamanho];
Onde, nome é o nome pelo qual a string será referenciada e tamanho é a quantidade
de caracteres que a string pode conter.
Exemplos:
- Declaração de uma string denominada palavra de 8 posições de caracteres.
char palavra [8];
Assim como uma variável simples, a string pode ser declarada e inicializada no
início de um programa. O trecho de código a seguir mostra a inicialização da string
sob 2 formas.
char palavra [8] = {‘U’ , ‘n’, ‘i’, ‘n’, ‘o’, ‘v’, ‘e’, ‘\0’};
ou
char palavra [8] = “Uninove”;

DICA IMPORTANTE
O conteúdo das variáveis do tipo char deve ser referenciado entre apóstrofes (‘ ‘).
O conteúdo das strings deve ser referenciado entre aspas (“ ”).
Referenciando um Caractere da String

Os caracteres de uma string podem ser referenciados de forma individualizada.
Não é possível referenciar todos ao mesmo tempo, já que sabemos que a string é
um vetor. Um caractere é referenciado pelo nome da string seguido do índice onde
ele está armazenado entre colchetes.
O exemplo abaixo referencia o terceiro caractere da string denominada palavra. O
terceiro caractere, que no exemplo anterior, é a letra “i”, é referenciado pelo índice
2, já que o primeiro elemento tem índice 0.
palavra [2] = ‘i’;

Lendo e Exibindo Dados para uma String
Imagine que temos uma string denominada frase, que pode armazenar, no máximo,
50 caracteres. Queremos solicitar ao usuário que informe os dados para preencher
esse vetor de caracteres. O trecho de código a seguir lê os dados utilizando-se a
função scanf.
1. printf ("Digite a String=");

2. scanf ("%s", frase);
Devemos notar que não usamos o caractere & na passagem da variável palavra
para a função, pois a cadeia de caracteres é um vetor. O uso do especificador de
formato % na leitura é limitado, pois o fragmento de código acima funciona apenas
para capturar nomes simples. Para evitarmos este tipo de limitação, é necessário
especificar o número máximo de caracteres e a leitura até que seja encontrado o
caractere de mudança de linha (‘\n’), o qual está representado no trecho de código
a seguir.
1. printf ("Digite a String=");

2. scanf (" %49[^\n]", frase);
Entretanto, a leitura feita com esta função não é muito utilizada, pois seu uso é
muito limitado. Para tanto, existe uma função específica para a leitura de strings, a
qual trataremos no próximo tópico.
Embora também não seja muito usual, para exibir o conteúdo de uma string,
podemos utilizar a função printf, juntamente com o especificador de formato %s. O
trecho de código a seguir mostra a exibição da String utilizando a função printf.
1. printf ("%s \n", frase);
Funções para manipulação de Strings

Um dos recursos adicionais da linguagem C é a possibilidade de declararmos
bibliotecas, cuja principal vantagem é a utilização de funções pré-definidas. Isso
deixa o código mais claro e de fácil manutenção. Para utilizarmos as funções que
manipulam strings, temos que declarar, no início do programa, a biblioteca
“string.h”. Dentre as funções mais usadas, destacam-se: gets, puts, strcmp, strcpy e
strlen.

1. gets: utilizada para a leitura de uma string via teclado. Esta é a função mais
indicada e utilizada para a leitura, pois não tem as limitações da função scanf. O
trecho de código abaixo mostra a utilização da função gets. A sintaxe da função é a
seguinte:
gets (string)
1. char str [40];

2. printf ("\n Digite a String desejada= ");
3. gets (str);

2. puts: utilizada para a exibição de uma string. O trecho de código abaixo mostra a
utilização da função puts. A sintaxe da função é a seguinte:
puts (string)
1. char str [40];

2. printf ("\n Digite a String desejada= ");
3. gets (str);
4. puts (str);
3. strcpy: utilizada para copiar o conteúdo de uma string origem para uma string
destino. A primeira string terá o mesmo valor da segunda string. Podemos,
também, colocar uma string qualquer entre aspas ao invés de uma variável no lugar
da segunda string (origem). Importante lembrar que as duas strings devem ter o
mesmo tamanho definido, sendo que a segunda string (origem) pode ser menor,
nunca maior que a primeira (destino). O trecho de código abaixo mostra a
utilização da função strcpy. A sintaxe da função é a seguinte:
strcpy (string destino, string origem)
1. char strdest [40], strorig [40];

2. printf ("\n Digite a String Origem= ");
3. gets (strorig);
4. strcpy(strdest, strorig);
4. strcmp: utilizada para comparar se o conteúdo de uma String é igual ao conteúdo
de outra String. Nesse caso, a função retorna o valor 0 (zero) se as duas cadeias
forem iguais, um valor menor que zero se a primeira string for alfabeticamente
menor que segunda string ou um valor maior que zero se a primeira string for
alfabeticamente maior que a segunda string. Esta função diferencia maiúsculas de
minúsculas. O trecho de código abaixo mostra a utilização da função strcmp. A
sintaxe da função é a seguinte:
strcmp (string1 , string2)
1. char str1[50], str2[50];

2. strcpy(str1, "Linguagem C");
3. printf ("\n Digite a Segunda String=");
4. gets (str2);
5. if ( strcmp (str1, str2) == 0 ) {
6. printf ("\n As Strings sao Iguais");}else { printf ("\n As Strings sao
Diferentes");
7. }
5. strlen: utilizada para retornar o tamanho (quantidade de letras) de uma string,

desprezando o caractere nulo final (\0). Ela retorna o valor exato de caracteres. A
sintaxe da função é a seguinte:
strlen (string)
1. char str [50];

2. int tam;
3. strcpy(str, "UNINOVE");
4. tam = strlen(str);
5. printf("\n A quantidade de caracteres da palavra e= %d", tam);
Exemplo 1
A seguir, apresentamos um exemplo de um programa em linguagem C que trabalha
com strings. O programa solicita que o usuário digite uma string e, em seguida,
percorre a string inteira, exibindo caractere por caractere.
3. #include <string.h>
4. main () {
5. // declaracao da string
6. char palavra [20];
7. int i;
8. // leitura da string
9. printf ("*** Digite a string ***\n");
10. gets (palavra);
11. //laco para percorrer a string
12. while (palavra [i] != ?\0?){
13. printf ("\n %c", palavra [i]);
14. i++;
15. }
17. }
Exemplo 2
Vamos estudar outro exemplo de utilização de strings em C. Um palíndromo é uma
palavra, frase ou qualquer outra sequência de caracteres que tenha a propriedade de
poder ser lida tanto da direita para a esquerda como da esquerda para a direita. O
programa solicita que o usuário digite uma string, faz a inversão dos caracteres e
verifica se a palavra é um palíndromo.
4. main () {
5. // declaração das strings
6. char palavra [20], palavra_invertida [20];
7. int i, j=0, tam;
10. gets (palavra);
11. tam = strlen (palavra); // tam armazenará o tamanho da string
12. for (i = tam-1; i>=0; i--){
13. palavra_invertida [j] = palavra [i];
14. j++;
15. }
16. palavra_invertida [j] = ?\0?;
17. if ( strcmp (palavra, palavra_invertida) == 0)
18. printf ("\n A palavra e um palindromo!");
19. else printf ("\n A palavra e nao palindromo!");
21. }
Exemplo 3
Neste programa é feita a contagem de todas as vogais existentes em uma string de
tamanho 30. Por fim, é mostrada a quantidade de vogais.
4. main() {
5. // declaração da string
7. int i= 0, qtde=0;
10. gets (palavra);
11. //laço para percorrer a string
12. while (palavra [i] != '\0'){
13. if (palavra [i] == 'a' || palavra [i] == 'e' || palavra [i] == 'i'
|| palavra [i] == 'o' || palavra [i] == 'u')
14. {
15. qtde++;
16. }
17. i++;
18. }
19. printf ("\n A quantidade de vogais da palavra e = %d\n", qtde);
21. }
Exemplo 4
Neste programa, a letra “a” é substituída pela letra “i” em uma string de tamanho
15. Por fim, a string alterada é exibida.
4. main () {
5. // declaração da string
7. int i, tam;
10. gets (palavra);
11. tam = strlen (palavra); // tam armazenará o tamanho da string
12. for (i = 0; i<tam; i++){
13. if (palavra [i] == 'a')
14. palavra [i] = 'i';
15. }
16. puts (palavra);
18. }
Vetores de Strings em C
Apresentar o conceito de vetores de strings e aplicar tal conceito utilizando a
linguagem C.
NESTE TÓPICO
NESTE TÓPICO
Introdução
Definição
Declaração do Vetor de Strings
Referenciando uma String do Vetor
Referenciando um Caractere de uma String do Vetor
Lendo Dados para um Vetor de Strings
Acessando Dados de um Vetor de Strings
Exemplo 1
Exemplo 2
Exemplo 3
Exemplo 4
Referências
Marcar
tópico

Introdução
Na linguagem C é possível criar uma lista de strings, ou seja, armazenar strings em
cada posição contínua de memória. A este tipo de representação denominamos
vetor de strings, que pode ser utilizado em muitas aplicações. Por exemplo,
podemos considerar uma aplicação que armazene os nomes de todos os alunos de
uma turma em um vetor.
Para representarmos um vetor no qual cada elemento é uma string, devemos ter um
conjunto bidimensional de char.

Definição
Um vetor de strings é uma coleção de strings (cadeias de caracteres). Para um
vetor de strings é necessário definirmos o tamanho do vetor e a quantidade máxima
de caracteres que cada string deverá ter. Na Figura abaixo é mostrada a
representação gráfica de um vetor de strings. Ainda considerando o exemplo dos
alunos de uma turma, o vetor poderá armazenar até 10 alunos, sendo cada nome
composto por, no máximo, 60 caracteres.
Declaração do Vetor de Strings

Como uma variável simples, um vetor de strings deve ser declarado antes de sua
utilização. A declaração de um vetor de strings é feito indicando o tipo de dado
como char, o seu nome, o tamanho do vetor e o tamanho das strings (quantidade de
caracteres).
A forma geral de declaração de um vetor de strings em linguagem C é:
char nome [tamanho do vetor] [tamanho das strings];
Onde, nome é o nome pelo qual a string será referenciada, o tamanho do vetor é a
quantidade strings que o vetor poderá ter e o tamanho das strings é a quantidade
máxima de caracteres que cada string poderá ter.
Exemplo:
 Declaração de um vetor de strings denominado alunos, que poderá

armazenar até 10 nomes de alunos, os quais poderão ter, no máximo, 60
caracteres.
char alunos [10] [60];

Assim como uma variável simples, um vetor de strings pode ser declarado e
inicializado no início de um programa. O trecho de código a seguir mostra a
inicialização do vetor de strings.
1. char alunos [10] [60] = {"Ana", "Pedro", "Maria" , "Antonio" , "Marcos" ,

"João", "Andre" , "Diego" , "Liliane", "Denise"};
Referenciando uma String do Vetor
Uma string que está no vetor é referenciada pelo nome do vetor seguido do índice
onde ela está armazenada entre colchetes.
O exemplo abaixo referencia a terceira string do vetor denominado alunos. A
terceira string, que no exemplo anterior, é o nome “Maria”, é referenciada pelo
índice 2, já que o primeiro elemento tem índice 0.
alunos [2] = “Maria”

Referenciando um Caractere de uma String do
Vetor
Um caractere de uma string que está armazenada no vetor é referenciado pelo
nome do vetor seguido do índice onde a string está armazenada e seguido do índice
do caractere ao qual se quer ter acesso. O exemplo abaixo referencia o segundo
caractere (letra “a”) da terceira string armazenada no vetor (“Maria”).
alunos [2] [1] = ‘a’

Lendo Dados para um Vetor de Strings
Imagine que temos um vetor de strings denominado alunos, que pode armazenar,
no máximo, 10 nomes. Queremos solicitar ao usuário que informe os dados para
preencher esse vetor de strings. O trecho de código a seguir lê os dados utilizando-
se a função gets.
1. int i;
2. for (i = 0; i < 10; i++) {
3. printf ("Digite o nome do aluno %d: ", i);
4. gets (alunos [i]);
5. }
O laço for é usado para o processo de solicitar um nome ao usuário e armazená-lo

no vetor de strings. No exemplo acima, esse processo é repetido 10 vezes. A leitura
do nome informado pelo usuário é feita por meio da função gets, da biblioteca
“string.h”, e será armazenado na posição de índice do valor atual da variável i.

Acessando Dados de um Vetor de Strings
Uma vez preenchido o vetor queremos manipular os seus elementos (strings) ou
apresentá-los na tela. Utilizando o vetor de alunos preenchido na seção anterior,
vamos exibi-los utilizando a função puts, da biblioteca “string.h”. Analise o
seguinte trecho de código.
1. int i;
2. for (i = 0; i < 10; i++) {
3. printf ("Nome do aluno %d: ", i);
4. puts (alunos [i]);
5. }
Exemplo 1
A seguir, apresentamos um exemplo de um programa em linguagem C que trabalha
com vetor de strings. O programa solicita que o usuário digite os nomes de 10
alunos e os armazena em um vetor. Em seguida, os nomes presentes no vetor são
exibidos na tela.
4. main () {
5. char alunos [10][60];
6. int i;
7. for (i = 0; i < 10; i++) {
8. printf ("\n\nDigite um nome de aluno: ");
10. }
11. printf ("\n\n Alunos da turma:\n\n");
12. for (i = 0; i < 10; i++) {
14. }
15. system ("pause");
16. }
Exemplo 2
Vamos estudar outro exemplo de utilização de vetor de strings. O programa solicita
a usuário os nomes de 20 candidatos que irão prestar um concurso e os armazena
em um vetor de strings. Na sequência, necessário exibir todos os candidatos cujos
nomes iniciam-se com a letra “A”.
4. main () {
5. char candidatos [20][60];
6. int i;
7. for (i = 0; i < 20; i++) {
8. printf ("\n\nDigite um nome do candidato: ");
9. gets (candidatos [i]);
10. }
11. printf ("\n\n Candidatos cujo nome começa com a letra A:\n\n");
12. for (i = 0; i < 20; i++) {
13. if ( candidatos [i] [0] ='A' ) {
15. }
16. }
18. }
Exemplo 3
Neste exemplo é utilizado um vetor de strings de tamanho 30 para armazenar os
alunos de uma determinada turma. Suponha que o usuário deseja fazer uma busca
por um nome neste vetor. No fim do programa, uma mensagem é exibida caso o
nome seja encontrado no vetor.
4. main () {
5. char alunos [30][60], nome [60];
6. int i;
7. for (i = 0; i < 30; i++) {
8. printf ("\n\nDigite um nome de aluno: ");
10. }
11. printf ("\n\n Digite o nome do aluno a ser procurado:\n\n");
12. gets (nome);
13. for (i = 0; i < 30; i++) {
14. if ( strcmp(alunos [i], nome) == 0 ) {
15. printf ("\n\nO nome foi encontrado!!");
16. }
17. }
19. }
Exemplo 4
Neste exemplo, é feita a simulação de um dicionário de inglês para português, que
armazena 50 palavras. Nesse caso, são utilizados 2 dois vetores de strings, sendo o
primeiro para armazenar as palavras em inglês e, o segundo, para armazenar a
tradução das respectivas palavras para o português. Em seguida, o usuário faz uma
consulta por uma palavra em inglês que esteja armazenada no vetor e o programa
exibe a tradução para o português.
4. main () {
5. char ingles [50][30], portugues [50][30], palavra [30];
6. int i;
7. for (i = 0; i < 50; i++) {
8. printf ("\n\nDigite palavra em ingles: ");
9. gets (ingles [i]);
10. printf ("\n\nDigite a tradução para o portugues: ");
11. gets (portugues [i]);
12. }
13. printf ("\n\n Digite uma palavra em inglês para saber a tradução para o
portugues:\n\n");
14. gets (palavra);
15. for (i = 0; i < 50; i++) {
16. if ( strcmp(ingles [i], palavra) == 0 ){
17. printf ("\n\nPalavra em portugues =");
18. puts (portugues [i]);
19. }
20. }
22. }
Definição e aplicação de Ponteiros

em C
Apresentar o conceito de ponteiros e aplicá-los utilizando a linguagem C.
NESTE TÓPICO
NESTE TÓPICO
Introdução
Definição
Declaração do Ponteiro
Operadores para Ponteiros

Exemplo 1
Exemplo 2
Exemplo 3
Exemplo 4
Referências
Marcar
tópico

Introdução
Na maioria das linguagens de programação, as variáveis, quando declaradas,
devem ter um identificador (nome) e um tipo de dados. Quando o programa é
executado, as variáveis declaradas recebem uma identificação para que elas
possam ser localizadas na memória do computador e uma quantidade de bytes.
O identificador para as variáveis são os endereços de memória, que, normalmente,
são representados por números hexadecimais e ocupam o primeiro byte alocado
para elas. No programa a seguir, são utilizadas duas variáveis inteiras, a e b, e, na
figura, é apresentada a simulação da memória do computador quando o programa é
executado. Observe que o endereço de memória de a é 3FFA00C0 e o de b é
4FFA00C0.
Da mesma maneira que existem variáveis do tipo char, int e float na linguagem C,
existem variáveis definidas como ponteiro. Uma variável, quando declarada como
ponteiro, proporciona um modo de acesso às variáveis sem referenciá-las
diretamente.
Os ponteiros podem ser utilizados para diversas finalidades. Dentre elas, cita-se:
 Subprogramas (funções e procedimentos): modificação de argumentos em

subrotinas, quando os parâmetros são passados por referência;
 Alocação dinâmica de memória: permitem a criação de estruturas de dados

complexas, tais como listas encadeadas e árvores binárias;

Definição
Um ponteiro é uma variável especial que armazena endereço de memória ao invés
de armazenar um dado ou valor. O mecanismo usado para isso é o endereço da
variável, sendo o ponteiro a representação simbólica de um endereço. Com isso, é
possível acessar o conteúdo de uma variável de forma indireta.

Declaração do Ponteiro
A única diferença na declaração de ponteiros com relação às variáveis mais
comuns (int, float e char) está no fato dele armazenar endereço de memória. Para
informar que a variável é um ponteiro, basta colocar o símbolo de asterisco (*) ao
lado do tipo da variável. Por exemplo, se o tipo é definido como int, então a
variável declarada como ponteiro só poderá armazenar endereço de memória para
um número inteiro. O símbolo de asterisco é que vai indicar à linguagem C que a
variável é um ponteiro e não uma variável comum.
A forma geral de declaração de um ponteiro em linguagem C é:
tipo *nome-variável;
Onde, tipo é um tipo qualquer de dados e nome-variável é o nome pelo qual o
ponteiro será referenciado.
Exemplos:
 Declaração de um ponteiro denominado px, que armazenará o endereço de

memória de uma variável do tipo int.
int *px;
 Declaração de um ponteiro denominado pc, que armazenará o endereço de

memória de uma variável do tipo char.
char *pc;

Operadores para Ponteiros
A manipulação de variáveis declaradas como ponteiros se faz por meio da
utilização de dois operadores unários, que são os seguintes:
1. * : o operador “asterisco” pode ser utilizado sob 2 formas: na declaração de
ponteiros e para acessar o conteúdo da variável que está sendo apontada
pelo ponteiro. No exemplo abaixo é mostrada a utilização deste operador.

2. & : este operador permite acessar o endereço de memória de uma variável.

Para tanto, ele deve ser utilizado antes do nome da variável.

Exemplo 1
Abaixo é mostrado um exemplo de um programa que possui uma variável inteira x
e um ponteiro px, que contém o endereço de memória de x. Na linha 6, a variável
px é declarada como um ponteiro, utilizando-se o operador * (asterisco). Na linha
7, a variável px recebe o endereço de memória de x, utilizando-se o operador &.
Percebe-se que, na linha 8, para mostrar o endereço de memória de x, é necessário
o uso do operador & e o especificador de formato %p. Na linha 9, para exibir o
conteúdo da variável que está sendo apontada por px (acesso indireto ao conteúdo
de x), é necessário o uso do operador * (asterisco).
3.
4. main(){
5. int x = 15;
6. int *px;
7. px = &x;
8. printf ("Endereco de memoria de x = %p", &x);
9. printf ("Conteudo da variavel x por meio do ponteiro px = %d", *px);
10. printf ("Conteudo da variavel px = %p", px);
11. printf ("Endereco de memoria de px = %p", &px);
13. }
Na Figura abaixo, é mostrada uma simulação do programa acima. Quando o

programa for executado, irão aparecer as seguintes mensagens na tela: “Endereco
de memória de x = 3FFA00C0”, “Conteudo da variável x por meio do ponteiro px
= 15”, ”Conteudo da variável px = 3FFA00C0” e “Endereco de memória de
px=4FFA00C0”.

Exemplo 2
A seguir, apresentamos um exemplo completo de um programa com as variáveis p
e q como ponteiros para número inteiro. Observe que, na linha 10, é feita uma
atribuição à variável q, que passa a ter o mesmo valor (endereço de memória de a)
armazenado em p. Na linha 11, ao modificarmos o conteúdo apontado por q, o
valor armazenado em a será alterado, visto que a variável q também aponta para a
variável a.
3.
4. main(){
5. int a, b;
6. int *p, *q;
7. a = 5;
8. b = 15;
9. p = &a;
10. q = p;
11. *q = 25;
12. printf ("Conteudo da variavel a = %d", a);
14. }
programa for executado, irá aparecer a seguinte mensagem na tela: “Conteudo da
variavel a = 25”.

Exemplo 3
O programa abaixo contém as variáveis pa e pb como ponteiros para número real
(float). Observe que, na linha 11, ocorre a atribuição da soma dos valores das
variáveis a e b à variável r, de forma indireta, por meio da utilização dos ponteiros.
3.
4. main(){
5. float a, b, r;
6. float *pa, *pb;
7. a = 7.3;
8. b = 11.5;
9. pa = &a;
10. pb = &b;
11. r = *pa + *pb;
12. printf ("Soma de a e b via ponteiros = %f", r);
14. }
programa for executado, irá aparecer a seguinte mensagem na tela: “Soma de a e b
via ponteiros = 18.8”.

Exemplo 4
Neste programa, uma variável ponteiro armazena o endereço de memória de uma
variável n do tipo int. Em seguida, é feita a divisão de n por 5, sem utilizar o valor
de n diretamente.
3. main () {
4. int n = 5;
5. int *pn;
6. pn = &n;
7. *pn = *pn / 5;
8. printf ("\n Valor de n = %d", *pn);
10. }
Ponteiros para Ponteiros

Apresentar conceitos adicionais sobre ponteiros e aplicar tais conceitos utilizando
a linguagem C.
NESTE TÓPICO
NESTE TÓPICO
Ponteiro para ponteiros

Declaração
Exemplo 1
Referências
Marcar
tópico

Ponteiro para ponteiros

Na linguagem C, também é possível criar um ponteiro que aponta para outro
ponteiro, criando assim níveis, pois um ponteiro poderá apontar para outro
ponteiro, que, por sua vez, aponta para outro ponteiro, que aponta para um ponteiro
diferente e assim por diante.
A sintaxe para se criar ponteiros para ponteiros é a mesma de ponteiros comuns,
apenas a forma de acessar seus valores é diferente. Por exemplo, se um ponteiro
aponta para um ponteiro que aponta para um valor inteiro, para acessarmos esse
valor inteiro a partir do primeiro ponteiro usaríamos dois asteriscos (**), ao invés
de apenas um (*).

Declaração
A forma geral de declaração de um ponteiro que armazena outro ponteiro é a
seguinte:
tipo **nome-variável;
Onde, tipo é um tipo qualquer de dados e nome-variável é o nome pelo qual o
ponteiro será referenciado.
Exemplos:
 Declaração de um ponteiro para outro ponteiro denominado Ppx, que

armazenará o endereço de memória de um ponteiro que armazena o
endereço de uma variável do tipo int.
int **Ppx;
 Declaração de um ponteiro para outro ponteiro denominado Ppy, que

armazenará o endereço de memória de um ponteiro que armazena o
endereço de uma variável do tipo float.
float **Ppy;

Exemplo 1
A seguir, apresentamos um exemplo de um programa que possui uma variável
inteira x inicializada com o valor 25, um ponteiro px e um ponteiro para ponteiro
Ppx. Na linha 7, o endereço da variável x foi atribuído à px e, na linha 8, foi
atribuído o endereço do ponteiropxao ponteiro Ppx. Neste momento, Ppx passa a
apontar para px.
3.
4. main(){
5. int x = 25;
6. int *px, **Ppx;
7. px = &x;
8. Ppx = &px;
9. printf ("Conteudo da variavel x por meio do ponteiro Ppx = %d", **Ppx);
11. }
programa for executado, irá aparecer a seguinte mensagem na tela: “Conteudo da
variavel x por meio do ponteiro Ppx = 25”.

Conceitos iniciais sobre

Programação Estruturada em C
Apresentar conceitos sobre programação estruturada ou modular e aplicar tais
conceitos utilizando a linguagem C.
NESTE TÓPICO
NESTE TÓPICO
Introdução
Exemplo 1
Exemplo 2
Referências
Marcar
tópico

Introdução
A maioria das linguagens de programação permite a construção de programas
estruturados, que consiste na divisão de grandes tarefas de computação em partes
menores, a fim de utilizar seus resultados parciais para compor o resultado final
desejado. Dessa forma, há uma diminuição da extensão dos programas, de forma
que qualquer alteração poderá ser feita mais rapidamente, caso seja necessária. A
modularização é uma técnica utilizada para desenvolver algoritmos, na qual se
divide o problema em pequenas partes denominadas módulos, sendo estes também
conhecidos também como sub-rotinas, sub-programas ou sub-algoritmos.
Ao desenvolvermos um programa, muitas vezes precisamos utilizar uma pequena
rotina repetidamente em mais de um local do mesmo, quando fazemos isso,
estamos ocupando mais espaço de memória, aumentando a complexidade do
algoritmo, aumentando o tamanho do programa. Para evitar tudo isso, podemos
modularizar o programa.
A principal vantagem da modularização é possibilitar o reaproveitamento de
código, já que podemos utilizar um módulo várias vezes, eliminando assim a
necessidade de escrever o mesmo código em situações repetitivas.
Ao trabalhar com essa técnica, pode ser necessário dividir um módulo em outras
tantas quantas forem necessárias, buscando uma solução mais simples de uma parte
do problema maior. As vantagens da programação estruturada são:
 Deixar o programa mais legível e fácil de entender.
 Encontrar e corrigir erros com mais facilidade.
 Facilitar os testes, diminuindo a probabilidade de erros.
 Reduzir o tempo e custo da programação.
 Possibilitar o reaproveitamento de partes do programa (módulos).
Para exemplificar a técnica de programação estruturada ou modular, abaixo segue

os exemplos de um mesmo programa construído de duas maneiras diferentes: sem
modularização e com modularização.

Exemplo 1
O programa consiste em uma calculadora básica que realiza as operações de
adição, subtração, multiplicação e divisão. Nesse caso, o programa foi criado sem
modularização.
1. #include<stdio.h>
2. #include<stdlib.h>
3. #include<conio.h>
4. main ()
5. {
6. int opcao=0;
7. float A, B, R;
8.
9. while (opcao!=5)
10. {
11. system("cls");
12. printf("\n1-adicao");
13. printf("\n2-subtracao");
14. printf("\n3-multiplicacao");
15. printf("\n4-divisao");
16. printf("\n5-sair");
17. printf("\n\n-Escolha um num:");
18. scanf("%d",&opcao);
19.
20. switch(opcao)
21. {
22. case 1:
23. {
24. printf("\nDigite o primeiro numero: ");
25. scanf("%f",&A);
26. printf("\nDigite o segundo numero: ");
27. scanf("%f",&B);
28. R=A + B;
29. printf ("\n\nO resultado e=%0.2f",R);
30. getch();
31. break;
32. }
33. case 2:
34. {
36. scanf("%f",&A);
38. scanf("%f",&B);
39. R=A - B;
41. getch();
42. break;
43. }
44.
45. case 3:
46. {
48. scanf("%f",&A);
50. scanf("%f",&B);
51. R=A * B;
53. getch();
54. break;
55. }
56. case 4:
57. {
59. scanf("%f",&A);
61. scanf("%f",&B);
62. R=A / B;
64. getch();
65. break;
66. }
67. default:
68. printf("\nEsta operacao nao existe");
69. }
70. }
72. }
No exemplo acima, percebe-se que existe redundância com relação a trechos de

códigos que se repetem várias vezes. Agora, imaginando outra situação em que um
programa com cinco mil linhas foi construído de forma não estruturada, ou seja,
toda codificação foi feita dentro do programa principal (main) e com vários trechos
de códigos que se repetem. Isso não é bom, pois pode demandar tempo e trabalho
desnecessário quando da manutenção do programa.
O programa da calculadora apresentado anteriormente permite que seja aplicada a
técnica de modularização, pois nos 4 módulos de cálculo existem instruções que
realizam as mesmas tarefas. Por exemplo: a entrada e a saída são efetuadas com as
mesmas variáveis. A solução é definir as variáveis A, B e R como globais e
construir mais dois módulos, uma para entrada e a outra para saída. Os quatro
módulos atuais serão diminuídos em número de linhas, pois tudo o que se repete
nos módulos será retirado. Observe a declaração das variáveis A, B e R como
globais e a definição e chamada de dois novos módulos, entrada e saída. No
exemplo abaixo é mostrado, como comentários, os módulos que serão utilizados no
programa, sendo que, mais adiante, será explicado como eles são definidos na
linguagem C.

Exemplo 2
O programa consiste em uma calculadora básica que realiza as operações de
adição, subtração, multiplicação e divisão. Nesse caso, o programa foi criado com
modularização.
4.
5. float A, B, R;
6.
7. /***********************************************
8. Definicao do MODULO DE ENTRADA
9. */**********************************************
10.
11. /***********************************************
12. Definicao do MODULO ADICAO
13. */**********************************************
14.
15. /***********************************************
16. Definicao do MODULO DE SUBTRACAO
17. */**********************************************
18.
19. /***********************************************
20. Definicao do MODULO DE MULTIPLICACAO
21. */**********************************************
22.
23. /***********************************************
24. Definicao do MODULO DE DIVISAO
25. */**********************************************
26.
27. /***********************************************
28. Definicao do MODULO DE SAIDA
29. */**********************************************
30.
31.
32. main ()
33. {
34. int opcao=0;
35.
36. while (opcao!=5)
37. {
38. system("cls");
46.
47. switch(opcao)
48. {
49. case 1:
50. {
51. /**********************************************
52. Utilizacao do MODULO DE ENTRADA
53. */**********************************************
54.
55. /**********************************************
56. Utilizacao do MODULO ADICAO
57. */**********************************************
58.
59. /**********************************************
60. Utilizacao do MODULO DE SAIDA
61. */**********************************************
62.
63. break;
64. }
65. case 2:
66. {
67. /**********************************************
69. */**********************************************
70.
71. /**********************************************
72. Utilizacao do MODULO SUBTRACAO
73. */**********************************************
74.
75. /**********************************************
77. */**********************************************
78.
79. break;
80. }
81. case 3:
82. {
83. /**********************************************
85. */**********************************************
86.
87. /**********************************************
88. Utilizacao do MODULO MULTIPLICACAO
89. */**********************************************
90.
91. /**********************************************
93. */**********************************************
94.
95. break;
96. }
97. case 4:
98. {
99. /**********************************************
101. */**********************************************
102.
103. /**********************************************
104. Utilizacao do MODULO DIVISAO
105. */**********************************************
106.
107. /**********************************************
109. */**********************************************
110.
111. break;
112. }
113. default:
115. }
116. }
118. }
Programação estruturada ou
modular - tipos de módulos
Apresentar conceitos adicionais sobre programação estruturada e aplicar tais
NESTE TÓPICO
NESTE TÓPICO
Tipos de Módulos
Procedimentos
Exemplo 1
Funções
Exemplo 2
Utilização dos Procedimentos e Funções
Exemplo 3
Exemplo 4
Exemplo 5
Referências
Marcar
tópico

Tipos de Módulos
Basicamente, há 2 tipos de módulos: procedimentos e funções. Entre esses dois
tipos de módulos existem algumas diferenças, mas o conceito é mesmo para
ambas.
O importante no uso prático desses dois tipos de módulo é distinguir as diferenças
entre eles e como utilizá-Ios no momento mais adequado.

Procedimentos
Um procedimento é um bloco de programa contendo início e fim, identificado por
um nome, por meio do qual será referenciado em qualquer parte do programa
principal ou em outro procedimento. A característica principal de um procedimento
é que não há retorno de valor ou variável, pois, no momento da execução do
programa, somente as instruções definidas dentro do escopo do procedimento são
executadas. Quando um procedimento é chamado por um programa, ele é
executado até o seu término e a execução do programa volta exatamente para a
primeira linha de instrução, após a linha que fez a chamada do procedimento.
A forma geral para se definir um procedimento é a seguinte:
void nome-do-procedimento (lista de parâmetros){
corpo do procedimento (instruções)
}

Exemplo 1
A seguir, apresentamos a definição do Módulo de Entrada citado no exemplo da
calculadora. Quando este procedimento for chamado e executado, será solicitada a
entrada ao usuário das variáveis A e B.
1. void Entrada ( )
2. {
4. scanf("%f",&A);
6. scanf("%f",&B);
7. }
Funções
Uma função também é um bloco de programa, como são os procedimentos,
contendo início e fim e identificada por um nome, pelo qual também será
referenciada em qualquer parte do programa principal. A principal diferença entre
um procedimento e uma função está no fato de uma função retornar um
determinado valor, sendo que o tipo de dado (int, float, char) de tal valor deve ser
definido na criação da função. A forma geral para se definir uma função é a
seguinte:
tipo-de-dado nome-da-função (lista de parâmetros){
corpo da função (instruções)
return (variável/valor);
}

Exemplo 2
A seguir, apresentamos a definição do Módulo Adição citado no exemplo da
calculadora. Quando esta função for chamada e executada, será feito o cálculo de
adição das variáveis A e B, o qual será atribuído à variável R, que será o retorno da
função.
1. float Adicao ( )
2. {
3. R = A + B;
4. return (R);
5. }
Utilização dos Procedimentos e Funções

A definição de procedimentos e funções só faz sentido se eles forem utilizados em
alguma parte do programa. Os procedimentos e funções, em geral, são utilizados
dentro do programa principal. Entretanto, eles também podem ser chamados em
outros módulos.
A forma geral da utilização de um procedimento é a seguinte:
nome-do-procedimento (lista de parâmetros);
Para utilizarmos uma função, normalmente, devemos declarar uma variável que
receberá o retorno da função. Então, a forma geral da utilização de uma função é a
seguinte:
Variável = nome-da-função (lista de parâmetros);

Exemplo 3
Para exemplificarmos a utilização dos procedimentos e funções, abaixo segue o
programa da calculadora escrito de forma estruturada ou modular. Observe que a
entrada e saída de dados foram transformadas em procedimentos e as operações
matemáticas em funções.
4.
5. float A, B, R;
6.
7. void Entrada ( )
8. {
10. scanf("%f",&A);
12. scanf("%f",&B);
13. }
14.
15. float Adicao ( )
16. {
17. R = A + B;
18. return (R);
19. }
20. float Subtracao ( )
21. {
22. R = A - B;
23. return (R);
24. }
25. float Multiplicacao ( )
26. {
27. R = A * B;
28. return (R);
29. }
30. float Divisao ( )
31. {
32. R = A / B;
33. return (R);
34. }
35.
36. main ()
37. {
38. int opcao=0;
39. float result;
40.
42. {
43. system("cls");
51.
52. switch(opcao)
53. {
54. case 1:
55. {
56. Entrada ();
57. result = Adicao ();
58. printf ("\n A + B = %f", result);
59. break;
60. }
61. case 2:
62. {
63. Entrada ();
64. result = Subtracao ();
65. printf ("\n A - B = %f", result);
66. break;
67. }
68. case 3:
69. {
70. Entrada ();
71. result = Multiplicacao ();
72. printf ("\n A * B = %f", result);
73. break;
74. }
75. case 4:
76. {
77. Entrada ();
78. result = Divisao ();
79. printf ("\n A / B = %f", result);
80. break;
81. }
82.
83. default:printf("\nEsta operacao nao existe");
84. }
85. }
86. system("PAUSE");
87. }
Existe, também, outra forma de estruturarmos um programa por meio de módulos,

os quais podem ser definidos após o programa principal (main). Neste caso, como
os módulos são criados após o programa principal, então deverá haver um
protótipo para cada módulo logo após a seção include. O protótipo consiste no
cabeçalho do módulo.

Exemplo 4
Para ilustrarmos melhor esta outra forma para estruturarmos o programa, abaixo
segue o mesmo exemplo da Calculadora, no qual os módulos são criados após o
programa principal.
4.
5. float A, B, R;
6.
7. /******************************
8. Prototipos dos modulos
9. *******************************/
10. void Entrada ();
11. float Adicao ();
12. float Subtracao ();
13. float Multiplicacao ();
14. float Divisao ();
15.
16. /******************************/
17.
18. main ()
19. {
20. int opcao=0;
21. float result;
22.
24. {
25. system("cls");
33.
34. switch(opcao)
35. {
36. case 1:
37. {
38. Entrada ();
39. result = Adicao ();
40. printf ("\n A + B = %f", result);
41. break;
42. }
43. case 2:
44. {
45. Entrada ();
46. result = Subtracao ();
47. printf ("\n A - B = %f", result);
48. break;
49. }
50. case 3:
51. {
52. Entrada ();
53. result = Multiplicacao ();
54. printf ("\n A * B = %f", result);
55. break;
56. }
57. case 4:
58. {
59. Entrada ();
60. result = Divisao ();
61. printf ("\n A / B = %f", result);
62. break;
63. }
64.
65. default:
67. }
68. }
69. }
70. void Entrada ( )
71. {
73. scanf("%f",&A);
75. scanf("%f",&B);
76. }
77.
78. float Adicao ( )
79. {
80. R = A + B;
81. return (R);
82. }
83. float Subtracao ( )
84. {
85. R = A - B;
86. return (R);
87. }
88. float Multiplicacao ( )
89. {
90. R = A * B;
91. return (R);
92. }
93. float Divisao ( )
94. {
95. R = A / B;
96. return (R);
97. }
Exemplo 5
Neste exemplo, o programa contém os seguintes módulos:
1. Um procedimento para a leitura da variável n.
2. Um procedimento que calcula e mostra o dobro do valor de n.
3. Uma função que verifica se o número n é par ou ímpar. Se n é par, então a
função retorna 1. Se n é ímpar, a função retona 0 (zero).

Observação: os módulos são chamados no programa principal (main) e a variável n
é declarada como global.
3. int n;
4.
5. void entrada (){
6. printf ("\n Digite o valor de n=");
7. scanf ("%d", &n);
8. }
9.
10. void dobro (){
11. n = n*2;
12. printf ("\n Dobro de n=%d",n);
13. }
14. int paridade (){
15. if (n%2==0)
16. return (1);
17. else return (0);Prática de Programação
18. }
19. main () {
20. int par_impar;
21.
22. entrada ();
23. dobro();
24. par_impar = paridade ();
25.
26. if (par_impar==1)
27. printf ("\n O numero e par");
28. else printf ("\n O numero e impar");
29.
31. }
Parâmetros e passagem de
parâmetros em programação
estruturada
Apresentar conceitos sobre a utilização de parâmetros em programação estruturada
e aplicar tais conceitos utilizando a linguagem C.
NESTE TÓPICO
NESTE TÓPICO
Introdução
Parâmetros formais e reais
Exemplo 1
Passagem de parâmetros
Passagem de parâmetro por valor
Exemplo 2
Passagem de parâmetro por referência
Exemplo 3
Exemplo 4
Referências
Marcar
tópico

Introdução
Os parâmetros servem um ponto de comunicação bidirecional entre um módulo e o
programa principal ou outro módulo hierarquicamente de nível mais alto. É
possível passar valores de um módulo ou módulo chamador a outro módulo e vice-
versa, utilizando parâmetros que podem ser formais ou reais.

Parâmetros formais e reais
Serão considerados parâmetros formais quando forem declarados por meio de
variáveis juntamente com a identificação do nome do módulo, os quais serão
tratados exatamente da mesma forma que são tratadas as variáveis globais ou
locais. Serão considerados parâmetros reais quando substituírem os parâmetros
formais, quando da utilização do módulo por um programa principal.
A forma geral do cabeçalho de um módulo com a declaração de parâmetros
formais em linguagem C é:
void / tipo-retorno nome-módulo (tipo-parametro nome-parametro, .......)
Onde, void / tipo-retorno depende do tipo de módulo (procedimento ou função,
respectivamente), nome-módulo é o nome que se deve dar ao módulo e tipo-
parametro nome-parametro corresponde à declaração do parâmetro. Vale lembrar
que podemos declarar quantos parâmetros forem necessários.
Exemplo:
- Declaração do cabeçalho do procedimento “Exemplo”, que terá como parâmetros
duas variáveis inteiras x e y.
void Exemplo (int x, int y)

Exemplo 1
O programa abaixo mostra uma função cujo objetivo é verificar e retornar o maior
valor entre duas variáveis (a e b), as quais são definidas como parâmetros formais.
Na chamada da função, no programa principal, as variáveis p e q são definidas
como parâmetros reais.
3.
4. int verifica_maior (int a, int b) //a e b sao Parametros FORMAIS
5. {
6. if (a > b)
7. return (a);
8. else return (b);
9. }
10.
11. main ()
12. {
13. int p=7, q=10;
14. int maior;
15. maior = verifica_maior (p, q); //p e q sao Parametros REAIS
16. printf ("\n Maior elemento = %d", maior);
17. }
Passagem de parâmetros
A passagem de parâmetro ocorre quando é feita uma substituição dos parâmetros
formais pelos reais no momento da execução do módulo. Esses parâmetros são
passados por variáveis de duas formas: por valor e por referência.

Passagem de parâmetro por valor
A passagem de parâmetro por valor caracteriza-se pela não-alteração do valor do
parâmetro real quando o parâmetro formal é manipulado dentro do módulo. Assim
sendo, o valor passado pelo parâmetro real é copiado para o parâmetro formal, que
no caso assume o papel de variável local do módulo. Qualquer modificação, que
ocorra na variável local do módulo, não afeta o valor do parâmetro real
correspondente, ou seja, o processamento é executado somente dentro do módulo,
ficando o resultado obtido "preso" no módulo.

Exemplo 2
No programa abaixo, o procedimento possui apenas um parâmetro formal (x), o
qual é passado por valor. Este parâmetro é alterado pelo valor de seu quadrado
dentro do procedimento, porém tal alteração só é válida dentro do procedimento.
3.
4. void quadrado (int x)
5. {
6. x = x*x;
7. printf ("\n Valor de x = %d", x);
8. }
9.
10. main ()
11. {
12. int x = 4;
13. quadrado (x);
14. printf ("\n Valor de x = %d", x);
16. }
Na Figura abaixo, é mostrada a simulação das alocações das variáveis na memória

quando o programa acima é executado. Embora o parâmetro formal tenha o mesmo
nome que o parâmetro real, as variáveis ocupam posições diferentes na memória.
Assim, notamos que a alteração é feita somente no parâmetro formal, sendo que o
parâmetro real mantém seu valor. Dessa forma, o programa exibirá duas
mensagens na tela: “Valor de x = 16” e “Valor de x = 4”.

Passagem de parâmetro por referência

A passagem de parâmetro por referência ocorre quando o parâmetro real recebe o
conteúdo do parâmetro formal e, após um certo processamento dentro do módulo,
o parâmetro formal reflete a alteração de seu valor junto ao parâmetro real.
Qualquer modificação feita no parâmetro formal implica em alteração do
parâmetro real correspondente. A alteração efetuada é devolvida para a rotina
chamadora.

Exemplo 3
No programa abaixo, o procedimento possui apenas um parâmetro (n), o qual é
passado por referência. Para tanto, é necessário declarar o parâmetro formal como
um ponteiro (asterisco antes do nome do parâmetro), que permitirá a alteração do
parâmetro formal reflita sobre o parâmetro real. Na chamada do procedimento, é
necessário passar o endereço de memória de n.
3.
4. void dobro (int *n)
5. {
6. *n = 2*(*n);
7. printf ("\n Valor de n = %d", *n);
8. }
9.
10. main ()
11. {
12. int n = 8;
13. dobro (&n);
14. printf ("\n Valor de n = %d", n);
16. }
Na Figura abaixo, é mostrada a simulação das alocações das variáveis na memória

quando o programa acima é executado. Embora o parâmetro formal tenha o mesmo
nome que o parâmetro real, as variáveis ocupam posições diferentes na memória.
Assim, notamos que a alteração do parâmetro real é feita de forma indireta por
meio do parâmetro formal, que é definido como um ponteiro. Por fim, o programa
exibirá duas mensagens na tela: “Valor de n = 16” e “Valor de n = 16”.

Exemplo 4
Neste exemplo, o programa contém os seguintes módulos:
1. Uma função com dois parâmetros, por valor, denominados “ini” e “fim”. É
feito o cálculo e o valor da soma de todos os números pares entre “ini” e
“fim” é retornado.
2. Um procedimento com dois parâmetros, sendo o primeiro “opcao” por valor

e o segundo “n” por referência. Se “opcao” é igual a 1, então, é feito o
cálculo do dobro do valor de “n”. Se “opcao” é igual a 2, o triplo do valor de
“n” é calculado. O valor de n, alterado por referência dentro do
procedimento, é mostrado no "main".
3.
4. int soma_valores (int ini, int fim) {
5. int i, soma = 0;
6. for (i=ini;i<=fim;i++)
7. soma = soma + i;
8. return (soma);
9. }
10.
11. void calcula_dobro_triplo (int opcao, int *n) {
12. if (opcao==1)
13. *n = *n * 2;
14. else if (opcao==2)
15. *n = *n * 3;
16. }
17.
18. main () {
19. int ini = 1, fim = 10, n=4, soma, opcao;
20.
21. soma = soma_valores (ini, fim);
22. printf ("\n Valor da soma = %d", soma);
23.
24. printf ("\n Digite a opcao =");
25. scanf ("%d", &opcao);
26. calcula_dobro_triplo (opcao, &n);
27. printf("Valor de n = %d", n);
28.
30. }
Passagem de vetor como parâmetro

e macros
Apresentar o conceito de passagem de vetor como parâmetro para função e também
o conceito de macros, e aplicá-los utilizando a linguagem C.
NESTE TÓPICO
NESTE TÓPICO
Introdução
Exemplo 1
Exemplo 2
Exemplo 3
Macros
Exemplo 4
Exemplo 5
Referências
Marcar
tópico

Introdução
Como uma variável simples, um vetor também pode ser passado como parâmetro
para uma função. O tipo de passagem de parâmetro de um vetor para uma função é
sempre por referência.
Para indicarmos que um parâmetro de uma função é um vetor, basta colocarmos
colchetes após o nome do parâmetro. Na especificação da função não é necessário
colocar o tamanho do vetor. O exemplo a seguir define o protótipo de uma função f
que tem como parâmetro um vetor v do tipo inteiro.
void f (int v []);
Quando chamamos uma função que tem como parâmetro um vetor, basta apenas
passar o nome do vetor para a função. Analise o trecho de código seguinte.
1. // declaração e inicialização do vetor

2. int vetor [3] = {2, 4, 6};
3. // passagem do vetor para a função f definida anteriormente
4. f (vetor);
No exemplo anterior criamos e inicializamos um vetor de três posições. Esse vetor

foi posteriormente passado como parâmetro para a função f, definida
anteriormente. Note que é só passar o nome do vetor como argumento para a
função.

Exemplo 1
A seguir apresentamos um exemplo completo de um programa em linguagem C,
que utiliza passagem de vetor como parâmetro para função. Vamos criar duas
funções: uma que inicializa todas as posições do vetor com valor 1 e outra que
apresenta os dados do vetor na tela. Analise o trecho de código.
3. // constante simbolica que representa o tamanho do vetor
4. #define TAM 10
5. // definição da função inicializaVetor
6. void inicializaVetor(int v[]) {
7. int i;
8. for (i = 0; i < TAM; i++) {
9. v[i] = 1;
10. }
11. }
12. // definição da função imprimeVetor
13. void imprimeVetor(int v[ ]) {
14. int i;
15. for (i = 0; i < TAM; i++) {
16. printf ("%d ", v[i]);
17. }
18. }
19. main () {
20. int vetor[TAM];
21. // chama a funcao inicializaVetor
22. inicializaVetor(vetor);
23. // chama a função imprimeVetor
24. imprimeVetor(vetor);
26. system("PAUSE");
27. }
Exemplo 2
Neste exemplo, é criada uma função que recebe como parâmetro um vetor de
valores inteiros com 5 posições e retorna a soma dos valores do vetor. A função é
chamada no "main" e o valor da soma é mostrado na tela.
3. // constante simbólica para representar o tamanho do vetor
4. #define TAM 5
5.
6. // definição da função que recebe como parametro um vetor de inteiros
7. int somaValores (int vet[]) {
8. int i, soma = 0;
9. for (i = 0; i < TAM; i++) {
10. soma += vet[i];
11. }
12. return soma;
13. }
14.
15. main () {
16. int vetor[TAM];
17. int i;
19. printf ("*** Informe os dados para o vetor ***\n");
20. for (i = 0; i < TAM; i++) {
23. }
24. // chamada da funcao somaValores
25. int s = somaValores (vetor);
26. // impressao do retorno na tela
27. printf ("\nSoma = %d\n\n", s);
29. }
Exemplo 3
Neste exemplo, é criado um procedimento (função void) que recebe como
parâmetro um vetor com 7 valores inteiros e altera todos os valores pares para zero
.O procedimento é chamado no "main" e os valores alterados do vetor são
mostrados na tela.
3. // constante simbólica para representar o tamanho do vetor
4. #define TAM 7
5.
6. // definição da função
7. void alteraPares (int vet[]) {
8. int i;
9. for (i = 0; i < TAM; i++) {
10. // verifica ser o valor é par
11. if (vet[i] % 2 == 0) {
12. vet[i] = 0;
13. }
14. }
15. }
16. main () {
17. int vetor[TAM];
18. int i;
20. printf ("*** Informe os dados para o vetor ***\n");
21. for (i = 0; i < TAM; i++) {
24. }
25. // chamada da funcao alteraPares
26. alteraPares (vetor);
27. // impressao do vetor
29. for (i = 0; i < TAM; i++) {
31. }
34. }
Macros
Como já é sabido, a diretiva #define serve para definirmos constantes simbólicas.
Essa diretiva tem ainda a habilidade de usar parâmetros. Uma diretiva #define com
parâmetros é chamada de macro e é bastante semelhante a uma função. A seguir
apresentamos um exemplo do uso de macro.
3. // definição da macro
4. #define PRN(n) printf("%.2f\n", n)
5. main() {
6. float num1 = 27.25;
7. float num2 = 1.0/3.0;
8. // chamada a macro
9. PRN(num1);
10. PRN(num2);
12. }
No exemplo anterior definimos uma macro, denominada PRN, que tem n como

parâmetro. Note que os parâmetros de uma macro devem ficar entre parênteses,
como se fosse uma função. Após a definição do nome e dos parâmetros da macro,
definimos o seu significado, utilizando o parâmetro especificado.
As chamadas às macros são substituídas no programa pelo seu significado. Assim,
toda ocorrência de PRN(n) do exemplo será trocada por printf("%.2f\n", n), de tal
forma que no lugar de n é usado o argumento da chamada à macro.
Na definição de uma macro, nunca deve haver espaço em branco no identificador.
Por exemplo:
#define PRN (n) printf("%.2f\n", n)
Não funcionará, porque o espaço entre PRN e (n) é interpretado como fim do
identificador.

Exemplo 4
A seguir apresentamos outro exemplo do uso de macro. O programa cria uma
macro para calcular a área de uma circunferência. Posteriormente, essa macro é
chamada na função main().
3. // definição da constante simbolica PI
4. #define PI 3.1415
5. // definição da macro
6. #define AREA(r) (PI * r * r)
7. main() {
8. float raio;
9. printf ("Raio: ");
10. scanf ("%f", &raio);
11. // chamada a macro
12. float area = AREA(raio);
13. printf ("Area = %.2f\n", area);
15. }
Exemplo 5
Neste exemplo, é criada uma macro denominada quad, que recebe como parâmetro
um número e calcula o quadrado desse número. No "main" é feita a chamada da
macro criada e seu retorno é apresentado na tela.
3. // definiçao da macro quad
4. #define quad(n) (n*n)
5.
6. main () {
7. int num;
9. scanf ("%d", &num);
10. // chamada da macro
11. int quadrado = quad(num);
12. printf ("\nQuadrado = %d\n\n", quadrado);
14. }
Agora que você já estudou essa aula acesse, Resolva os exercícios propostos e
verifique o seu conhecimento. Caso fique alguma dúvida, leve a questão ao Fórum
e divida-a com seus colegas e professor.
Conceitos iniciais sobre Registros
(Estruturas) em C
Apresentar o conceito de estruturas (structs) e aplicar tal conceito utilizando a
linguagem C.
NESTE TÓPICO
NESTE TÓPICO
Estruturas
Definição de estruturas
Declaração de variáveis do tipo estrutura
Referenciando campos de uma estrutura
Lendo dados para campos de uma estrutura
Acessando dados de uma estrutura
Exemplo 1
Exemplo 2
Exemplo 3
Referências
Marcar
tópico

Estruturas

Até agora, vimos que os dados manipulados pelos programas são armazenados em
variáveis simples, ou em um vetor, uma estrutura de dados homogênea, que
permite armazenar uma coleção de dados do mesmo tipo.
Vamos agora estudar outra forma de manipulação de dados pelos programas,
conhecida como estrutura de dados heterogênea. Este tipo de estrutura permite
armazenar uma coleção de dados de tipos diferentes. Em linguagem C, essa forma
de manipulação de dados é denominada estrutura ou registro (struct). Uma
estrutura em C corresponde ao conceito de registro de algumas linguagens de
programação, como o PASCAL.
Uma estrutura é uma coleção arbitrária de variáveis logicamente relacionadas
agrupadas sob um único nome, de forma a facilitar a sua referência. As estruturas
podem conter variáveis de qualquer tipo de dados válidos em C (tipos básicos,
vetores, strings, ponteiros ou mesmo outras estruturas). As variáveis que fazem
parte de uma estrutura são denominadas membros ou campose são identificadas
por nomes. A figura a seguir apresenta a representação gráfica de uma estrutura.
Definição de estruturas
Antes de usarmos uma estrutura, precisamos defini-la. Definimos uma estrutura
pelo seu nome e pelo conjunto de campos que ela contém. A forma geral de
definição de uma estrutura em linguagem C é:

1. struct <nome_estrutura> {
2. <tipo> <nome_campo1>;
3. <tipo> <nome_campo2>;
4. ...
5. <tipo> <nome_campoN>;
6. };
Podemos, por exemplo, criar uma estrutura capaz de armazenar uma data.
1. struct Data {
2.
3. int dia;
4. int mes;
5. int ano;
6.
7. };
No exemplo ilustrado, definimos uma estrutura denominada Data, que contém os

campos dia, mes, ano, todos eles do tipo inteiro.
As estruturas devem ser definidas antes de qualquer função, isso é de maneira
global. Isso permite que as funções tenham acesso a estrutura.

Declaração de variáveis do tipo estrutura
Na seção anterior, vimos como definir uma estrutura. Para a manipulação dos
dados em uma estrutura é preciso declarar uma variável do tipo da estrutura. A
forma geral de declaração de variáveis do tipo estrutura em linguagem C é:
1. struct <nome_estrutura> <nome_variável>;
Por exemplo, vamos declarar uma variável para a estrutura criada da seção
anterior.
1. struct Data hoje;
Referenciando campos de uma estrutura

Uma vez declarada uma variável do tipo estrutura, podemos atribuir dados a seus
campos. A forma geral na linguagem C é:
1. <nome_variavel>.<nome_campo> = valor;
Por exemplo, podemos atribuir valores aos campos da variável do tipo estrutura
declarada na seção anterior.
1. hoje.dia = 20;
2. hoje.mes = 10;
3. hoje.ano = 2013;
Lendo dados para campos de uma estrutura

Imagine que temos a estrutura Data definida na seção anterior e criamos a
variável hoje, que é do tipo desta estrutura. Queremos solicitar ao usuário que
informe os dados para preencher essa variável, para isso vamos usar a
função scanf(). Como em um vetor, não podemos acessar todos os dados ao mesmo
tempo. Em uma estrutura, temos que acessar um campo de cada vez. O trecho de
código a seguir solicita ao usuário para informar dados que preencham a variável
hoje.
1. // declaração de uma variável do tipo Data

2. struct Data hoje;
3. // leitura do campo dia
4. printf ("Dia: ");
5. scanf ("%d", &hoje.dia);
6. // leitura do campo mês
7. printf ("Mes: ");
8. scanf ("%d", &hoje.mes);
9. // leitura do campo ano
10. printf ("Ano: ");
11. scanf ("%d", &hoje.ano);
Acessando dados de uma estrutura

Uma vez preenchida uma estrutura, queremos manipular os seus elementos ou
apresentá-los na tela. Utilizando a variável hoje preenchida na seção anterior,
vamos apresentar seus dados na tela usando a função printf(). Analise o seguinte
trecho de código.
1. // imprime o valor do campo dia

2. printf ("Dia = %d\n", hoje.dia);
3. // imprimi o valor do campo mes
4. printf ("Mês = %d\n", hoje.mes);
5. // imprime o valor do campo ano
6. printf ("Ano = %d\n", hoje.ano);
Exemplo 1
que trabalha com estruturas. O programa cria uma estrutura denominada Data que
contém os campos dia, mes, ano; lê um valor para cada um dos campos da
estrutura e os apresenta na tela.
3. // definição da estrutura Data
4. struct Data {
5. int dia, mes, ano;
6. };
7.
8. main () {
9. // declaracao de uma variavel da estrutura
10. struct Data umaData;
11. // leitura do campo dia
13. scanf ("%d", &umaData.dia);
14. // leitura do campo mes
15. printf ("Mês: ");
16. scanf ("%d", &umaData.mes);
17. // leitura do campo ano
19. scanf ("%d", &umaData.ano);
20. // impressão da tada informada
21. printf ("\n*** Data Informada ***\n");
22. printf ("%d / %d / %d\n\n", umaData.dia, umaData.mes, umaData.ano);
24. }
Exemplo 2
Vamos estudar outro exemplo de utilização de estruturas. Um aluno possui um
código (inteiro), um nome e três notas. O seguinte programa lê os dados de um
aluno, apresenta-os na tela juntamente com a média aritmética de suas notas.
4. // definição da estrutura aluno
5. struct Aluno {
6. int codigo;
7. // o nome é representado por uma string
8. char nome[80];
9. // as notas são armazenadas em um vetor
10. float notas[3];
11. };
12.
13. main () {
14. // declaração da variável da estrutura Aluno
15. struct Aluno umAluno;
16. // leitura do código
17. printf ("Codigo: ");
18. scanf ("%d", &umAluno.codigo);
19. getchar();
20. // leitura do nome. Usamos o comando gets() para ler a string
21. printf ("Nome: ");
22. gets (umAluno.nome);
23. // leitura das notas do aluno. Percorremos o vetor com um for
24. int i;
25. for (i = 0; i < 3; i++) {
26. printf ("Nota %d: ", i + 1);
27. scanf ("%f", &umAluno.notas[i]);
28. }
29. float soma = 0;
30. // calculo da media do aluno
31. for (i = 0; i < 3; i++) {
32. soma += umAluno.notas[i];
33. }
34. printf ("\n*** Dados do Aluno ***\n");
35. printf ("Codigo: %d\n", umAluno.codigo);
37. puts (umAluno.nome);
38. printf ("Notas: %.1f %.1f %.1f\n", umAluno.notas[0], umAluno.notas[1],
umAluno.notas[2]);
39. printf ("Media: %.1f\n\n", soma / 3);
41. }
Exemplo 3

Neste exemplo, é declarada uma estrutura chamada "livro", que contém os
seguintes dados: título, autor, editora e ano de publicação. O programa faz a leitura
dos valores para os campos da estrutura e depois os apresenta na tela.
4. // definiçao da estrutura Livro
5. struct Livro {
6. char titulo[80];
7. char autor[80];
8. char editora[40];
9. int ano;
10. };
11. main () {
12. // declaracao de uma variavel do tipo Livro
13. struct Livro liv;
14. // leitura dos dados do livro
15. printf ("*** Informe os dados do livro ***\n");
16. printf ("Titulo: ");
17. gets (liv.titulo);
18. printf ("Autor: ");
19. gets (liv.autor);
20. printf ("Editora: ");
21. gets (liv.editora);
22. printf ("Ano de Publicacao: ");
23. scanf ("%d", &liv.ano);
24. // impressao dos dados do livro
25. printf ("\n*** Dados do Livro ***\n");
26. printf ("Titulo: %s\n", liv.titulo);
27. printf ("Autor: %s\n", liv.autor);
28. printf ("Editora: %s\n", liv.editora);
29. printf ("Ano de Publicacao: %d\n\n", liv.ano); Prática de Programação
31. }
Agora que você já estudou esta aula, resolva os exercícios e verifique seu
conhecimento. Caso fique alguma dúvida, leve a questão ao Fórum e divida com
seus colegas e professor.
Inicialização de estruturas e
estruturas aninhadas
Apresentar o conceito de inicialização de estruturas e estruturas aninhadas e
aplicar tal conceito utilizando a linguagem C.
NESTE TÓPICO
NESTE TÓPICO
Inicialização de estruturas
Estruturas aninhadas
Exemplo 1
Exemplo 2
Referências
Marcar
tópico

Inicialização de estruturas
Assim como vetores, estruturas podem ser inicializadas no momento de sua
declaração. Para isso, basta fornecer os valores iniciais de seus campos entre
chaves e separados por vírgula. Os valores devem seguir a ordem em que os
campos foram declarados na estrutura.
O exemplo a seguir apresenta a inicialização da estrutura Data.
1. // definição da estrutura
2. struct Data {
4. };
5. ...
6. // declaração e inicialização da variável hoje
7. struct Data hoje = {21, 10, 2013};
Os valores são atribuídos aos campos da estrutura hoje na ordem em que são

fornecidos: o campo dia recebe o valor 21, o mes, 10 e o ano, 2013.

Estruturas aninhadas
É possível criar um tipo de estrutura em que um ou mais de seus campos também
sejam estruturas, desde que os tipos de tais estruturas tenham sido previamente
declarados no programa. Isso é conhecido como estrutura aninhada. A seguir,
apresentamos um exemplo deste tipo de estrutura.
1. struct Data {
2. int dia, mes, int ano;
3. };
4.
5. struct Pessoa {
6. char nome[50];
7. struct Data dataNasc;
8. };
Note que o campo dataNasc é uma estrutura aninhada. Para isso, é necessário que
a estrutura Data tenha sido definida antes da estrutura Pessoa. A próxima figura
apresenta a representação gráfica da estrutura Pessoa.

Ao acessar campos em estruturas aninhadas, podemos usar o operador de seleção
de campo (.) quantas vezes forem necessárias. A seguir, apresentamos um exemplo
de acesso aos campos de uma variável do tipo da estrutura Pessoa.
1. // declaração da variável da estrutura Pessoa

2. struct Pessoa umaPessoa;
3. // atribuição de um nome
4. strcpy (umaPessoa.nome, "Joao");
5. // acesso aos campos da estrutura aninhada
6. umaPessoa.dataNasc.dia = 15;
7. umaPessoa.dataNasc.mes = 5;
8. umaPessoa.dataNasc.ano = 1976;
Para acessar os campos dia, mes e ano, primeiro temos que acessar o

campo dataNasc. Por exemplo, seria um erro escrever umaPessoa.dia, já que a
variável umaPessoa é do tipoPessoa, e esse tipo não tem nenhum campo
chamado dia.
Podemos também declarar e inicializar uma estrutura aninhada. Veja o exemplo
que usa a estrutura aninhada definida anteriormente:
1. // declaração e inicialização da variável da estrutura Pessoa

2. struct Pessoa umaPessoa = {"Joao", {15, 5, 1976}};
Exemplo 1
que trabalha com estruturas aninhadas. Uma pessoa tem um nome, um endereço e
uma data de nascimento. O endereço tem rua, número e bairro. No programa,
vamos criar três estruturas Pessoa, Endereco e Data. O programa lê os dados de
uma pessoa e depois os apresenta na tela.
4. // definição da estrutura Data
5. struct Data {
7. };
8. // definição da estrutura Endereco
9. struct Endereco {
10. char rua[100];
11. char numero[10];
12. char bairro[30];
13. };
14. // definição da estrutura Pessoa
15. struct Pessoa {
16. char nome[80];
17. struct Endereco endereco;
18. struct Data dataNasc;
19. };
20. main () {
21. // declaração da variavel do tipo Pessoa
22. struct Pessoa umaPessoa;
23. // leitura do nome
25. gets (umaPessoa.nome);
26. // leitura do endereco
27. printf ("Rua: ");
28. gets (umaPessoa.endereco.rua);
30. gets (umaPessoa.endereco.numero);
31. printf ("Bairro: ");
32. gets (umaPessoa.endereco.bairro);
33. // leitura da data de nascimento
35. scanf ("%d", &umaPessoa.dataNasc.dia);
36. printf ("Mes: ");
37. scanf ("%d", &umaPessoa.dataNasc.mes);
39. scanf ("%d", &umaPessoa.dataNasc.ano);
40. // impressao dos dados da pessoa
41. printf ("\n\n*** Dados da Pessoa *** \n");
43. puts (umaPessoa.nome);
44. printf ("Endereco: %s, ", umaPessoa.endereco.rua);
45. printf ("%s - ", umaPessoa.endereco.numero);
46. printf ("%s\n", umaPessoa.endereco.bairro);
47. printf ("Data de Nasscimento: %d/", umaPessoa.dataNasc.dia);
48. printf ("%d/", umaPessoa.dataNasc.mes);
49. printf ("%d\n\n", umaPessoa.dataNasc.ano);
51. }
Exemplo 2
Neste exemplo, é definida uma estrutura para armazenar os dados de um voo
(cidades de origem e destino, datas e horários de partida e chegada). Para
armazenar as datas e horários, uma estrutura denominada "DataHorario" é criada e
utilizada como uma estrutura aninhada à estrutura "voo". O programa faz a leitura
dos dados do voo e, por fim, os apresenta na tela.
4. // definicao da estrutura DataHorario
5. struct DataHorario {
7. int hora, minuto;
8. };
9. struct Voo {
10. char origem[80];
11. char destino[80];
12. struct DataHorario partida;
13. struct DataHorario chegada;
14. };
15. main () {
16. // declaração da variavel do tipo Voo
17. struct Voo voo;
18. // leitura dos dados do voo
19. printf ("Cidade de Origem: ");
20. gets (voo.origem);
21. printf ("Cidade de Destino: ");
22. gets (voo.destino);
23. printf ("Dia da Partida: ");
24. scanf ("%d", &voo.partida.dia);
25. printf ("Mes da Partida: ");
26. scanf ("%d", &voo.partida.mes);
27. printf ("Ano da Partida: ");
28. scanf ("%d", &voo.partida.ano);
29. printf ("Hora da Partida: ");
30. scanf ("%d", &voo.partida.hora);
31. printf ("Minutos da Partida: ");
32. scanf ("%d", &voo.partida.minuto);
33. printf ("Dia da Chegada: ");
34. scanf ("%d", &voo.chegada.dia);
35. printf ("Mes da Chegada: ");
36. scanf ("%d", &voo.chegada.mes);
37. printf ("Ano da Chegada: ");
38. scanf ("%d", &voo.chegada.ano);
39. printf ("Hora da Chegada: ");
40. scanf ("%d", &voo.chegada.hora);
41. printf ("Minutos da Chegada: ");
42. scanf ("%d", &voo.chegada.minuto);
43.
44. // impressao dos dados do voo
45. printf ("\n*** Dados do Voo ***\n");
46. printf ("Cidade de Origem: %s\n", voo.origem);
47. printf ("Cidade de Destino: %s\n", voo.destino);
48. printf ("Data/Hora da Partida: %d/%d/%d %d:%d\n", voo.partida.dia,
voo.partida.mes, voo.partida.ano, voo.partida.hora, voo.partida.minuto);
49. printf ("Data/Hora da Chegada: %d/%d/%d %d:%d\n", voo.chegada.dia,
voo.chegada.mes, voo.chegada.ano, voo.chegada.hora, voo.chegada.minuto);
51. }
Conceitos iniciais sobre Tabelas em

C
Apresentar o conceito de tabelas (vetor de estrutura) e aplicar tal conceito
utilizando a linguagem C.
NESTE TÓPICO
NESTE TÓPICO
Introdução
Declaração de uma tabela
Acessando um campo de uma tabela
Exemplo 1
Exemplo 2
Exemplo 3
Referências
Marcar
tópico

Introdução
É possível combinar vetores e estruturas de muitas maneiras. A combinação mais
comum é criar um vetor cujos elementos são estruturas. Um vetor desse tipo é
denominado tabela. Ele é geralmente representado com seus elementos dispostos
em linha e os campos em colunas. A figura a seguir apresenta um exemplo de
tabela de 10 elementos cujos campos são nome e telefone.

Declaração de uma tabela
A declaração de uma tabela é similar a de um vetor. Imagine que temos uma
estrutura denominada Pessoa, podemos declarar uma tabela do tipo Pessoa da
seguinte forma:
struct Pessoa agenda[10];
A variável agenda é um vetor cujos elementos são estruturas do tipo Pessoa. O
vetor declarado anteriormente pode conter até 10 elementos desta estrutura.

Acessando um campo de uma tabela
Para acessarmos um campo de uma tabela, devemos colocar o nome do vetor que
representa a tabela, seguido do índice entre colchetes que está o campo, seguido de
ponto e o nome do campo que queremos acessar. Por exemplo, a instrução a seguir
acessa o campo nome, que está na segunda linha da tabela agenda.
agenda[1].nome;

Exemplo 1
Vamos criar um programa que representa uma agenda eletrônica. Um contato da
agenda tem um nome e um telefone. Vamos criar um vetor de contatos, isto é, uma
tabela que pode armazenar até 5 nomes. O seguinte programa solicita os dados do
contato ao usuário e depois lista os contatos inseridos na agenda.
3. // constante simbolica que representa o tamanho da agenda
4. #define TAM 5
5. // definicao da estrutura Contato
6. struct Contato {
7. char nome[80];
8. char telefone[15];
9. };
10. main () {
11. // declaração da tabela agenda (vetor de contato)
12. struct Contato agenda[TAM];
13. int i;
14. // leitura dos dados da agenda
15. // como agenda é um vetor, usamos um laço for para percorrê-lo
16. for (i = 0; i < TAM; i++) {
18. gets (agenda[i].nome);
19. printf ("Telefone: ");
20. gets (agenda[i].telefone);
21. }
22. // impressao dos contatos da agenda
23. printf ("\n*** Lista de Contatos ***\n");
24. for (i = 0; i < TAM; i++) {
25. printf ("%s - %s\n", agenda[i].nome, agenda[i].telefone);
26. }
28. }
Exemplo 2
Vamos estudar outro exemplo de utilização de tabelas. Um aluno possui uma
matrícula (inteiro), um nome e três notas. O programa que segue lê os dados de 7
alunos, calcula e apresenta a matrícula, o nome e a média aritmética de cada aluno
e também a média da turma.
3. // constante simbolica que representa o tamanho da turma
4. #define TAM 7
5. // definição da estrutura Aluno
6. struct Aluno {
7. int matricula;
8. char nome[80];
9. // as notas são armazenadas em um vetor
10. float notas[3];
11. };
12. main () {
13. // declaração da tabela alunos (vetor de Aluno)
14. struct Aluno alunos[TAM];
15. int i, j;
16. // leitura dos dados dos alunos
17. printf ("*** Informe os Dados dos Alunos ***");
18. for (i = 0; i < TAM; i++) {
19. printf ("\nMatricula: ");
20. scanf ("%d", &alunos[i].matricula);
21. getchar();
23. gets (alunos[i].nome);
24. // leitura das notas do aluno. Percorremos o vetor com outro for
25. for (j = 0; j < 3; j++) {
26. printf ("Nota %d: ", j + 1);
27. // o primeiro indice refere-se a tabela e o segundo ao
vetor de notas
28. scanf ("%f", &alunos[i].notas[j]);
29. }
30. }
31. // impressão dos dados dos alunos
32. // calculo da média aritmética de cada aluno
33. // calculo da media da turma
34. printf ("\n\n*** Dados dos Alunos ***\n");
35. float somaAluno, mediaAluno, somaTurma = 0;
36. for (i = 0; i < TAM; i++) {
37. somaAluno = 0;
38. // percorre o vetor de notas dos alunos para soma-las
39. for (j = 0; j < 3; j++) {
40. somaAluno += alunos[i].notas[j];
41. }
42. mediaAluno = somaAluno / 3;
43. somaTurma += mediaAluno;
44. printf ("%d - ", alunos[i].matricula);
45. printf ("%s - ", alunos[i].nome);
46. printf ("%.1f\n", mediaAluno);
47. }
48. float mediaTurma = somaTurma / TAM;
49. printf ("\nMedia da Turma = %.1f\n\n", mediaTurma);
51. }
Exemplo 3
Neste exemplo, uma estrutura "produto" possui os seguintes dados: código
(inteiro), descrição e preço. O programa faz a leitura dos dados de 5 produtos,
armazenando-os em uma tabela e, depois, os apresenta na tela.
4. // constante simbolica que representa o tamanho da tabela
5. #define TAM 5
6. // definição da estrutura Produto Prática de Programação
7. struct Produto {
8. int codigo;
9. char descricao[80];
10. float preco;
11. };
12. main () {
13. // declaração da tabela de produtos
14. struct Produto produtos[TAM];
15. int i;
16. // leitura dos produtos
17. printf ("*** Informa os Dados dos Produtos ***\n");
18. for (i = 0; i < TAM; i++) {
19. printf ("\n*** Produto %d ***\n", i);
20. printf ("Codigo: ");
21. scanf ("%d", &produtos[i].codigo);
22. getchar();
23. printf ("Descricao: ");
24. gets (produtos[i].descricao);
25. printf ("Preco: ");
26. scanf ("%f", &produtos[i].preco);
27. }
28. // impressao dos produtos
29. printf ("\n\n*** Dados dos Produtos ***\n");
30. for (i = 0; i < TAM; i++) {
31. printf ("%d ", produtos[i].codigo);
32. printf ("%s ", produtos[i].descricao);
33. printf ("%.2f\n", produtos[i] .preco);
34. }
36. }
Passagem de estruturas e tabelas

como parâmetros para funções
Apresentar a forma de passagem de estruturas e tabelas como parâmetros para
funções na linguagem C.
NESTE TÓPICO
NESTE TÓPICO
Passagem de estruturas como parâmetro para funções

Exemplo 1
Passagem de tabelas como parâmetro para funções
Exemplo 2
Exemplo 3
Referências
Marcar
tópico

Passagem de estruturas como parâmetro para

funções
Estruturas podem ser passadas como parâmetros para funções da mesma forma que
variáveis simples. Para isso, declaramos na assinatura da função um parâmetro do
tipo da estrutura que queremos passar. A forma geral é a seguinte:
1. <tipo_retorno><nome_funcao> (struct<nome_estrutura><nome_var>)
Por exemplo, imagine que temos uma estrutura denominada Pessoa e queremos
passá-la como parâmetro para a função imprimirPessoa. A assinatura da função
fica da seguinte forma:
void imprimirPessoa (struct Pessoa p)
Na chamada da função imprimirPessoa, temos que passar como argumento uma
variável do tipo Pessoa. Analise o trecho de código seguinte:
1. // declaração da tabela do tipo Pessoa

2. struct Pessoa pessoa;
3. ...
4. // passagem da tabela como parâmetro para a função imprimirPessoa
5. imprimirPessoa (pessoa);
Exemplo 1
Vamos criar um programa que define uma estrutura “Pessoa” com os
campos nome e idade; ler valores para os campos da estrutura e depois chamar a
função imprimirPessoa, que apresenta os dados na tela. Note que a
estrutura Pessoa deve ser definida antes da função que a usa como parâmetro.
3. // definiçao da estrutura Pessoa
4. struct Pessoa {
5. char nome[80];
6. int idade;
7. };
8. // definição da função imprimirPessoa
9. void imprimirPessoa (struct Pessoa p) {
10. printf ("%s - %d", p.nome, p.idade);
11. }
12. main () {
13. // declaração da variável do tipo Pessoa
14. struct Pessoa pessoa;
15. // leitura dos dados de uma Pessoa
17. gets (pessoa.nome);
18. printf ("Idade: ");
19. scanf ("%d", &pessoa.idade);
20. printf ("\n");
21. // chamada da funçao imprimirPessoa, passando a estrutura comoargumento
22. imprimirPessoa (pessoa);
25. }
Passagem de tabelas como parâmetro para

funções
Tabelas (vetor de estruturas) podem ser passadas como parâmetros para funções da
mesma forma que vetores de tipos simples. Para isso, declaramos na assinatura da
função um parâmetro do tipo da tabela que queremos passar, isto é, após o nome da
variável colocamos abre e fecha colchetes. A forma geral é a seguinte:
1. <tipo_retorno><nome_funcao>(struct<nome_estrutura><nome_var>[])
Por exemplo, imagine que temos uma tabela do tipo “Pessoa” e queremos passá-la
como parâmetro para a função imprimirPessoas. A assinatura da função fica da
seguinte forma:
void imprimirPessoas (struct Pessoa pessoas[])
Na chamada da função imprimirPessoas, temos que passar como argumento uma
tabela do tipo Pessoa. Analise o trecho de código a seguir.
1. // declaração de uma tabela do tipo Pessoa

2. struct Pessoa pessoas[5];
3. ...
4. // passagem da tabela como parâmetro para a função imprimirPessoas
5. imprimirPessoas (pessoas);
Como tabelas são vetores, elas são passadas para a função por referência, isto é, se
alterarmos o conteúdo da tabela dentro da função, as alterações serão refletidas
para fora da função.

Exemplo 2
Vamos criar um programa que define uma estrutura “Pessoa” com os
campos nome e idade e criar uma tabela que armazena os dados de 5 pessoas; ler
valores para cada pessoa da tabela (para isso vamos criar a função lerPessoas) e
depois chamar a função imprimirPessoas que apresenta os dados na tela. Note que
a estrutura “Pessoa” deve ser definida antes das funções que usam a tabela do tipo
“Pessoa” como parâmetro.
3. // constante simbólica que representa a quantidade de pessoas da tabela
4. #define TAM 5
5. // definiçao da estrutura Pessoa
6. struct Pessoa {
7. char nome[80];
8. int idade;
9. };
10. // definição da função lerPessoas
11. void lerPessoas (struct Pessoa pessoas[]) {
12. int i;
13. for (i = 0; i < TAM; i++) {
15. gets (pessoas[i].nome);
16. printf ("Idade: ");
17. scanf ("%d", &pessoas[i].idade);
18. getchar();
19. }
20. }
21. // definição da função imprimirPessoa
22. void imprimirPessoa (struct Pessoa pessoas[]) {
23. int i = 0;
24. for (i = 0; i < TAM; i++) {
25. printf ("%s - %d\n", pessoas[i].nome, pessoas[i].idade);
26. }
27. }
28. main () {
29. // declaração da tabela do tipo Pessoa
30. struct Pessoa pessoas[TAM];
31. // chamada da funçao lerPessoas, passando a tabela como argumento
32. lerPessoas (pessoas);
33. // chamada da funçao imprimirPessoas, passando a tabela como
argumento
34. imprimirPessoa (pessoas);
37. }
Exemplo 3
Neste exemplo, é declarada a estrutura "Aluno", que possui os seguintes campos:
Número de Matricula, Nome, Serie, Turma e Média. Em seguida, é criada uma
função que recebe como parâmetro um aluno e indica se ele está aprovado ou
reprovado (Retorna 1 para Aprovado e 0 para Reprovado). Na função principal, é
feita a leitura dos dados do aluno e é feita a chamada da função que verifica sua
situação. Por fim, é exibida uma mensagem de aprovação ou reprovação do aluno.
4. // definição da estrutura Aluno
5. struct Aluno {
6. int matricula;
7. char nome[80];
8. int serie;
9. char turma;
10. float media;
11. };
12. // definiçao da função que indica a aprovacao
13. int estaAprovado (struct Aluno aluno) {
14. if (aluno.media >= 6) {
15. return 1;
16. }
17. else {
18. return 0;
19. }
20. }
21. main () {
22. // declaração da variavel do tipo Aluno
23. struct Aluno umAluno;
24. // leitura dos dados do aluno
25. printf ("*** Informe os dados do Aluno ***\n");
26. printf ("Matricula: ");
27. scanf ("%d", &umAluno.matricula);
28. getchar();
30. gets (umAluno.nome);
31. printf ("Serie: ");
32. scanf ("%d", &umAluno.serie);
33. getchar();
34. printf ("Turma: ");
35. scanf ("%c", &umAluno.turma);
36. printf ("Media: ");
37. scanf ("%f", &umAluno.media);
38. // chama a função que indica a aprovacao passando o aluno como parametro
39. int aprovado = estaAprovado (umAluno);
40. // imprime a mensagem indicando a aprovação/reprovação
41. if (aprovado == 1) {
42. printf ("\nAluno Aprovado!\n\n");
43. }
44. else {
45. printf ("\nAluno Reprovado!\n\n");
46. }
48. }
Conceitos sobre aplicação de

Ponteiros em Estruturas em C
Apresentar a criação de ponteiros de estruturas e como passar estruturas como
referência para funções. Apresentar também a aplicação de ponteiros em
estruturas.
NESTE TÓPICO
NESTE TÓPICO
Ponteiros de estruturas
Passagem por referência de estruturas para funções
Estruturas contendo ponteiros
Exemplo
Referências
Marcar
tópico

Ponteiros de estruturas
Em C, podemos definir um ponteiro para uma estrutura. Ele não é diferente de um
ponteiro para um tipo de dados básico. Se um ponteiro p aponta para uma estrutura
que tem um campo x, então podemos escrever (*p).x para acessar esse membro a
partir de p.
A seguir, apresentamos um exemplo de ponteiro para estrutura.
4. struct Pessoa {
5. char nome[80];
6. int idade;
7. };
8. main () {
9. // declaração e inicialização da estrutura
10. struct Pessoa pessoa = {"Ana", 22};
11. // declaração de um ponteiro para o tipo da estrutura
12. struct Pessoa *ptr;
13. // faz o ponteiro ptr apontar para a estrutura pessoa
14. ptr = &pessoa;
15. // imprime os dados da estrutura acessando seus campos via ponteiro
16. printf ("%s - %d\n\n", (*ptr).nome, (*ptr).idade);
18. }
O operador de seleção de campo (.) tem maior precedência que o operador de

conteúdo (*). Por esse motivo, o uso de parênteses é obrigatório em (*ptr).nome e
em (*ptr).idade. Em C, temos um operador específico para acessar campos de
estruturas a partir de ponteiro, esse é o operador -> (seta). Usando esse operador,
em vez de escrever (*ponteiro).campo podemos escrever ponteiro->campo.
O próximo exemplo apresenta o uso do operador seta:
4. struct Pessoa {
5. char nome[80];
6. int idade;
7. };
8. main () {
9. // declaração e inicialização da estrutura
10. struct Pessoa pessoa = {"Ana", 22};
11. // declaração de um ponteiro para o tipo da estrutura
12. struct Pessoa *ptr;
13. // faz o ponteiro ptr apontar para a estrutura pessoa
14. ptr = &pessoa;
15. // imprime os dados dos campos usando o operador seta
16. printf ("%s - %d\n\n", ptr->nome, ptr->idade);
18. }
Passagem por referência de estruturas para

funções
Quando passamos uma estrutura como parâmetro para uma função, ela é passada
por valor, isto é, se alterarmos os valores da estrutura dentro da função, tais
alterações não serão refletidas fora da função. Se quisermos que valores de campos
alterados dentro da função sejam refletivos para fora da função temos que passar o
parâmetro da estrutura por referência. Para isso, colocamos o símbolo * antes do
nome do parâmetro.
Por exemplo, vamos criar um programa que define uma estrutura Funcionário que
tem como campos nome e salario. Vamos também criar uma função que recebe por
referência uma estrutura do tipo Funcionário e reajusta o seu salário de acordo
com a seguinte regra: salários menores que R$ 500,00 são reajustados em 12%;
salários maiores ou iguais a R$ 500,00 são reajustados em 7%. Após a chamada da
função os dados do funcionário são apresentados.
3. // definição da estrutura funcionário
4. struct Funcionario {
5. char nome[80];
6. float salario;
7. };
8. // definição da função reajustarSalario
9. // note que temos que colocar o operador * antes
10. // do nome do parametro, indicando que a passagem
11. // é por referência
12. void reajustarSalario (struct Funcionario *func) {
13. if (func->salario < 500) {
14. // reajusta o salario em 12%
15. func->salario = func->salario * 1.12;
16. }
17. else {
18. // reajusta o salario em 7%
19. func->salario = func->salario * 1.07;
20. }
21. }
22. main () {
23. // declaração da variável do tipo funcionario
24. struct Funcionario f;
25. // leitura dos dados do funcionário
27. gets (f.nome);
28. printf ("Salario: ");
29. scanf ("%f", &f.salario);
30. // chamada a função de reajuste de salario
31. // note que temos que colocar o operador & antes do
32. // nome da variavel de estrutura, pois a estamos
33. // passando por referencia
34. reajustarSalario (&f);
35. // imprime os dados do funcionario
36. printf ("%s - %.2f\n\n", f.nome, f.salario);
38. }
Estruturas contendo ponteiros

Em C, ponteiros também podem ser campos de estruturas. Vamos apresentar tal
conceito por meio de um exemplo:
1. struct PonteirosInteiros {
2. int *p1;
3. int *p2;
4. }
Uma estrutura denominada PonteirosInteiros é definida contendo dois campos do

tipo ponteiro para inteiro denominados p1 e p2, respectivamente. Podemos definir
uma variável do tipo PonteirosInteiros da forma usual:
struct PonteirosInteiros ponteiros;
A variável ponteiros pode ser usada da mesma forma que qualquer outra variável
do tipo estrutura. Note que a variável ponteiros não é um ponteiro, ela é uma
variável de estrutura que tem dois ponteiros como campos.
O programa a seguir apresenta como a estrutura PonteirosInteiros pode ser tratada
em C:
3. // definição da estrutura com campos que são ponteiros
4. struct PonteirosInteiros {
5. int *p1;
6. int *p2;
7. };
8. main () {
9. // declaração da variável do tipo PonteirosInteiros
10. struct PonteirosInteiros ponteiros;
11. // declaração de duas variáveis inteiras
12. int x = 20, y;
13. // o campos p1 de ponteiros aponta para o endereço da variável x
14. ponteiros.p1 = &x;
15. // o campo p2 de ponteiros aponta para o endereço da variável y
16. ponteiros.p2 = &y;
17. // atribuição do valor 30 ao campo p2 de ponteiros
18. // note que para acessar o conteúdo do endereço apontado por p2
19. // temos que colocar o símbolo * antes do nome da variável de estrutura
20. *ponteiros.p2 = 30;
21. // impressão das variáveis
22. printf ("x = %d y = %d\n", x, y);
23. printf ("Ponteiros p1 = %d p2 = %d\n\n", *ponteiros.p1, *ponteiros.p2);
25. }
Exemplo
No programa a seguir, é definida uma estrutura denominada "Campo". Em seguida,
é criada uma função que recebe essa estrutura por referência e troca os valores
de campo1 e campo2. No programa principal, é feita a leitura dos valores para os
campos da estrutura e é feita a chamada da função para trocar os valores e os
apresentar na tela.
3. // definicao da estrutura
4. struct Campos {
5. int campo1, campo2;
6. };
7. // definição da função que recebe por referencia a estrutura Inteiros
8. void trocar (struct Campos *c) {
9. // troca os valores dos campos
10. int aux = c->campo1;
11. c->campo1 = c->campo2;
12. c->campo2 = aux;
13. }
14. main () {
15. struct Campos c;
16. // leitura dos dados
17. printf ("Campo 1: ");
18. scanf ("%d", &c.campo1);
19. printf ("Campo 2: ");
20. scanf ("%d", &c.campo2);
21. // chama a funçao passando o parametro por referencia
22. trocar (&c);
23. printf ("\nCampo 1 = %d ", c.campo1);
24. printf ("Campo 2 = %d\n\n", c.campo2);
26. }
Ponteiros em Vetores
Apresentar conceitos sobre a utilização de ponteiros em vetores e aplicar tais
NESTE TÓPICO
NESTE TÓPICO
Ponteiros em vetores

Vetores de ponteiros
Exemplo 1
Referências
Marcar
tópico

Ponteiros em vetores
Como já visto até agora, ponteiros são variáveis que guardam o endereço de
memória de outra variável. Veremos como se aplica esse recurso em vetores.
Quando declaramos um vetor, o nome da variável é, na verdade, um ponteiro para
o tipo da variável do vetor. O compilador aloca, na memória, o espaço em bytes,
considera o nome da variável (que é um endereço de memória) e aponta para o
primeiro elemento do vetor. O programa mostrado a seguir ilustra esse conceito.
3. main (){
4. int vet [10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
5. int *p;
6. p=vet;
7. printf ("O terceiro elemento do vetor e: %d",p[2]);
8. printf ("O terceiro elemento do vetor e: %d",*(p+2));
10. }
Note que, no exemplo ilustrado, o terceiro elemento do vetor é mostrado sob duas
formas diferentes. Isso é possível, pois p[2] equivale a *(p+2). Quando somamos
um número ao ponteiro, o que estamos fazendo é, na verdade, somar o número
necessário de bytes para o próximo endereço.
Por outro lado, podemos construir, também, vetores de ponteiros como declaramos
vetores de qualquer outro tipo.

Vetores de ponteiros
Na linguagem C, é possível que cada elemento de um vetor armazene um endereço
de memória. Dessa forma, é possível criar um vetor de ponteiros.
A forma geral de declaração de um vetor de ponteiros em linguagem C é:
tipo *nome-vetor [tamanho];
Em que tipo é um tipo qualquer de dados, nome-vetor é o nome pelo qual o vetor
será referenciado e tamanho é a quantidade de elementos que o vetor pode conter.
Exemplos:
 Declaração de um vetor para 10 posições de ponteiros para números

inteiros:
int *vet_inteiros[10];
 Declaração de um vetor para 20 posições de ponteiros para números reais:
float *vet_reais[20];

Exemplo 1
O programa a seguir mostra a utilização de um vetor que irá armazenar e mostrar
na tela os endereços de memória de 5 números inteiros.
3.
4. main () {
5. int *vet [5];
6. int v1=3, v2=5, v3=8, v4=10, v5=15, i;
7. vet [0] = &v1;
8. vet [1] = &v2;
9. vet [2] = &v3;
10. vet [3] = &v4;
11. vet [4] = &v5;
12.
13. for (i=0; i<5; i++) {
14. printf ("\n Conteudo de vet[%d] = %p", i, vet[i]);
15. }
17. }
Na figura a seguir, é mostrada a simulação da memória do computador quando o

programa mencionado é executado. Podemos observar que, em cada posição do
vetor, está armazenado o endereço de memória das variáveis.

Depois de rever o conteúdo desta aula, solucione os exercícios de múltipla escolha

propostos. Lembre-se de que você poderá postar suas dúvidas no Fórum e ter
auxílio de seus colegas e professor.
Conceitos iniciais sobre Unions em

C
Apresentar o conceito de uniões e aplicar tal conceito utilizando a linguagem C.
NESTE TÓPICO
Introdução
Definição
Declaração da “Union”
Acesso aos membros da “Union”
Exemplo 1
Exemplo 2
Referências
NESTE TÓPICO
Introdução
Definição
Exemplo 1
Exemplo 2
Referências
Marcar
tópico

Introdução
Já vimos anteriormente que, na linguagem C, é possível agrupar vários dados de
tipos diferentes em uma só unidade, conhecida como “struct”. Como exemplo,
podemos citar os dados de um aluno, tais como: nome, notas e faltas.
Assim como as “structs”, as “unions” podem agrupar vários dados de tipos
diferentes. Em uma “union“, os elementos compartilham a mesma área de
memória, enquanto que em uma “struct” cada elemento tem sua própria área de
memória. Com isso, as uniões são utilizadas com a finalidade de economizar
memória. Em uma união, o compilador se encarrega de contabilizar a memória
necessária para armazenar os membros.
Na figura a seguir, é mostrada a diferença entre uma “struct” e uma “union” com
relação à alocação de memória. Ainda considerando os dados de um aluno, se estes
fossem armazenados em uma “struct” e, considerando que a variável nome é uma
string com 40 caracteres, então a quantidade de memória necessária seria de 48
bytes (40 bytes da variável “nome” + 4 bytes da variável “notas” + 4 bytes da
variável “faltas”). No caso da “union”, os dados ocupariam 40 bytes, que
corresponde ao tamanho da maior variável.

Definição
Uma “union” é uma estrutura de dados que permite agrupar dados de vários tipos
diferentes, compartilhando uma mesma área de memória, ou seja, 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 “struct”. A forma
geral de declaração de uma “union” em linguagem C é:
1. union nome-union {
2. tipo-variavel nome-variavel;
3. };
Em que nome-union é o nome da union, Tipo-variavel é o tipo da variável que

pertence à “union” e nome-variavel é o nome da variável que pertence à “union”.
Para manipularmos uma “union” é necessário declarar uma variável. A forma geral
de declaração de uma variável para uma “union” em linguagem C é:
1. union nome-union nome-variavel;
Exemplo:
Declaração de uma “union” denominada dados_aluno que terá os dados de alunos
e da variável aluno_uninove.
1. union dados_aluno {
2. char nome [40];
3. float nota;
4. int faltas;
5. } ;
6.
7. union dados_aluno aluno_uninove;
No exemplo mencionado, as variáveis declaradas dentro da “union” são chamadas

de membros.

Para acessar qualquer membro de uma “union”, é necessário utilizar o operador
ponto (.) entre o nome da variável declarada para a manipulação da “union” e o
membro que se deseja acessar.
A forma geral para o acesso de um membro de uma “union” em linguagem C é:
1. nome-variavel-union.nome-membro;
Exemplo 1
A seguir, é mostrado um exemplo de um programa que possui uma “union” com os
dados de alunos. Inicialmente, os dados são solicitados ao usuário e, em seguida,
são mostrados na tela. Observe como os membros da “union” são acessados para
serem lidos e exibidos na tela.
4. // definição da union
5. union dados_aluno {
6. char nome [40];
7. float nota;
8. int faltas;
9. } ;
10. main ( ) {
11. // declaração de uma variável da union
12. union dados_aluno aluno_uninove;
13.
14. printf ("\n Digite o nome do aluno=");
15. gets (aluno_uninove.nome);
16. printf ("\n Nome do aluno=");
17. puts (aluno_uninove.nome);
18. printf ("\n Digite a nota do aluno=");
19. scanf ("%f", &aluno_uninove.nota);
20. printf ("\n Nota do aluno=%f", aluno_uninove.nota);
21. printf ("\n Digite as faltas do aluno=");
22. scanf ("%d", &aluno_uninove.faltas);
23. printf ("\n Faltas do aluno=%d", aluno_uninove.faltas);
25. }
Exemplo 2
Neste exemplo, é criada uma union com os seguintes membros: matrícula (int),
nome do funcionário (string de tamanho 40), cargo(string de tamanho 30) e salário
(float). O programa solicita ao usuário que digite os valores dos membros da union
e, por fim, exibe os valores armazenados.
4. union dados_funcionario {
5. int matricula;
6. float salario;
7. char nome [40];
8. char cargo [30];
9. };
10. main () {
11. union dados_funcionario func;
12. printf ("\n Digite a matricula:");
13. scanf ("%d", &func.matricula);
14. printf ("\n Matricula = %d", func.matricula);
15. printf ("\n Digite o nome:");
16. fflush (stdin);
17. gets(func.nome);
18. puts(func.nome);
19. printf ("\n Digite o cargo:");
20. gets(func.cargo);
21. puts(func.cargo);
22. printf ("\n Digite o salario:");
23. scanf ("%f", &func.salario);
24. printf ("\n Salario = %f", func.salario);
26. }
Utilizando "unions" com "structs"

Apresentar conceitos adicionais sobre uniões (unions) e aplicar tal conceito
utilizando a linguagem C.
NESTE TÓPICO
NESTE TÓPICO

Exemplo 1
Exemplo 2
Referências
Marcar
tópico


Na linguagem C, é possível utilizar "unions" juntamente com "structs". Para
ilustrarmos melhor o uso combinado dessas duas estruturas, vamos imaginar uma
empresa de seguros que ofereça três tipos de apólices: de vida, automotivas e
residenciais. Para todos os tipos de seguro, é necessário ter o nome do proprietário
da apólice, o endereço, o valor do seguro e o pagamento do prêmio mensal.
Podemos dizer, então, que esses dados representam a parte fixa (dados comuns)
das declarações dos membros de uma "struct". Os dados específicos referentes a
cada apólice correspondem à parte variável e serão definidos por "structs" dentro
de uma "union".
Nesse caso, a "union" permite que uma variável assuma vários "tipos" diferentes
em diferentes pontos na execução e permite, também, que um vetor contenha
objetos de diferentes tipos.

Exemplo 1
A seguir, é mostrado o exemplo do programa que combina "structs" e "unions".
Nesse caso, essa combinação foi utilizada para armazenar, em um vetor, os dados
referentes a duas apólices de seguro.
3. #define SEGVIDA 1
4. #define SEGAUTO 2
5. #define SEGCASA 3
6. struct endereco{
7. char rua[50];
8. char cidade[10];
9. char estado[2];
10. };
11. struct data{
12. int dia;
13. int mes;
14. int ano;
15. };
16. struct apolice{
17. int apolnumero;
18. char nome[30];
19. struct endereco ender;
20. float valseguro;
21. float premio;
22. int tipo;
23. union {
24. struct {
25. char beneficiario[30];
26. struct data aniversario;
27. } segvida;
28. struct {
29. int valordedutivel;
30. char licenca[10];
31. char estado[2];
32. char modelo[15];
33. int ano;
34. } segauto;
35. struct {
36. int valordedutivel;
37. int anoconstrucao;
38. } segcasa;
39. }infoapolice;
40. };
41. main() {
42. struct apolice p[2];
43. scanf("%s",&p[0].infoapolice.segvida.beneficiario);
44. scanf("%d",&p[0].infoapolice.segvida.aniversario.dia);
45. scanf("%d",&p[0].infoapolice.segvida.aniversario.mes);
46. scanf("%d",&p[0].infoapolice.segvida.aniversario.ano);
47. p[0].tipo=1;
48. scanf("%d",&p[1].infoapolice.segauto.valordedutivel);
49. scanf("%s",&p[1].infoapolice.segauto.licenca);
50. scanf("%s",&p[1].infoapolice.segauto.estado);
51. scanf("%s",&p[1].infoapolice.segauto.modelo);
52. scanf("%d",&p[1].infoapolice.segauto.ano);
53. p[1].tipo=2;
54. int i;
55. for (i=0; i<=1; i++) {
56. if (p[i].tipo==SEGVIDA) {
57. printf ("\n Beneficiário=
%s",p[i].infoapolice.segvida.beneficiario);
58. printf("\n Dia de niver=
%d",p[i].infoapolice.segvida.aniversario.dia);
59. printf("\n Mes de niver=
%d",p[i].infoapolice.segvida.aniversario.mes);
60. printf("\n Ano de niver=
%d",p[i].infoapolice.segvida.aniversario.ano);
61. }
62. else if (p[i].tipo==SEGAUTO) {
63. printf("\n Valor =
%d",p[i].infoapolice.segauto.valordedutivel);
64. printf("\n Licenca =
%s",p[i].infoapolice.segauto.licenca);
65. printf("\n Estado =
%s",p[i].infoapolice.segauto.estado);
66. printf("\n Modelo =
%s",p[i].infoapolice.segauto.modelo);
67. printf("\n Ano = %d",p[i].infoapolice.segauto.ano);
68. }
69. }
71. }
Exemplo 2
Neste exemplo, são armazenados os dados das contas de uma agência bancária.
Sabe-se que uma conta pode ser de 2 tipos: conta corrente e conta poupança. Os
atributos comuns às duas contas são os seguintes: Número da conta, Nome do
titular e Saldo. Para os dois tipos de contas, os atributos particulares são os
seguintes: Conta Corrente (limite) e Conta Poupança (taxa de juros). O programa a
seguir utiliza uma combinação de union com struct para armazenar os dados das
contas. Por fim, os valores são inseridos e exibidos na tela.
4. #define CCORR 1
5. #define CPOUP 2
6.
7. struct conta{
8. int nroconta;
9. char nome[30];
10. float saldo;
11. int tipo_conta;
12. union {
13. struct {
14. float limite;
15. } contcorr;
16. struct {
17. float taxa_juros;
18. } contpoup;
19. } infoconta;
20. };
21.
22. main() {
23. struct conta p[2];
24. int i; Prática de Programação
25. printf("\n Digite o nro da conta=");
26. scanf("%d",&p[0].nroconta);
27. printf("\n Digite o nome=");
28. fflush (stdin);
29. gets(p[0].nome);
30. printf("\n Digite o saldo=");
31. scanf("%f",&p[0].saldo);
32. printf("\n Digite o limite=");
33. scanf("%f",&p[0].infoconta.contcorr.limite);
34. p[0].tipo_conta=1;
35. printf("\n Digite o nro da conta=");
36. scanf("%d",&p[1].nroconta);
37. printf("\n Digite o nome=");
38. fflush (stdin);
39. gets(p[1].nome);
40. printf("\n Digite o saldo=");
41. scanf("%f",&p[1].saldo);
42. printf("\n Digite a taxa de juros=");
43. scanf("%f",&p[1].infoconta.contpoup.taxa_juros);
44. p[1].tipo_conta=2;
45. for (i=0;i<=1;i++){
46. if (p[i].tipo_conta== CCORR) {
47. printf("\n Nro da conta= %d",p[i].nroconta);
48. printf("\n Nome=");
49. fflush (stdin);
50. puts(p[i].nome);
51. printf("\n Saldo= %.2f",p[i].saldo);
52. printf("\n Limite=%.2f",p[i].infoconta.contcorr.limite);
53. }
54. else if (p[i].tipo_conta== CPOUP) {
55. printf("\n Nro da conta= %d",p[i].nroconta);
56. printf("\n Nome=");
57. fflush (stdin);
58. puts(p[i].nome);
59. printf("\n Saldo= %.2f",p[i].saldo);
60. printf("\n Taxa de juros=
%.2f",p[i].infoconta.contpoup.taxa_juros);
61. }
62. }
64. }

Conteúdo - Prática de Programação

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Conteúdo - Prática de Programação

Enviado por

Direitos autorais:

Formatos disponíveis

Constantes e Operadores em C

Apresentar os seguintes conceitos da linguagem C: constantes, operadores de

Operadores Aritméticos de Atribuição

Expressão Forma Compacta

 Forma prefixa: ++variavel, --variavel

 Forma posfxa: variavel++, variavel--

O trecho de código a seguir apresenta um exemplo de utilização dos operadores de

A diferença entre usar o operador na forma prefixa ou posfixa aparece somente

Embora o operador ternário de decisão e o comando if-else sejam semelhantes, eles

Conceitos iniciais, definição e

 Declaração de um vetor denominado notas de 15 posições de valores do tipo

Conceitos adicionais sobre vetores

Uso da diretiva #define

Se quisermos agora modificar o nosso programa para que o vetor armazene 15

1. int matriz [3][4] = {

Matrizes de duas dimensões são inicializadas da mesma forma que um vetor. Os

1. int i, j; // i representa a linha e j representa a coluna

Na manipulação de vetor é utilizada uma única instrução de laço for. No caso de

Conceitos iniciais e manipulação de

O conteúdo das strings deve ser referenciado entre aspas (“ ”).

Referenciando um Caractere da String

1. printf ("Digite a String=");

1. printf ("Digite a String=");

1. printf ("%s \n", frase);

Funções para manipulação de Strings

1. char str [40];

1. char str [40];

1. char strdest [40], strorig [40];

1. char str1[50], str2[50];

5. strlen: utilizada para retornar o tamanho (quantidade de letras) de uma string,

1. char str [50];

Declaração do Vetor de Strings

 Declaração de um vetor de strings denominado alunos, que poderá

char alunos [10] [60];

1. char alunos [10] [60] = {"Ana", "Pedro", "Maria" , "Antonio" , "Marcos" ,

O laço for é usado para o processo de solicitar um nome ao usuário e armazená-lo

Definição e aplicação de Ponteiros

 Subprogramas (funções e procedimentos): modificação de argumentos em

 Alocação dinâmica de memória: permitem a criação de estruturas de dados

 Declaração de um ponteiro denominado px, que armazenará o endereço de

 Declaração de um ponteiro denominado pc, que armazenará o endereço de

2. & : este operador permite acessar o endereço de memória de uma variável.

Na Figura abaixo, é mostrada uma simulação do programa acima. Quando o

Ponteiros para Ponteiros

Ponteiro para ponteiros

Ponteiro para ponteiros

 Declaração de um ponteiro para outro ponteiro denominado Ppx, que

 Declaração de um ponteiro para outro ponteiro denominado Ppy, que

Conceitos iniciais sobre

 Deixar o programa mais legível e fácil de entender.

 Encontrar e corrigir erros com mais facilidade.

 Facilitar os testes, diminuindo a probabilidade de erros.

 Reduzir o tempo e custo da programação.

 Possibilitar o reaproveitamento de partes do programa (módulos).

Para exemplificar a técnica de programação estruturada ou modular, abaixo segue

No exemplo acima, percebe-se que existe redundância com relação a trechos de

Utilização dos Procedimentos e Funções

Existe, também, outra forma de estruturarmos um programa por meio de módulos,

Na Figura abaixo, é mostrada a simulação das alocações das variáveis na memória

Passagem de parâmetro por referência

Na Figura abaixo, é mostrada a simulação das alocações das variáveis na memória

2. Um procedimento com dois parâmetros, sendo o primeiro “opcao” por valor