Slide - Subalgoritmos em C e C - Introdução à Computação 2 - 2023-2

1.1. Sub-algoritmos (Funções e Procedimentos) em C/C++ ❑ Nesta aula veremos o conceito de sub-algoritmo (ou sub-rotina): funções e procedimentos ❑ Sub-algoritmos são blocos de instruções que realizam tarefas específicas ❑ O código de um sub-algoritmo é carregado uma vez e pode ser executado quantas vezes for necessário ❑ Assim, os programas tendem a ficar menores e mais organizados, uma vez que o problema pode ser dividido em tarefas menores 2 Sub-algoritmos em C++ ❑A declaração (definição) de um sub-algoritmo (função ou procedimento) em C++ é similar à do programa principal (main) ❑Sub-algoritmos preferencialmente devem ser declarados antes do programa que os chama ❑É permitido declarar variáveis dentro do sub- algoritmo ▪ As variáveis declaradas dentro do sub-algoritmo, incluindo os parâmetros são denominadas variáveis locais 3 Funções em C++ ❑Função f(x) = x2 - 3x + 2 float f(float x) { return(x * x - 3 * x + 2); } 4 Funções em C++ ❑Função f(x) = x2 - 3x + 2 float f(float x) { return(x * x - 3 * x + 2); } Indica o tipo de dado que a função deve retornar. Neste caso, a função retorna um número real 5 Funções em C++ ❑Função f(x) = x2 - 3x + 2 float f(float x) { return(x * x - 3 * x + 2); } Indica o nome da função. Neste caso, f 6 Funções em C++ ❑Função f(x) = x2 - 3x + 2 float f(float x) { return(x * x - 3 * x + 2); } Indica o tipo de dado do primeiro parâmetro da função. Neste caso é um número real 7 Funções em C++ ❑Função f(x) = x2 - 3x + 2 float f(float x) { return(x * x - 3 * x + 2); } Indica o nome do primeiro parâmetro da função. Neste caso, x 8 Funções em C++ ❑Função f(x) = x2 - 3x + 2 float f(float x) { return(x * x - 3 * x + 2); } Indica o que deve ser retornado pela função 9 Funções em C++ ❑Função f(x) = x2 - 3x + 2 float f(float x) { float r; r = x * x - 3 * x + 2; return r; } Se houver necessidade, variáveis (locais) adicionais podem ser declaradas dentro da função, de forma análoga à declaração de variáveis no programa principal 10 Exemplo de Chamada em C++ #include <iostream> using namespace std; //------------------------------------------------------------ float f(float x) /* definicao da funcao f */ { return x * x - 3 * x + 2; } //------------------------------------------------------------ int main() /* programa principal */ { float a,r; a = 3; /* utilizar a funcao numa expressao simples */ r = f(a); /* ativacao de f */ cout << ”Valor de f(“ << a << “)=” << r << endl; /* utilizar a funcao numa expressao mais elaborada */ r = f(2*a) + 3 * f(1) + 2 * f(-1); /* ativacao de f */ cout << r << endl; return 0; } 11 Funções em C++ #include <iostream> using namespace std; //------------------------------------------------------ float divisao(int dividendo, int divisor) { float quociente; quociente = 1.0 * dividendo / divisor; return quociente; } //------------------------------------------------------ int main() { int a=3, b=4; cout << a << ”/” << b << ”=” << divisao(a,b) << endl; cout << b << ”/” << a << ”=” << divisao(b,a) << endl; return 0; } Memória Endereço Valor Memória Endereço Valor 12 Funções em C++ #include <iostream> using namespace std; //------------------------------------------------------ float divisao(int dividendo, int divisor) { float quociente; quociente = 1.0 * dividendo / divisor; return quociente; } //------------------------------------------------------ int main() { int a=3, b=4; cout << a << ”/” << b << ”=” << divisao(a,b) << endl; cout << b << ”/” << a << ”=” << divisao(b,a) << endl; return 0; } Memória Endereço Valor Memória Endereço Valor a 3 b 4 13 Funções em C++ #include <iostream> using namespace std; //------------------------------------------------------ float divisao(int dividendo, int divisor) { float quociente; quociente = 1.0 * dividendo / divisor; return quociente; } //------------------------------------------------------ int main() { int a=3, b=4; cout << a << ”/” << b << ”=” << divisao(a,b) << endl; cout << b << ”/” << a << ”=” << divisao(b,a) << endl; return 0; } Memória Endereço Valor Memória Endereço Valor a 3 b 4 14 Funções em C++ #include <iostream> using namespace std; //------------------------------------------------------ float divisao(int dividendo, int divisor) { float quociente; quociente = 1.0 * dividendo / divisor; return quociente; } //------------------------------------------------------ int main() { int a=3, b=4; cout << a << ”/” << b << ”=” << divisao(a,b) << endl; cout << b << ”/” << a << ”=” << divisao(b,a) << endl; return 0; } Memória Endereço Valor dividendo 3 divisor 4 Memória Endereço Valor a 3 b 4 15 Funções em C++ #include <iostream> using namespace std; //------------------------------------------------------ float divisao(int dividendo, int divisor) { float quociente; quociente = 1.0 * dividendo / divisor; return quociente; } //------------------------------------------------------ int main() { int a=3, b=4; cout << a << ”/” << b << ”=” << divisao(a,b) << endl; cout << b << ”/” << a << ”=” << divisao(b,a) << endl; return 0; } Memória Endereço Valor dividendo 3 divisor 4 quociente Memória Endereço Valor a 3 b 4 16 Funções em C++ #include <iostream> using namespace std; //------------------------------------------------------ float divisao(int dividendo, int divisor) { float quociente; quociente = 1.0 * dividendo / divisor; return quociente; } //------------------------------------------------------ int main() { int a=3, b=4; cout << a << ”/” << b << ”=” << divisao(a,b) << endl; cout << b << ”/” << a << ”=” << divisao(b,a) << endl; return 0; } Memória Endereço Valor dividendo 3 divisor 4 quociente 0.75 Memória Endereço Valor a 3 b 4 17 Funções em C++ #include <iostream> using namespace std; //------------------------------------------------------ float divisao(int dividendo, int divisor) { float quociente; quociente = 1.0 * dividendo / divisor; return quociente; } //------------------------------------------------------ int main() { int a=3, b=4; cout << a << ”/” << b << ”=” << divisao(a,b) << endl; cout << b << ”/” << a << ”=” << divisao(b,a) << endl; return 0; } Memória Endereço Valor dividendo 3 divisor 4 quociente 0.75 Memória Endereço Valor a 3 b 4 18 Funções em C++ #include <iostream> using namespace std; //------------------------------------------------------ float divisao(int dividendo, int divisor) { float quociente; quociente = 1.0 * dividendo / divisor; return quociente; } //------------------------------------------------------ int main() { int a=3, b=4; cout << a << ”/” << b << ”=” << divisao(a,b) << endl; cout << b << ”/” << a << ”=” << divisao(b,a) << endl; return 0; } Memória Endereço Valor Memória Endereço Valor a 3 b 4 3/4=0.75 19 Funções em C++ #include <iostream> using namespace std; //------------------------------------------------------ float divisao(int dividendo, int divisor) { float quociente; quociente = 1.0 * dividendo / divisor; return quociente; } //------------------------------------------------------ int main() { int a=3, b=4; cout << a << ”/” << b << ”=” << divisao(a,b) << endl; cout << b << ”/” << a << ”=” << divisao(b,a) << endl; return 0; } Memória Endereço Valor Memória Endereço Valor a 3 b 4 3/4=0.75 20 Funções em C++ #include <iostream> using namespace std; //------------------------------------------------------ float divisao(int dividendo, int divisor) { float quociente; quociente = 1.0 * dividendo / divisor; return quociente; } //------------------------------------------------------ int main() { int a=3, b=4; cout << a << ”/” << b << ”=” << divisao(a,b) << endl; cout << b << ”/” << a << ”=” << divisao(b,a) << endl; return 0; } Memória Endereço Valor dividendo 4 divisor 3 Memória Endereço Valor a 3 b 4 3/4=0.75 21 Funções em C++ #include <iostream> using namespace std; //------------------------------------------------------ float divisao(int dividendo, int divisor) { float quociente; quociente = 1.0 * dividendo / divisor; return quociente; } //------------------------------------------------------ int main() { int a=3, b=4; cout << a << ”/” << b << ”=” << divisao(a,b) << endl; cout << b << ”/” << a << ”=” << divisao(b,a) << endl; return 0; } Memória Endereço Valor dividendo 4 divisor 3 quociente Memória Endereço Valor a 3 b 4 3/4=0.75 22 Funções em C++ #include <iostream> using namespace std; //------------------------------------------------------ float divisao(int dividendo, int divisor) { float quociente; quociente = 1.0 * dividendo / divisor; return quociente; } //------------------------------------------------------ int main() { int a=3, b=4; cout << a << ”/” << b << ”=” << divisao(a,b) << endl; cout << b << ”/” << a << ”=” << divisao(b,a) << endl; return 0; } Memória Endereço Valor dividendo 4 divisor 3 quociente 1.33 Memória Endereço Valor a 3 b 4 3/4=0.75 23 Funções em C++ #include <iostream> using namespace std; //------------------------------------------------------ float divisao(int dividendo, int divisor) { float quociente; quociente = 1.0 * dividendo / divisor; return quociente; } //------------------------------------------------------ int main() { int a=3, b=4; cout << a << ”/” << b << ”=” << divisao(a,b) << endl; cout << b << ”/” << a << ”=” << divisao(b,a) << endl; return 0; } Memória Endereço Valor dividendo 4 divisor 3 quociente 1.33 Memória Endereço Valor a 3 b 4 3/4=0.75 24 Funções em C++ #include <iostream> using namespace std; //------------------------------------------------------ float divisao(int dividendo, int divisor) { float quociente; quociente = 1.0 * dividendo / divisor; return quociente; } //------------------------------------------------------ int main() { int a=3, b=4; cout << a << ”/” << b << ”=” << divisao(a,b) << endl; cout << b << ”/” << a << ”=” << divisao(b,a) << endl; return 0; } Memória Endereço Valor Memória Endereço Valor a 3 b 4 3/4=0.75 4/3=1.33 25 Funções em C++ #include <iostream> using namespace std; //------------------------------------------------------ float divisao(int dividendo, int divisor) { float quociente; quociente = 1.0 * dividendo / divisor; return quociente; } //------------------------------------------------------ int main() { int a=3, b=4; cout << a << ”/” << b << ”=” << divisao(a,b) << endl; cout << b << ”/” << a << ”=” << divisao(b,a) << endl; return 0; } Memória Endereço Valor Memória Endereço Valor a 3 b 4 3/4=0.75 4/3=1.33 26 Funções em C++ #include <iostream> using namespace std; //------------------------------------------------------ float divisao(int dividendo, int divisor) { float quociente; quociente = 1.0 * dividendo / divisor; return quociente; } //------------------------------------------------------ int main() { int a=3, b=4; cout << a << ”/” << b << ”=” << divisao(a,b) << endl; cout << b << ”/” << a << ”=” << divisao(b,a) << endl; return 0; } Memória Endereço Valor Memória Endereço Valor 3/4=0.75 4/3=1.33 27 Passagem de Parâmetros ❑Em cada chamada de um procedimento ou função, uma correspondência é estabelecida entre os argumentos (ou parâmetros) da chamada particular e os parâmetros (ou argumentos) de definição do sub-algoritmo ❑Existem duas formas de executar essa correspondência: ▪ 1) passagem de parâmetros por valor ▪ 2) passagem de parâmetros por variável (ou por referência ou por endereço) 28 Passagem de Parâmetros ❑ Passagem por Valor ▪ Ao ser efetuada uma chamada de sub-algoritmo, os parâmetros passados por valor são calculados e seus valores são atribuídos aos parâmetros de definição; ou seja, os valores são copiados para os parâmetros de definição ▪ Quaisquer alterações (nos valores das variáveis passadas por valor) efetuadas dentro do sub-algoritmo não causam alterações nos parâmetros de chamada ❑ Passagem por Variável ▪ Na passagem por variável, ao ser efetuada uma chamada de sub- algoritmo, os endereços dos parâmetros de chamada são passados aos parâmetros de definição, ou seja, a própria variável de chamada é passada ▪ Quaisquer alterações (das variáveis passadas por referência) efetuadas dentro do sub-algoritmo causam a alterações nos parâmetros de chamada 29 Passagem de Parâmetros C++ ❑ Em C/C++ a escolha de passagem por valor ou por variável é efetuada na definição de cada parâmetro ❑ Parâmetros passados por valor são declarados como variáveis comuns ▪ float f1(int a, float b, int c) ❖ parâmetros a, b, c são passados por valor ❑ Parâmetros passados por referência devem ser precedidos pelo símbolo & antes do nome do parâmetro ▪ float f2(int &a, float b, double &c) ❖ parâmetros a e c são passados por referência, parâmetro b é passado por valor ▪ void p2(int &n, float a[]) ❖ parâmetros n, a são passados por variável ❑ Importante: vetores e matrizes são sempre passados por variável e o símbolo & é omitido ▪ É desnecessário informar o tamanho dos vetores usados como parâmetros ▪ Para matrizes é necessário declarar o tamanho de todas as dimensões exceto a primeira 30 Passagem por Valor 1 #include <iostream> 2 using namespace std; 3 //------------------------ 4 void soma1(int X) 5 { X = X + 5; 6 } 7 //------------------------ 8 int main() 9 { int A; 10 A = 0; 11 soma1(A); 12 cout << A << endl; 13 return 0; 14 } Memória Endereço Valor Memória Endereço Valor 31 Passagem por Valor 1 #include <iostream> 2 using namespace std; 3 //------------------------ 4 void soma1(int X) 5 { X = X + 5; 6 } 7 //------------------------ 8 int main() 9 { int A; 10 A = 0; 11 soma1(A); 12 cout << A << endl; 13 return 0; 14 } Memória Endereço Valor Memória Endereço Valor A 32 Passagem por Valor 1 #include <iostream> 2 using namespace std; 3 //------------------------ 4 void soma1(int X) 5 { X = X + 5; 6 } 7 //------------------------ 8 int main() 9 { int A; 10 A = 0; 11 soma1(A); 12 cout << A << endl; 13 return 0; 14 } Memória Endereço Valor Memória Endereço Valor A 0 33 Passagem por Valor 1 #include <iostream> 2 using namespace std; 3 //------------------------ 4 void soma1(int X) 5 { X = X + 5; 6 } 7 //------------------------ 8 int main() 9 { int A; 10 A = 0; 11 soma1(A); 12 cout << A << endl; 13 return 0; 14 } Memória Endereço Valor Memória Endereço Valor A 0 34 Passagem por Valor 1 #include <iostream> 2 using namespace std; 3 //------------------------ 4 void soma1(int X) 5 { X = X + 5; 6 } 7 //------------------------ 8 int main() 9 { int A; 10 A = 0; 11 soma1(A); 12 cout << A << endl; 13 return 0; 14 } Memória Endereço Valor X 0 Memória Endereço Valor A 0 35 Passagem por Valor 1 #include <iostream> 2 using namespace std; 3 //------------------------ 4 void soma1(int X) 5 { X = X + 5; 6 } 7 //------------------------ 8 int main() 9 { int A; 10 A = 0; 11 soma1(A); 12 cout << A << endl; 13 return 0; 14 } Memória Endereço Valor X 5 Memória Endereço Valor A 0 36 Passagem por Valor 1 #include <iostream> 2 using namespace std; 3 //------------------------ 4 void soma1(int X) 5 { X = X + 5; 6 } 7 //------------------------ 8 int main() 9 { int A; 10 A = 0; 11 soma1(A); 12 cout << A << endl; 13 return 0; 14 } Memória Endereço Valor Memória Endereço Valor A 0 37 Passagem por Valor 1 #include <iostream> 2 using namespace std; 3 //------------------------ 4 void soma1(int X) 5 { X = X + 5; 6 } 7 //------------------------ 8 int main() 9 { int A; 10 A = 0; 11 soma1(A); 12 cout << A << endl; 13 return 0; 14 } Memória Endereço Valor Memória Endereço Valor A 0 0 38 Passagem por Valor 1 #include <iostream> 2 using namespace std; 3 //------------------------ 4 void soma1(int X) 5 { X = X + 5; 6 } 7 //------------------------ 8 int main() 9 { int A; 10 A = 0; 11 soma1(A); 12 cout << A << endl; 13 return 0; 14 } Memória Endereço Valor Memória Endereço Valor A 0 0 39 Passagem por Valor 1 #include <iostream> 2 using namespace std; 3 //------------------------ 4 void soma1(int X) 5 { X = X + 5; 6 } 7 //------------------------ 8 int main() 9 { int A; 10 A = 0; 11 soma1(A); 12 cout << A << endl; 13 return 0; 14 } Memória Endereço Valor Memória Endereço Valor 0 40 Passagem por Valor 1 #include <iostream> 2 using namespace std; 3 //------------------------ 4 void soma1(int X) 5 { X = X + 5; 6 } 7 //------------------------ 8 int main() 9 { int A; 10 A = 0; 11 soma1(A); 12 cout << A << endl; 13 return 0; 14 } Linha A X 8 9 10 0 11 0 4 0 0 5 0 5 6 0 12 0 13 0 14 41 Passagem por Valor 1 #include <iostream> 2 using namespace std; 3 //------------------------ 4 void soma1(int X) 5 { X = X + 5; 6 } 7 //------------------------ 8 int main() 9 { int A; 10 A = 0; 11 soma1(A); 12 cout << A << endl; 13 return 0; 14 } main 0 A soma1 0 X soma1(A) 42 Passagem por Variável 1 #include <iostream> 2 using namespace std; 3 //------------------------ 4 void soma2(int &X) 5 { X = X + 5; 6 } 7 //------------------------ 8 int main() 9 { int A; 10 A = 0; 11 soma2(A); 12 cout << A << endl; 13 return 0; 14 } Memória Endereço Valor Memória Endereço Valor 43 Passagem por Variável 1 #include <iostream> 2 using namespace std; 3 //------------------------ 4 void soma2(int &X) 5 { X = X + 5; 6 } 7 //------------------------ 8 int main() 9 { int A; 10 A = 0; 11 soma2(A); 12 cout << A << endl; 13 return 0; 14 } Memória Endereço Valor Memória Endereço Valor & colocado na definição de um parâmetro indica que ele será passado por referência, ou seja, seu endereço será passado 44 Passagem por Variável 1 #include <iostream> 2 using namespace std; 3 //------------------------ 4 void soma2(int &X) 5 { X = X + 5; 6 } 7 //------------------------ 8 int main() 9 { int A; 10 A = 0; 11 soma2(A); 12 cout << A << endl; 13 return 0; 14 } Memória Endereço Valor Memória Endereço Valor 45 Passagem por Variável 1 #include <iostream> 2 using namespace std; 3 //------------------------ 4 void soma2(int &X) 5 { X = X + 5; 6 } 7 //------------------------ 8 int main() 9 { int A; 10 A = 0; 11 soma2(A); 12 cout << A << endl; 13 return 0; 14 } Memória Endereço Valor Memória Endereço Valor A 46 Passagem por Variável 1 #include <iostream> 2 using namespace std; 3 //------------------------ 4 void soma2(int &X) 5 { X = X + 5; 6 } 7 //------------------------ 8 int main() 9 { int A; 10 A = 0; 11 soma2(A); 12 cout << A << endl; 13 return 0; 14 } Memória Endereço Valor Memória Endereço Valor A 0 47 Passagem por Variável 1 #include <iostream> 2 using namespace std; 3 //------------------------ 4 void soma2(int &X) 5 { X = X + 5; 6 } 7 //------------------------ 8 int main() 9 { int A; 10 A = 0; 11 soma2(A); 12 cout << A << endl; 13 return 0; 14 } Memória Endereço Valor Memória Endereço Valor A 0 48 Passagem por Variável 1 #include <iostream> 2 using namespace std; 3 //------------------------ 4 void soma2(int &X) 5 { X = X + 5; 6 } 7 //------------------------ 8 int main() 9 { int A; 10 A = 0; 11 soma2(A); 12 cout << A << endl; 13 return 0; 14 } Memória Endereço Valor Memória Endereço Valor A 0 X 49 Passagem por Variável 1 #include <iostream> 2 using namespace std; 3 //------------------------ 4 void soma2(int &X) 5 { X = X + 5; 6 } 7 //------------------------ 8 int main() 9 { int A; 10 A = 0; 11 soma2(A); 12 cout << A << endl; 13 return 0; 14 } Memória Endereço Valor Memória Endereço Valor A 5 X 50 Passagem por Variável 1 #include <iostream> 2 using namespace std; 3 //------------------------ 4 void soma2(int &X) 5 { X = X + 5; 6 } 7 //------------------------ 8 int main() 9 { int A; 10 A = 0; 11 soma2(A); 12 cout << A << endl; 13 return 0; 14 } Memória Endereço Valor Memória Endereço Valor A 5 X 51 Passagem por Variável 1 #include <iostream> 2 using namespace std; 3 //------------------------ 4 void soma2(int &X) 5 { X = X + 5; 6 } 7 //------------------------ 8 int main() 9 { int A; 10 A = 0; 11 soma2(A); 12 cout << A << endl; 13 return 0; 14 } Memória Endereço Valor Memória Endereço Valor A 5 5 52 Passagem por Variável 1 #include <iostream> 2 using namespace std; 3 //------------------------ 4 void soma2(int &X) 5 { X = X + 5; 6 } 7 //------------------------ 8 int main() 9 { int A; 10 A = 0; 11 soma2(A); 12 cout << A << endl; 13 return 0; 14 } Memória Endereço Valor Memória Endereço Valor A 5 5 53 Passagem por Variável 1 #include <iostream> 2 using namespace std; 3 //------------------------ 4 void soma2(int &X) 5 { X = X + 5; 6 } 7 //------------------------ 8 int main() 9 { int A; 10 A = 0; 11 soma2(A); 12 cout << A << endl; 13 return 0; 14 } Memória Endereço Valor Memória Endereço Valor 5 54 Passagem por Variável 1 #include <iostream> 2 using namespace std; 3 //------------------------ 4 void soma2(int &X) 5 { X = X + 5; 6 } 7 //------------------------ 8 int main() 9 { int A; 10 A = 0; 11 soma2(A); 12 cout << A << endl; 13 return 0; 14 } Linha A X 8 9 10 0 11 0 4 0 0 5 5 5 6 5 12 5 13 5 14 55 Passagem por Variável 1 #include <iostream> 2 using namespace std; 3 //------------------------ 4 void soma2(int &X) 5 { X = X + 5; 6 } 7 //------------------------ 8 int main() 9 { int A; 10 A = 0; 11 soma2(A); 12 cout << A << endl; 13 return 0; 14 } main 0 A soma2 X soma2(A) 56 Regras de Escopo de Identificadores ❑ Um identificador consiste em um nome de variável, tipo de dado, sub-algoritmo ou constante simbólica ❑ O escopo de um identificador é a região do programa na qual ele pode ser referenciado ▪ Parâmetros e variáveis locais de um sub-algoritmo só podem ser referenciados diretamente dentro do próprio sub-algoritmo; nenhum outro sub-algoritmo pode fazer referência a eles ❑ Os parâmetros e as variáveis definidas em um sub-algoritmo são variáveis locais ▪ Uma variável local é criada (alocada na memória) no momento em que o sub-algoritmo que a define é chamado ▪ Uma variável local é liberada da memória no momento em que o sub-algoritmo que a define termina ▪ O escopo de uma variável local é dentro do sub-algoritmo que a define ❑ Caso um mesmo identificador (nome de variável) seja declarado em sub-algoritmos distintos, esses identificadores são considerados distintos entre si (variáveis distintas) ❑ O uso de variáveis locais minimiza a ocorrência de “efeitos colaterais” em programação: o programador pode definir e utilizar as variáveis que desejar em um sub-algoritmo sem interferir com outros sub-algoritmos ❑ As variáveis definidas na “camada” mais externa de um programa são denominadas globais e têm sua existência durante toda a execução do programa ❑ O uso de variáveis globais deve ser evitado, pois elas podem ser alteradas por quaisquer sub-algoritmos 57 Exemplo 1 #include <iostream> #include <iomanip> using namespace std; //----------------------------------------------- int i; // variavel global //----------------------------------------------- void escreve(int n) { cout << "Imprimindo de 1 ate " << n << endl; for(i=1; i<=n; i++) cout << setw(4) << i; cout << endl; } //----------------------------------------------- int main() { cout << "Qtde a ser impressa "; cin >> i; cout << "Qtde = " << i << endl; escreve(i); cout << "Qtde = " << i << endl; return 0; } Qtde a ser impressa 7 Qtde = 7 Imprimindo de 1 ate 7 1 2 3 4 5 6 7 Qtde = 8 58 Exemplo 2 #include <iostream> #include <iomanip> using namespace std; //----------------------------------------------- void escreve(int n) { int i; // variavel local cout << "Imprimindo de 1 ate " << n << endl; for(i=1; i<=n; i++) cout << setw(4) << i; cout << endl; } //----------------------------------------------- int main() { int i; // variavel local cout << "Qtde a ser impressa "; cin >> i; cout << "Qtde = " << i << endl; escreve(i); cout << "Qtde = " << i << endl; return 0; } Qtde a ser impressa 7 Qtde = 7 Imprimindo de 1 ate 7 1 2 3 4 5 6 7 Qtde = 7 59 Exemplo 3 #include <iostream> using namespace std; //-------------------------------------------------------- // Calcula a media dos elementos 1 ate n do vetor v float media(int n, float v[]) { int i; float soma=0.0; for(i=1; i<=n; i++) soma = soma + v[i]; return soma / n; } //-------------------------------------------------------- int main() { int i; float x[]={0,10,20,30,40,50},y[]={0,1,5,10,15,20,25,30,25,40,45}; cout << "Media x=" << media(5,x) << endl; cout << "Media y=" << media(10,y) << endl; return 0; } Media x=30.00 Media y=21.60 Lembre-se que todo vetor/matriz em C/C++ é sempre passado por referência e que o símbolo “&” não deve ser utilizado nesse caso. Note também que é desnecessário informar o tamanho dos vetores usados como parâmetros 60 Exemplo 4 #include <iostream> using namespace std; const int Max=5; //----------------------------------------------------------- // Calcula soma dos elementos de uma matriz quadrada ordem n float soma_matriz(int n, float m[][Max+1]) { int i, j; float soma=0.0; for (i=1; i<=n; i++) for (j=1; j<=n; j++) soma = soma + m[i][j]; return soma; } //----------------------------------------------------------- int main() { int x, y, n=Max; float matriz[Max+1][Max+1]; for (x=1; x<=n; x++) for (y=1; y<=n; y++) { cout << "Elemento [" << x << "," << y << "] ? "; cin >> matriz[x][y]; } cout << "\nA soma dos elementos da matriz = " << soma_matriz(n,matriz) << endl; return 0; } Para matrizes, é necessário declarar o tamanho de todas as dimensões, exceto a primeira dimensão 61 Copyright© Apresentação 2019 por José Augusto Baranauskas Universidade de São Paulo Professores são convidados a utilizarem esta apresentação da maneira que lhes for conveniente para uso não comercial, desde que esta nota de copyright permaneça intacta. (editado por Renato Tinós em 2022)