3. Normas-sobre-Programacao

Prévia do material em texto

1 
Algoritmos e Estruturas de Dados I IBm1014 
Departamento de Computação e Matemática 1º Semestre/2012 
 Prof. Dr. José Augusto Baranauskas Normas sobre Programação 
 
I. Normas Gerais sobre Programação 
1. Sempre escolha nomes significativos para variáveis, funções e procedimentos 
2. Mantenha a documentação concisa e descritiva 
3. Lembrar que o tempo de leitura e compreensão de um programa é muito maior do que o tempo para escrevê-
lo. A leitura do programa deve ser o mais fácil possível 
4. As três de estruturas de controle em programação são: 
• sequência: um comando é executado após o comando anterior 
• seleção: comandos alternativos são executados dependendo do valor de uma condição (que assume valor 
verdadeiro ou falso) e 
• repetição: uma sequência de comandos é executada zero, uma ou mais vezes 
o dependendo de um número pré-estabelecido de repetições (laço contado) 
o o laço é repetido enquanto uma condição é verdadeira (laço condicional) 
5. Cada subprograma (função ou procedimento) deve fazer uma única tarefa e deve fazê-la corretamente 
6. Inclua comentários (pré-condições e pós-condições) antes do início de cada programa, função ou 
procedimento 
7. Mantenha a conexão programa-subprogramas o mais simples possível. Evite usar variáveis globais sempre 
que possível 
8. Nunca cause efeitos colaterais se puder evitá-los. Se usar variáveis globais em subprogramas, documente-as 
exaustivamente 
9. Mantenha entradas e saídas como subprogramas separados. Assim eles podem ser alterados facilmente 
10. Testes de programas servem para determinar a presença de erros (bugs), mas nunca a sua ausência 
 
II. Normas sobre Programação em C++ 
1. Todo comando em C/C++ termina com um ponto-e-vírgula (;) 
2. Alinhe um { na mesma coluna que seu } correspondente. Todos os comandos entre { e } devem ser 
deslocados dois espaços para a direita 
3. Todo programa C++ inicia sua execução no programa principal, denominado main: 
#include <iostream> 
using namespace std; 
 
int main() 
{ /* a execução tem início aqui... */ 
 
 return 0; /* término da execução */ 
} 
4. Ao utilizar qualquer estrutura de seleção ou repetição, por exemplo, comandos de seleção (if, switch) ou de 
repetição (for, while, do-while), desloque dois espaços para a direita (indentation) os comandos contidos 
neles. Se há vários níveis de indentation, cada nível deve ser deslocado à direita por dois espaços 
5. O comando break usado nos comandos while, for, do/while, ou switch causa a saída imediata dessas 
estruturas para o próximo comando 
6. O comando continue usado nos comando while, for, do/while faz com que o controle do programa passe para 
o próximo passo da iteração. Nos comandos while e do/while as condições são imediatamente avaliadas após 
encontrar um continue; no comando for a expressão de incremento é executada e então a condição de 
término do comando for é avaliada. 
7. Colocar um ponto-e-vírgula logo após um comando de seleção ou repetição constitui um erro. Por exemplo, 
a mensagem “a igual b” sempre será impressa, independentemente se a é ou não igual a b nos comandos 
seguintes: 
if (a == b) ; 
 cout << ”a igual b”; 
8. Evite colocar mais de um comando em uma mesma linha 
9. Evite usar somente letras maiúsculas. Letras minúsculas são menos agressivas ao leitor. Intercale o uso de 
primeira letra maiúscula com as demais letras minúsculas em nomes compostos de variáveis e subprogramas. 
Por exemplo: TrianguloRetangulo é preferível a trianguloretangulo ou TRIANGULORETANGULO 
10. A linguagem C/C++ é sensível a letras maiúsculas e minúsculas. Por exemplo, os identificadores 
hipotenusa, Hipotenusa e HIPOTENUSA representam variáveis distintas. Evite usar esse recurso, pois as 
 2 
