Algoritmos e C++

 
 
Roteiro de aulas práticas
Parte III - estruturas de dados e funções
Sumário:
  • Estruturas de dados homogêneos
  • Matrizes unidimensionais – vetores
    • Declaração e operações básicas
  • Matrizes bidimensionais
    • Declaração e operações básicas
  • Funções
    • Protótipo e definição
    • Passagem de parâmetros
    • Funções de bibliotecas
  • Bibliografia
 

Estruturas de dados homogêneos

Variáveis compostas do mesmo tipo de dado (inteiro, real, ...) são denominadas de conjunto homogêneo de dados.
Esses agrupamentos de variáveis são conhecidos como vetores, matrizes, tabelas ou variáveis indexadas ou subscritas.
 
 

Matrizes unidimensionais – vetores

São variáveis do mesmo tipo declaradas com o mesmo identificador e referenciadas por um índice para determinar sua localização dentro da estrutura.
Segue-se uma ilustração:
c++p3_img01

Codificação
Pseudocódigo

Declaração:
declare brasilCp : matriz[1..5] inteiro

Operações básicas:
Atribuição:     brasilCp[5] <-- 02
Leitura/atribuição:     var <-- brasilCp[3]
Escrita:     escreva (brasilCp[3])
C++

Declaração:
int brasilCp[4];

Operações básicas:
Atribuição:     brasilCp[4] = 02;
Leitura/atribuição:     cp = brasilCp(2);
Escrita:     cout<< brasilCp(2);

Exemplo:
Calcular a média aritmética das notas de uma classe com cinco alunos, apresentar a média da turma e as notas iguais ou acima dessa média.

Diagrama de blocos
c++p3_img02
Pseudocódigo
programa notas_e_media
    declare notas : matriz[1..5], soma, nota, media real
    declare i inteiro
    soma <-- 0
    para i de 1 até 5 faça
       escreva('Entre com a ', i, 'a. nota: ')
       leia(nota)
       soma <-- soma + nota
       notas[i] <-- nota
    fim para
    media <-- soma / 5
    escreva('Relacao das notas maiores ou iguais a media: ', media)
    para i de 1 até 5 faça
       se notas[i] > media então
          escreva(notas[i])
       fim se
    fim para
Fim programa
C++
#include <iostream.h>
void main()
{
    float nota[5];    // declaração do vetor
    float media=0;
    for(int i=0; i<5; i++)
    {
       cout<<"Digite a "<<(i+1)<<"a.nota: ";
       cin>>nota[i];    //  armazena a nota no vetor
       media += nota[i];
    }
    media /= 5;
    cout<<"\nRelacao das notas maiores ou iguais a media: "<<media<<endl;
    for(i=0; i<5; i++)
   {
       if(nota[i]>=media)
       cout<<nota[i]<<endl;    // lista a nota a partir do vetor
   }
}
 
 

Matrizes bidimensionais

Exemplo:
Elaborar um algoritmo para carregar uma matriz 5 x 3 com valores das vendas de uma empresa, em que cada linha represente as vendas de um vendedor e cada coluna um mês de vendas.
Em seguida, determinar e escrever o código do vendedor e o valor das vendas daqueles que venderam acima da média.
Esquema de armazenamento:
c++p3_img03
Diagrama de blocos
c++p3_img04
Pseudocódigo
programa vendas
     declare venda : matriz [1..5,1..3], soma, media real
     declare i, j, k  inteiro
     soma <-- 0; k <-- 0
     para i de 1 até 5 faça
         para j de 1 ate 3 faça
             escreva('Insira o valor da venda – vendedor: ', i*10,  '  mês: ', j)
             leia(venda[i,j])
             soma <-- soma + venda[i,j]
         fim para
     fim para
     media  <-- soma / 5;
     para i de 1 até 5 faça
         soma <-- 0;
         para j de 1 até 3 faça
             soma <-- soma + venda[i,j];
         fim para
         Se soma > media then
             k <-- k +1
             escreva(' Vendedor: ', i*10, ' Valor: ', soma);
         fim se
     fim para
