VETORES / MATRIZES

FUNÇÕES
 Vetores em Linguagem “C”
• Vetores são Estruturas de Dados Homegêneas, isto é, são
estruturas capazes de armazenar uma quantidade pré-definida
de valores do mesmo tipo.
• Necessitam de apenas um índice de acesso.

• Declaração:
tipo nomedovetor[tamanho];
Onde:
– tipo:um dos tipos primitivos de dados em C (char, int, float, double)
– nomedovetor: segue as mesmas regras das variáveis básicas
– tamanho: define o número máximo de elementos do vetor
pode ser uma expressão constante inteira
 Vetores
Ex: Faça um programa para Calcular a média de uma
turma de 40 alunosLer a nota de 3 alunos e calcular a
média

int nota0, nota1, nota2;

printf(“entre com a 1a. nota”);

scanf(“%d”, &nota0);
: : :
printf(“média = %f”, (nota0 + nota1 + nota2) / 3));
 Vetores em Linguagem “C”
• Declaração:
tipo variavel_vetor[tamanho];
• Em C, os índices dos vetores variam de 0 a tamanho - 1

Exemplos de declarações:
float NOTAS[100];
int Conjunto[50];
char Nome[15];

• Acesso:
if((NOTAS[0] )== 10.0) {....}
while (Conjunto[1] > 10) {....}
Nome[14] = “ “;
 Vetores em Linguagem C
• Declaração / Inicialização:
#define TAM 5
• int vetor[TAM] = {10, 15, 20, 25, 30};

• int vetor[5] = {10, 15, 20, 25, 30};

• int vetor1[] = {10, 20, 30, 40, 50, 60, -1};

 Vetores em Linguagem C
• Atribuição:

float notas[4] = {5,4,8,7};

int idade[5];

//Atribuição estática
idade[0] = 25;
idade[1] = 50;
idade[2] = 15;
idade[3] = 23;
idade[4] = 42;
 Vetores em Linguagem C
• Atribuição:

float notas[4] = {5,4,8,7};

int idade[5];

//Atribuição dinâmica
printf(“Digite a idade: ”);
scanf(“%d”,&idade[2]);
 Vetores em Linguagem C
• Atribuição:

int notas[5], k;

//Atribuição dinâmica
for(k=0; k<5; k++){
scanf(“%d”,&notas[k]);
}
 Vetores em Linguagem C
• Impressão:

int notas[5], k;

//Atribuição dinâmica
for(k=0; k<5; k++){
printf(“%d”,notas[k]);
}
 Vetores
Ex: Faça um programa para calcular a média de 40 alunos
#include<stdio.h>
#define N_ALUNOS 40
main( )
{ int i;
float notas [ N_ALUNOS ], soma = 0;

for ( i = 0; i < N_ALUNOS; i++ ) {

printf (“entre com a nota %d”, i+1);
scanf (“%f”, &notas[ i ]);
soma = soma + notas [ i ];
}
printf (“ Média = %f \n”, media / N_ALUNOS);

for ( i = 0; i < N_ALUNOS; i++ ) {

printf (“\n Nota do aluno %d = ”, i+1);
printf (“%f \n”, notas[ i ]);
}
}
 Vetores - Observações importantes

• o tamanho de um vetor tem que ser determinado

em tempo de compilação

Ex: int alunos;

int notas [ alunos ];
: : :
printf (“entre com o número de alunos”);
scanf (“%d”, &alunos);

NÂO É ACEITO !!!

 Vetores - Observações importantes

Solução: declarar um vetor que suporte um

número máximo de elementos

Ex: int alunos;

int notas [ 70 ];
: : :
printf (“entre com o número de alunos”);
scanf (“%d”, &alunos);
 Vetores - Observações importantes

• C não realiza verificação de limites em vetores

• nada impede o acesso além do fim do vetor

• faça sempre que necessário a verificação dos limites

 Vetores - Observações importantes
#include <stdio.h>
#define TAMANHO 100
main( )
{
int quantidade, media = 0;
float notas [ TAMANHO ];
printf ( “quantas notas devo ler ?”);
scanf(“%d”, &quantidade);
for ( i = 0; i < quantidade; i++) {
printf ( “entre com a nota %d”, i+1);
scanf(“%d”, &notas [ i ]);
}
: : :
for ( i = 0; i < quantidade; i++)
media += notas [ i ];
: : :
}
 Matrizes

• em ‘C’ podemos definir um vetor em que cada

posição temos um outro vetor (matriz).
• estrutura de dados homogênea Quantidade de
multidimensional Linhas