pessoas que forem ler o seu programa ficarão confusas com esses nomes similares sendo utilizados para 
diferentes itens de dados. 
11. Nunca utilize como identificadores (nomes de variáveis ou sub-programas) as seguintes palavras reservadas: 
asm auto bool break case catch char class const const_cast continue 
default delete do double dynamic_cast else enum extern 
false float for friend goto if inline int long mutable namespace new 
operator private protected public register reinterpret_cast return 
short signed sizeof static struct switch 
template this throw try typedef typeid typename union unsigned using 
virtual void volatile wchar_t while 
bitand and bitor xor compl and_eq or_eq xor_eq not not_eq 
12. Caso exista um único comando “dentro” (ou seja, que faz parte) de um comando de seleção ou repetição, o 
uso de { e } é opcional e é normalmente omitido. Por exemplo, os comandos 12a e 12b são equivalentes; 
entretanto a notação 12a é preferível e a mais utilizada: 
(12a) (12b) 
if (a > b) 
x = a; 
y = b; 
if (a > b) 
{ x = a; 
} 
y = b; 
13. Se há mais de um comando “dentro” de um comando de seleção ou repetição, o uso de { e } é obrigatório. 
Por exemplo, os comandos 13a e 13b não são equivalentes: a situação 13b causa um laço que nunca termina 
(loop infinito): 
(13a) (13b) 
i = 1; 
while(i <= 10) 
{ cout << i << endl; 
 i = i + 1; 
} 
i = 1; 
while(i <= 10) 
 cout << i << endl; 
i = i + 1; 
 
14. Resumo das estruturas de controle, no qual cmd são comandos, cond são condições. const são constantes e 
var é uma variável enumerável (inteira ou caractere) 
 
Sequência Seleção Seleção Repetição 
cmd1; 
cmd2; 
if (cond) 
 cmd; 
while (cond) 
 cmd1; 
if (cond) 
{ cmd1; 
 cmd2; 
} 
while (cond) 
{ cmd1; 
 cmd2; 
} 
for(inicial;cond;incremento) 
 cmd1; 
if (cond) 
 cmd1; 
else 
 cmd2; 
for(inicial;cond;incremento) 
{ cmd1; 
 cmd2; 
} 
do 
{ cmd1; 
 cmd2; 
} while (cond); 
{ cmd1; 
 cmd2; 
} 
if (cond) 
{ cmd1; 
 cmd2; 
} 
else 
 cmd3; 
switch (var) 
{ case const1: 
 cmd1; 
 break; 
 
 case const2: 
case const3: 
 cm2; 
 cm3; 
 break; 
 
default: 
 cmd4; 
 cmd5; 
} 
do 
 cmd1; 
 cmd2; 
while (cond); 
 