Fim programa.
C++
#include <iostream.h>
void main()
{
     float vendas[5][3];     // declaração da matriz
     float soma=0, media;
     for(int i=0; i<5; i++)
         for(int j=0; j<3; j++)
         {
             cout<<"Insira o valor da venda - vendedor: "<<((i+1)*10)<<" mês “ <<j+1<<": ";
             cin>>vendas[i][j];     // armazena na matriz
             soma += vendas[i][j];
         }
     media = soma / 5;
     for(i=0; i<5; i++)
     {
         soma = 0;
         for(j=0; j<3; j++)
             soma += vendas[i][j];
         if (soma>media)
             cout<<"\nVendedor: "<<((i+1)*10)<<" valor: "<<soma;
     }
}
 
 

Matriz bidimensional de strings

Exemplo de matriz bidimensional de strings:
Ana Maria
Blumenau
SC
José da Silva
Curitiba
PR
João Antônio
Joinville
SC
Maria José
Torres
RS
Codificação
Pseudocódigo

Declaração:
declare alunos : matriz[1..4,1..3] caractere
Operações básicas:
Atribuição:
alunos[1,1] <-- 'Ana Maria'
alunos[1,2] <-- 'Blumenau'
alunos[1,3] <-- 'SC'
Leitura/atribuição:
nome <-- alunos[2,1]
Escrita:
escreva (alunos[4,3])
C++

Declaração:
char alunos [4][3][20]
Operações básicas:
Atribuição:
strcpy (alunos [1][1], "Ana Maria");
strcpy (alunos [1][2], "Blumenau");
strcpy (alunos [1][3], "SC");
Leitura/atribuição:
nome = alunos[1][2];
Escrita:
cout << alunos[1][2];

A seguir é apresentado um programa que armazena os dados informados pelo usuário numa matriz do tipo do exemplo mostrado e, em seguida, exibe os valores armazenados a partir dessa matriz.

#include<iostream.h>
void main() {
    char alunos[4][3][20];
    for(int i=0; i<4; i++)
        for(int j=0; j<3; j++) {
            if (j==0) {
                cout<<"Informe o nome: ";
                cin.getline(alunos[i][j],20);
            }
            else if (j==1) {
                cout<<"Informe a cidade: ";
                cin.getline(alunos[i][j],20);
            }
            else {
                cout<<"Informe o estado: ";
                cin.getline(alunos[i][j],20);
            }
        }
    for(i=0; i<4; i++) {
        cout<<'\n';
        for(int j=0; j<3; j++)
            cout<<alunos [i][j]<<endl;
    }
}
 
 

Funções

Uma função é um segmento de programa que executa uma tarefa específica.
Um programa pode conter várias funções, devendo ter no mínimo uma função chamada main() através da qual é iniciada a execução do programa.

Protótipo de funções

A instrução de declaração que estabelece o tipo da função e os argumentos que ela recebe é chamada de protótipo.
O protótipo da função, geralmente, é codificado no início do programa uma vez que ele deve preceder a definição e a chamada da função correspondente.
O tipo da variável especificado no protótipo é obrigatório, porém a informação do nome da variável é facultativa.

Definição da função

A seguir é mostrado um exemplo de um programa com uma função criada pelo usuário para calcular a média aritmética de dois números reais:

#include<iostream.h>
float media(float n1, float n2);         // protótipo da função
void main( )
{
    float num1, num2, med;
    cout<<"\nDigite dois números: ";
    cin >> num1 >> num2;
    med = media(num1, num2);         // chamada à função
    cout<<"\nMedia = " << med;
}
// Definição da função
float media(float n1, float n2)
{
    float m;
    m = (n1 + n2) / 2;
    return m;
}
 
 

Passagem de parâmetros

Por valor
Os valores das variáveis do programa chamador são copiados para as correspondentes variáveis da função chamada. O programa anterior é um exemplo.
Por referência
A função chamada pode acessar e modificar o conteúdo das variáveis da função chamadora, não ocorrendo nenhuma cópia de valores.
Segue um exemplo de passagem de parâmetros por referência:

#include<iostream.h>
void celsius (int& fahr, int& cels);         // protótipo da função
void main()
{
    int f, c;
    cout<<"Insira a temperatura em graus Fahrenheit: ";
    cin>>f;
    celsius(f,c);         // chamada à função
    cout<<"\nTemperatura em graus Celsius: "<<c<<endl;
}
// Definição da função
void celsius(int& fahr, int& cels)
{
    cels = (fahr - 32) * 5 / 9;
}