• Note: Quantidade de
int matéria [ 4 ] [ 40 ]; Colunas

temos 4 matérias, cada uma com 40 alunos

(Observação: Indexação no estilo [Linha][Coluna])

 Matrizes - Leitura

int i, j, matéria [ 4 ] [ 40 ];

for ( i = 0 ; i < 4; i++ ) {

printf (“entre com as notas da matéria %d”, i+1);
for ( j = 0; j < 40; j++) {
printf (“entre com a nota do aluno %d”, j+1);
scanf (“%d”, &materia [ i ] [ j ]);
}
}
 Matrizes - Impressão

int i, j, matéria [ 4 ] [ 40 ];

for ( i = 0 ; i < 4; i++ ) {

printf (“Notas da matéria %d”, i+1);
for ( j = 0; j < 40; j++) {
printf(“%d”, &materia [ i ] [ j ]);
}
}
 Matrizes - exemplo
#include <stdio.h>
#include <stdlib.h>
void main()
{
float matriz [2][2];
float media, quant;
matriz[0][0] = 9.0;
matriz[0][1] = 8.0;
matriz[1][0] = 7.0;
matriz[1][1] = 7.0;
quant = matriz[0][0] + matriz[0][1]
+ matriz[1][0] + matriz[1][1];
media = quant / 4.0;
printf (“ A média dos 4 números é: %f.”, media);
return 0;
}
 Matrizes - String

• Matriz do tipo char terminada pelo caractere null ‘\0’

• Cada caractere de um string pode ser acessado
individualmente
• vetor de tamanho n string de tamanho ( n-1 )
Ex:
char string[10] = “exemplo” ;
char string[10] = { “exemplo” };
char string[10] = { ‘e’, ‘x’, ‘e’, ‘m’, ‘p’, ‘l’, ‘o’, ‘\0’ };

printf ( “%s”, string );

printf ( “%c”, string [ 0 ] );
 Funções
• O que são “Funções”? (ou subprogramas ou subrotinas)
– São trechos de código fonte agrupados sob um nome, que
podem ser chamados sempre que for necessário executar
uma determinada ação programada neste trecho;

• Como usar funções?

– Atribui-se um nome à uma seqüência de comandos, e faz-se
referência a este nome nos vários lugares do programa onde
a seqüência em questão deveria ser repetida.
 Funções
• Por que usar funções?
– Evita escrita repetida de código (uma certa seqüência de comandos deve
ser repetida em vários lugares de um programa).
• Economiza o tempo gasto com o trabalho de copiar estas seqüências;
• Evitar a necessidade de mudar em múltiplos lugares caso deseje alterar o
seu funcionamento;
– Dividir grandes tarefas de computação em tarefas menores:
• Facilita o gerenciamento de grandes sistemas e
• Aumenta a confiabilidade dos mesmos.

• Resumo: Principais motivações para uso das funções!

– Evitar repetição de código
– Modularização
 Funções
• Funções em “C"
– Em “C”, todo programa é composto por funções;
– Já utilizamos muitas funções, mesmo sem saber que eram
funções(printf, scanf, sqrt, e até a famosa função “main”…)
• Formato de declaração de funções :
tipo_de_retorno nome_da_função (tipo1 param1, tipo2 param2,..., tipoN paramN)
{
/* corpo da função */
return valor_de_retorno;
} /* fim da função */
– tipo_de_retorno especifica o tipo do valor que será retornado para
quem chamou a função (int, float, double, char, void).
– Se o tipo_de_retorno for void significa que se trata de uma função que
se comporta como uma subrotina; ou seja, a função não necessita
retornar nenhum valor (exemplo: printf)
 Funções
• “Funções” que não retornam valores - Tipo: void
#include <stdio.h>

void desenha( )
{
int i;
for (i = 0; i < = 10; i++)
printf (“-”);
}
main ( )
{
desenha ( );
printf (“ usando funções”);
desenha ( );
}
 Funções
• “Funções” que não retornam valores - Tipo: void
int main(){

imprimir();
media();
return 0;
}
void imprimir(){
printf(“Verifica Valor”);
}
void media(){
int x = 10;

if( x % 2 == 0){
printf(“Numero Par”);
}
}
 Funções
• “Funções” que retornam valores - int, float, double e
etc. int main(){
float ret;

ret = calculaMedia();

printf(“A media e %f”,ret);

return 0;
}
float calculaMedia(){
int x = 10, y = 5;
float media;

media = (x + y)/2;

return media;
}
 Funções