15. Equivalência entre bibliotecas C e C++ (#include <biblioteca>): 
 
C C++ Descrição Observação 
stdio.h iostream Entrada/Saída using namespace std; 
 iomanip Formatação de entrada e saída 
math.h cmath Funções Matemáticas 
string.h cstring Manipulação de strings 
stdlib.h cstdlib Funções de propósito geral 
 
16. Equivalência entre comandos pseudo-código, C e C++: 
 3 
 
Pseudo-Código C C++ 
Leia(A) A inteiro: scanf(“%d”,&A); 
A real: scanf(“%f”,&A); 
A caracter: scanf(“%c”,&A); 
A string: scanf(“%s”,&A); 
cin >> A; 
Leia(A,B,C,D) A inteiro, B real, C caracter e D string 
scanf(“%d %f %c %s”,&A,&B,&C,&D); 
 
cin >> A >> B >> C >> D; 
Escreva(A,B,C,D) A inteiro, B real, C caracter e D string 
printf(“%d %f %c %s”,A,B,C,D); 
 
printf(“%d %f %c %s\n”,A,B,C,D); 
 
cout << A << ” ” << B << ” ” 
 << C << ” ” << D; 
cout << A << ” ” << B << ” ” 
 << C << ” ” << D << endl; 
 
printf(”%4d”,A); cout << setw(4) << A; 
 
printf(”\n”); cout << endl; 
 
printf(”\n”); cout << ”\n”; 
Comentários Entre /* e */ Entre /* e */ 
// até o final da linha 
 
Comandos de sequência (incluindo atribuição), seleção e repetição são idênticos entre C e C++; o mesmo se 
aplica à aritmética e prioridade de operadores (lógicos, relacionais e aritméticos). 
 
Exemplo C Exemplo C++ 
#include <stdio.h> 
 
/* Algoritmo Conversão. Este algoritmo lê uma 
temperatura na escala Celsius (oC) e imprime a 
equivalente em Fahrenheit (oF). 
*/ 
void main(void) 
{ float C, F; 
 /* um comentário até o final da linha */ 
 printf(”Temperatura em graus Celsius?”); 
 scanf(”%f”,&C); 
 F = 9.0 / 5.0 * C + 32; 
 printf(”\nTemperatura em graus Fahrenheit= 
%f\n”,F); 
 if(C > 25) 
 printf(”Muito quente\n”); 
 else 
 printf(”Agradável\n”); 
} 
 
#include<iostream> 
using namespace std; 
/* Algoritmo Conversão. Este algoritmo lê uma 
temperatura na escala Celsius (oC) e imprime a 
equivalente em Fahrenheit (oF). 
*/ 
int main() 
{ float C, F; 
 // um comentário até o final da linha 
 cout << ”Temperatura em graus Celsius? ”; 
 cin >> C; 
 F = 9.0 / 5.0 * C + 32; 
 cout << ”\nTemperatura em graus Fahrenheit= ” 
 << F << endl; 
 if(C > 25) 
 cout << ”Muito quente\n”; 
 else 
 cout << ”Agradável” << endl; 
 
 return 0; 
} 
 
17. Extensões do código-fonte 
• Código-fonte em C: extensão .c (letra “c” minúscula) 
• Código-fonte em C++: extensões . em C++: .cpp, .cxx, .C (letra “C” maiúscula). Recomenda-se a 
extensão .cpp. 
 
18. Constantes Simbólicas em C++ 
Frequentemente, uma mesma constante é utilizada em várias partes de um programa. Para facilitar o 
entendimento, pode-se declarar uma constante simbólica, ou seja, uma constante com um nome associado. Em 
C++, a declaração de constantes simbólicas é efetuada por meio do modificador const. Por exemplo: 
• const int Max = 100; 
• const int N = 8; 
 
É óbvio que não é permitido alterar o valor de uma constante. Considere o seguinte fragmento de código C++: 
Observe, no exemplo seguinte, que o uso de constantes simbólicas melhora o entendimento do código, além de 
facilitar qualquer alteração da dimensão dos vetores v e s: basta apenas alterar o valor definido pela constante 
simbólica max. 
 
 4 
Sem uso de constante simbólica Com uso de constante simbólica 
 
int n,i,v[11], s[10]; 
 
cin >> n; 
if (n > 10) 
{ cout << “muito grande” << endl; 
 abort(); 
} 
const int max = 10; 
int n,i,v[max+1], s[max]; 
 
cin >> n; 
if (n > max) 
{ cout << “muito grande” << endl; 
 abort(); 
} 
 
19. Passagem de parâmetros em C++ 
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: 
• Passagem de parâmetros por valor 
o 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; 
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 de parâmetros por variável (ou por referência ou por endereço) 
o 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; 
o Quaisquer alterações (das variáveis passadas por referência) efetuadas dentro do sub-algoritmo 
causam a alterações nos parâmetros de chamada. 
Em 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 
o float f1(int a, float b, int c) 
o 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 
o float f2(int &a, float b, double &c) 
o parâmetros a e c são passados por referência, parâmetro b é passado por valor 
• void p2(int &n, float a[]) 
o parâmetros n, a são passados por referência 
Importante: vetores e matrizes sempre 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. 
 
20. 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.