Passagem de parâmetros por referência
É utilizado o operador & na declaração do tipo do argumento da função receptora. 
As variáveis fahr e cels declaradas na função celsius() são as mesmas variáveis f e c da função principal, apenas referenciadas por outros nomes. 
Portanto, qualquer  modificação de conteúdo das variáveis fahr e cels realizada pela função celsius() são automaticamente refletidas nas variáveis f e c da função main().

Passagem e retorno de valores
As funções do tipo void não retornam nenhum valor e podem também não receber nenhum argumento.
Segue um exemplo que recebe uma constante como argumento e não retorna nada, apenas exibe um traçado em forma de caixa com um texto interno:

#include <iostream.h>
void linha(int num);
void main()
{
    cout<<"\n\n";
    linha(23);
    cout<<"\t\t| Isto e' uma moldura |\n";
    linha(23);
}
void linha(int num)
{
    cout<<"\t\t";         // tabulação dupla
    for(int i=0; i<num; i++)
        cout<<'=';
    cout<<endl;
}
 
 

Funções do usuário armazenadas em bibliotecas

Funções de uso geral escritas pelo usuário, geralmente, são armazenadas em arquivos organizados em pastas específicas, constituindo-se nas chamadas bibliotecas do usuário.
Segue exemplo de um programa composto pela função principal e por outras duas funções armazenadas no arquivo de nome “mediaCxa.bib” da biblioteca cpp.
O programa tem objetivo efetuar o cálculo da média aritmética e exibir o resultado numa caixa de texto:
#include <iostream.h>
    /* Através da diretiva #include é indicado, entre aspas duplas, o nome do
         arquivo precedido do endereço de sua localização. */
#include"c:\cpp\mediaCxa.bib"
void main()
{
    cout<<"\n\n";
    linha(20);
    int med = media(30,20);
    cout<<"\n\t\t||   Media = "<<med<<"   ||\n";
    linha(20);
}

Conteúdo do arquivo “mediaCxa.bib”:
// Definição da função cálculo da média.
float media(float n1, float n2)
{
    float m;
    m = (n1 + n2) / 2;
    return m;
}
// Definição da função caixa de texto.
void linha(int num)
{
    cout<<"\t\t";
    for(int i=0; i<num; i++)
        cout<<'=';
}
 
 

Passando vetores para funções

Assim como as variáveis, os vetores e matrizes podem ser passados como argumento para uma função.
Sintaxe da passagem para a função:
nome_função (nome_vetor, elementos_vetor)
Sintaxe do recebimento pela função:
tipo nome_função (tipo nome_vetor[ ], tipo elementos_vetor)

A seguir é mostrado um exemplo que passa vetores para a função exibe() para imprimir o conteúdo desses vetores:

#include <iostream.h>
void exibe (int lista[], int elementos);         // protótipo da função
void main()
{
    int par[10] = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20};         // declaração e inicialização
    int impar[10] = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};       // idem
    cout<<"\nNumeros pares: ";
    exibe(par,10);         // chama a função exibe
    cout<<"\nNumeros impares: ";
    exibe(impar, 10);         // chama a função exibe
}
void exibe (int lista[], int elementos)         // recebe os agumentos
{
    for(int i=0; i<elementos; i++)
        cout<<lista[i]<<' ';
}

(Como se vê, na chamada à função exibe(), o nome da matriz é escrito sem colchetes, cujo  argumento é recepcionado numa variável seguida de colchetes vazios.)
 
 

Bibliografia

  • ASCENCIO, Ana Fernanda Gomes, CAMPOS, Edilene Aparecida Veneruchi de. Fundamentos da programação de computadores : algoritmos, Pascal e C/C. São Paulo : Prentice Hall, 2002. xviii, 355p.
  • FORBELLONE, André Luiz Villar; EBERSPACHER, Henri Frederico. Lógica de programação : a construção de algoritmos e estruturas de dados. 2.ed. São Paulo : Makron Books, 2000. 197p.
  • JAMSA, Kris A. Aprendendo C. São Paulo : Makron Books do Brasil, 1999. 271p.
  • MIZRAHI, Victorine Viviane. Treinamento em linguagem C. Sao Paulo : Makron, 1994. v.
  • BERRY, John Thomas. Programando em C. Sao Paulo : Makron Books, 1991. xvi, 385p.
  • UCCI, Waldir; SOUSA, Reginaldo Luiz; KOTANI, Alice Mayumi, et al. . Lógica de programação : os primeiros passos. 8.ed. Sao Paulo : Erica, 1999. 339p.