• “Funções” que retornam valores - int, float, double e
etc.
int main(){
float ret;

printf(“A media e %f”,calculaMedia());

return 0;
}
float calculaMedia(){
int x = 10, y = 5;
float media;

media = (x + y)/2;

return media;
}
 Funções
• “Funções” que recebem valor - int, float, double e etc.
int main(){
float x = 10, y = 5;
int ret;
ret = calculaMedia(x,y));
printf(“A media e %d”,ret);

return 0;
}
int calculaMedia(float k, float j){

int calculo;

calculo = (int)(k + j);

return calculo;
}
 Funções
• “Funções” que retornam valores
#include <stdio.h>

int fatorial (int n)

{
int i, resultado = 1;
for ( i = 1; i <= n; i ++)
resultado *= i;
return resultado;
}
int main ( )
{
printf (“ o fatorial de 4 = %d”, fatorial(4) );
printf (“ o fatorial de 3 = %d”, fatorial(3) );
return 0;
}
 Funções – Escopo de Variáveis

• Variáveis declaradas dentro de uma função são

denominadas locais e somente podem ser usadas
dentro do próprio bloco.

• São criadas apenas na entrada do bloco e destruídas na

saída (automáticas).

• Variáveis declaradas fora das funções são denominadas

variáveis globais, e podem ser usadas em qualquer
parte do código.
 Funções – Escopo de Variáveis
• Variável local – Acessada somente dentro da função
void calculaMedia();

int main(){
float x = 10, y = 5;

printf(“x = %f e y = %f”,x,y);
calculaMedia();
return 0;
}
void calculaMedia(){
float media;

media = (x + y)/2; //Erro variáveis não declaradas

printf(“a media e = %f”,media);

}
 Funções – Escopo de Variáveis
• Variável Global – Acessada por qualquer função
void calculaMedia();
float x = 10, y = 5;

int main(){
x+= 2;
printf(“x = %f e y = %f”,x,y);
calculaMedia();
return 0;
}
void calculaMedia(){
float media;
x += 5;
media = (x + y)/2;
printf(“a media e = %f \n”,media);
printf(“x = %f e y = %f \n”,x,y);
}
 Funções – Variáveis Locais
void desenha ( ) void desenha ( )
{ {
int i, j; int i, j; i, j em
. . . . . . desenha são
} . . . variáveis
main ( ) } diferentes de
{ void calcula ( ) i, j em
int a; { calcula.
int i, j;
desenha();
. . .
a = i; ¬ erro
. . .
. . . }
}
 Funções – Variáveis Globais
• Variável que é declarada externamente podendo ser
acessada por qualquer função

#include <stdio.h> void desenha ( )

{
int i; int j;
i = 0;
main ( ) . . .
{ }
void calcula ( )
......... {
......... int m;
desenha ( ); i = 5;
calcula ( ); . . .
} }
 Funções – Passando Dados

• Passagem de parâmetro por Valor - uma cópia

do argumento é passada para a função

• O parâmetro se comporta como uma variável local

Funções – Passando Dados - Valor
int main(){
int x = 10, y = 5;

calculaMedia(x,y);

return 0;
}
void calculaMedia(int k, int j){
float media;

media = (k + j)/2;

printf(“A media e %f”,media);

}
Funções – Passando Dados - Valor
int main(){
int x = 10, y = 5;
float ret;

ret = calculaMedia(x,y);

printf(“A media e %f”,ret);

return 0;
}
float calculaMedia(int k, int j){
float media;

media = (k + j)/2;

return media;
}
Funções – Passando Dados
main ( )
{
printf (“ %c”, minúsculo (‘A’) );

parâmetro real
}
char minúsculo (char ch)
parâmetro formal
{
if (( ch >= ‘A’)&& (ch <= ‘Z’))
return (ch + ‘a’-, ‘A’);
else
return (ch);
}
 Funções – Passando Dados
#include <stdio.h>
main ( )
{
int num, b;
printf (“ entre com um número > o”);
scanf (“ %d”, &num );
b = abs (num);
. . .
printf (“ Valor absoluto de num = %d”, abs(num) );
. . .
b = abs(-3);
}
int abs (int x)
{
return ( ( x < 0 ) ? -x : x );
}
 Funções – Passando vários argumentos

Ex 1:
float área_retângulo (float
largura, float altura)
{
return (largura * altura);
} for (i = 1; i <= expoente; i++)
Ex 2:
float potência (float base, int expoente)
{
int i; float resultado = 1;
if (expoente == 0)
return 1;
resultado *= base
return resultado;
}
 Funções – Passando Dados
Usando várias funções: calcular a seguinte seqüência
S(x, n) = x/1! + x2/2! + x3/3! + ... + xn/ n!
#include <stdio.h>
float serie (float , int );
float potencia (float , int)
int fat (int);
main( )
{
float x;
int termos;

printf(“entre com o numero de termos: “);

scanf(“%d”, &termos);
printf(“entre com o valor de X: “);
scanf(“%f”, &x);
printf(“O valor de série = %f “, serie(x, termos));
}
 Funções – Passando Dados
float serie (float x, int n)
{
int i; float resultado = 0;
for ( i = 1; i <= n; i++)
resultado += potência( x, i ) / fat( i );
return resultado;
}
float potencia (float base, int expoente)
{
int i; float resultado = 1;
if (expoente == 0)
return 1;
for (i = 1; i <= expoente; i++)
resultado *= base;
return resultado;
}
 Funções – Passando Dados

int fat (int n)

{
int i, resultado = 1;

for ( i = 1; i <= n; i ++)

resultado *= i;
return resultado;
}
 Vetores – passando como parâmetro

#include <stdio.h>
int maximum( int [] ); /* ANSI function prototype */

main( )
{
int values[5], i, max;
printf("Entre com 5 numeros:\n");
for( i = 0; i < 5; ++i )
scanf("%d", &values[i] );
max = maximum( values );
printf("\nValor Maximo: %d\n", max );
}
 Vetores – passando como parâmetro

Saída:
int maximum( int values[5] )
{ Entre com 5 numeros:
int max_value, i; 7 23 45 9 121
Valor Maximo: 121
max_value = values[0];
for( i = 0; i < 5; ++i )
if( values[i] > max_value )
max_value = values[i];
return max_value;
}
 String – Leitura

• scanf : lê o string até que um branco seja encontrado

Ex: Saída:
main ( ) Digite seu nome: Pedro Henrique
{ Bom dia Pedro
char nome[40];

printf ( “Digite seu nome: “ );

scanf ( “%s”, &nome[ 0 ] );
//scanf ( “%s”, nome );
printf ( “Bom dia %s”, nome);
}
 String – Leitura

• Gets
lê caracteres até encontrar ‘\n’
substitui ‘\n’ por ‘\0’
Saída:
Ex: Digite seu nome: Pedro Henrique
main ( ) Bom dia Pedro Henrique
{
char nome[40];

printf ( “Digite seu nome: “ );

gets ( &nome[ 0 ] ); // ou gets(nome);
printf ( “Bom dia %s”, nome );
}
 String – Impressão
• printf
• puts Saída:
Ex: Digite seu nome: Pedro Paulo
main ( ) Bom dia
{ Pedro Paulo
char nome[40];

printf ( “Digite seu nome: “ );

gets ( &nome[ 0 ] );
puts ( “Bom dia ” );
puts ( nome );
}
 String – Funções de Manipulação
• Strlen
retorna o tamanho do string - não conta ‘\0’

Ex: Saída:
main ( ) Digite seu nome: Jose Maria
{ Tamanho = 10
char nome[40];

printf ( “Digite seu nome: “ );

gets ( &nome[ 0 ] );
printf (“Tamanho = %d”, strlen(&nome[ 0 ]) );
}
 String – Funções de Manipulação

• strcat ( str1, str2 )

Concatena str2 ao final de str1

Ex:
main ( ) Saída:
{ Maria
char nome[40] = “Jose”, JoseMaria
char sobrenome[30] = “Maria”;
Cuidado:
strcat(nome, sobrenome); dado str1 + str2 tem
puts (sobrenome); que caber em str1
puts (nome);
}
 String – Funções de Manipulação

• strcmp ( str1, str2 )

compara dois strings retornando:
– negativo se str1 < str2
– 0 se str1 == str2
– positivo se str1 > str2
• a comparação é feita por ordem alfabética
 String – Funções de Manipulação

#include <stdio.h>
main ( )
{
char nome[40] = “Jose”;
char sobrenome[30] = “Maria”;

if ( strcmp ( nome, sobrenome ) !=0)

puts ( “os strings são diferentes” );
else
puts ( “os strings são identicos” );
}
 String – Conversões

• podemos também converter strings e números

(inteiros/fracionários) conforme desejarmos:

Exemplo: Conversão de String em Número Inteiro

#include <stdio.h>
main()
{
int i;
char s[10];
printf(“Digite uma sequencia de numeros com letras:
“);
gets(s);
i = atoi(s);
printf(“Numero: %d “,i);
}