Instruções das Linguagens C e C++

Prévia do material em texto

APOSTILA: LINGUAGENS DE PROGRAMAÇÃO C E C++ 
Angelo Passaro Página IV.1 Segunda revisão / 2002 
 
IIVV.. IINNSSTTRRUUÇÇÕÕEESS DDAASS LLIINNGGUUAAGGEENNSS CC EE CC++++ 
As linguagens C e C++ apresentam um número muito pequeno de instruções. Como 
conseqüência, não é difícil conhecer e aprender as instruções básicas da linguagem. Contudo, 
isto não faz com que essas linguagens sejam fáceis de usar, pois o número pequeno de 
instruções (ou comandos) é compensado pela grande quantidade de operadores, como visto na 
seção III, funções padronizadas (e que acompanham os compiladores na forma de bibliotecas 
padrão do ANSI C) e de operadores de classes (que acompanham os compiladores na forma de 
uma biblioteca de classes padrão ANSI C++). 
Pode-se dizer que existem, essencialmente, onze instruções (comandos) básicos, 
relacionados na tabela IV.1. 
Tabela IV.1 : Comandos básicos das linguagens C e C++ 
Instrução Descrição 
expressões expressões em geral 
{ } bloco ou instrução composta 
break controla a interrupção de execução de um bloco 
continue interrompe a iteração atual de um laço 
do ........while laço com teste no final do bloco 
for laço iterativo 
goto desvio incondicional 
if - else processamento condicional 
return retorno explícito de uma função 
switch bloco de processamento condicional 
while laço com teste no início do bloco 
 
Nas subseções a seguir alguns desses comandos serão detalhados, mas não na ordem 
apresentada na tabela. 
IV.A.1. Bloco ou Instrução composta 
Consulte a seção II.B para uma descrição de blocos. 
IV.A.2. Instrução break 
A instrução break interrompe a execução de um bloco de controle. Esse bloco pode ser 
tanto um laço (seção IV.A.4.c) como um bloco de processamento condicional (switch – seção 
IV.A.3.b). Exemplos de seu uso são apresentados nessas duas seções. 
IV.A.3. Instruções de processamento condicional 
São instruções que permitem controlar o caminho de processamento em função de 
condições que são avaliadas durante o processamento (“run-time” ou tempo de execução). 
Existem duas instruções condicionais, apresentadas nas próximas subseções. 
As instruções condicionais podem ser aninhadas, ou seja, pode-se definir uma instrução 
condicional dentro de outra. 
APOSTILA: LINGUAGENS DE PROGRAMAÇÃO C E C++ 
Angelo Passaro Página IV.2 Segunda revisão / 2002 
 
IV.A.3.a. INSTRUÇÕES if E else IV.A.3.a 
A instrução if testa uma condição especificada e, no caso desta condição ser verdadeira 
(true), um bloco de instruções que segue a instrução if é executado. Se a condição especificada 
for avaliada como sendo falsa (false), então o bloco de instruções que segue a instrução else é 
executado. A instrução else não é obrigatória. 
 
Sintaxe : 
if (condição) 
{ // início do bloco do if 
// se a condição for avaliada como true (ou seja, uma expressão que resulta um 
// valor diferente de zero), o conjunto de instruções definidas no 
// interior do bloco que segue o if é executado 
} // fim do bloco do if 
else 
{ // início do bloco else 
// se a condição do if for avaliada como false (ou seja, uma expressão que 
// resulta um valor igual a zero), o conjunto de instruções definidas no 
// interior do bloco que segue o else é executado. 
// O else não é obrigatório. Se este não existir, o processamento continua a partir 
// da primeira instrução após as instruções do bloco if. 
} // fim do bloco else 
 
Observação: 
Se apenas uma instrução segue o bloco if (ou o bloco else), esta não precisa ser 
definida no interior de um bloco. No entanto, o bloco é imprescindível se mais de 
uma instrução deve ser executada em seqüência. 
 
Exemplo: 
int i; 
.......... // indica várias instruções 
if ( i < 2 ) cout << “\n i é menor que 2 \n”; 
else cout << “\n i é maior ou igual a 2 \n”; 
 
Se a expressão relacional ( i < 2 ) resulta true, então a instrução : 
cout << “\n i é menor que 2 \n” 
é executada, caso contrário a instrução que segue o else : 
cout << “\n i é maior ou igual a 2 \n” 
 é executada. Note-se que os blocos de instrução que seguem tanto o if como o else contêm 
somente uma instrução. Neste caso, os símbolos utilizados para delimitar blocos ({ }) não são 
necessários. No entanto, o programador não incorre em erro ao utilizá-los, como mostrado a 
seguir: 
int i; 
APOSTILA: LINGUAGENS DE PROGRAMAÇÃO C E C++ 
Angelo Passaro Página IV.3 Segunda revisão / 2002 
 
.......... // indica várias instruções 
if ( i < 2 ) 
{ 
cout << “\n i é menor que 2 \n”; 
} 
else 
{ 
cout << “\n i é maior ou igual a 2 \n”; 
} 
 
Exemplo: 
 
unsigned char mascara_controle = 0; // define um identificador para uma 
 // variável do tipo unsigned char 
 
mascara_controle = LeDadosControle(); // na função LeDadosControle são 
 // executadas instruções que podem 
 // resultar em diferentes valores para 
 // mascara_controle (por exemplo, pode 
 //estar sendo feita uma leitura 
 // de um instrumento numa instalação 
 // industrial. 
 
// o processamento a seguir depende do valor de mascara_controle 
if (!mascara_controle || mascara_controle > 3) // se mascara_controle é zero ou maior do 
 // que esta condição é avaliada como true. 
 LuzesVerdes(); // somente esta instrução é executada se a 
 // condição é true, portanto não foi 
 // definido um bloco com os símbolos { e } 
else 
{ 
 if (mascara_controle == 1) 
 { 
 AcionaAlarmeSonoro(); // executa função sem passar parâmetro 
 AcionaAlarmePainel(mascara_controle); // executa função passando a 
 // variável mascara_controle por valor. 
} // fim do bloco if (mascara_controle == 1) 
else 
{ 
if (mascara_controle == 2) 
{ 
 AcionaAlarmeSonoro(); 
 TravaPortasSeguranca(); 
} // fim do bloco if (mascara_controle == 2) 
else 
{ 
if (mascara_controle == 3) 
APOSTILA: LINGUAGENS DE PROGRAMAÇÃO C E C++ 
Angelo Passaro Página IV.4 Segunda revisão / 2002 
 
{ 
 AcionaAlarmeSonoro(); 
 TravaPortasSeguranca(); 
DesligamentoGeral(); 
} // fim do bloco if (mascara_controle == 3) 
 } // fim do bloco else de if (mascara_controle == 2) 
 } // fim do bloco else de if (mascara_controle == 1) 
} // fim do primeiro bloco else de if (!mascara_controle || mascara_controle > 3) 
 
Note que os blocos else apresentam, a rigor, uma única instrução (o if seguido de seu 
bloco de instruções).Nestas condições pode-se escrever o programa de uma forma muito mais 
simples de ler. No próximo exemplo é apresentado o mesmo trecho de código do exemplo 
anterior, escrito de forma mais legível. 
 
Exemplo: 
unsigned char mascara_controle = 0; // define um identificador para uma variável 
 // do tipo unsigned char 
 
mascara_controle = LeDadosControle(); 
 
// o processamento a seguir depende do valor de mascara_controle 
if (!mascara_controle || mascara_controle > 3) LuzesVerdes(); 
else if (mascara_controle == 1) 
{ 
 AcionaAlarmeSonoro(); // executa função sem passar parâmetro 
AcionaAlarmePainel(mascara_controle); // executa função passando a 
 // variável mascara_controle por valor. 
} // fim do bloco if (mascara_controle == 1) 
else if (mascara_controle == 2) 
{ 
AcionaAlarmeSonoro(); 
TravaPortasSeguranca(); 
} // fim do bloco if (mascara_controle == 2) 
else if (mascara_controle == 3) 
{ 
 AcionaAlarmeSonoro(); 
TravaPortasSeguranca(); 
DesligamentoGeral(); 
} // fim do bloco if (mascara_controle == 3) 
 
Desta forma, else if não corresponde a um novo comando, mas sim uma forma 
compacta de escrever o blocos else aplicando a regra de que não é necessário definir um bloco 
para uma única instrução. Estude esse exemplo atentamente. 
IV.A.3.b. INSTRUÇÃO switch (bloco de processamento condicional) IV.A.3.b 
APOSTILA: LINGUAGENS DE PROGRAMAÇÃO C E C++ 
Angelo Passaro Página IV.5 Segunda revisão / 2002 
 
A instrução switch testa a expressão de controle buscando uma igualdade. Os valores 
de teste da instrução switch são indicados em cláusulas case. Se o valor expresso em uma 
cláusula case é igual ao resultado da expressão de controle, a seqüência de instruções que 
segue o case é executada. O processamento termina quando uma instrução break é localizada 
ou no final do bloco do switch. 
A cláusula opcional default pode ser utilizada para especificar o processamento a ser 
realizado se nenhuma das cláusulas precedentes for satisfeita. 
 
Sintaxe : 
switch (expressao de controle) 
{ // aqui inicia o bloco do switch 
case valor1 : // se o resultado da expressão de controle for igual ao valor1 o 
 // conjunto de instruções que segue o case é executado. 
 // note os dois pontos no final da cláusula 
..... // conjunto de instruções que serão executadas se a expressão de controle for igual a valor1 
break; // esta instrução interrompe o processamento, desviando o 
 // fluxo de controle de execução para a primeira instrução após 
 // o bloco do switch. 
 // Se esta instrução não for incluída, o processamento segue 
 // executando as instruções da segunda cláusula, até encontrar 
 // uma instrução break. 
case valor2 : // esta é a segunda cláusula. O bloco de instruções que segue 
 // esta cláusula é executado se a expressão de controle resultou 
 // igual a valor2. (Novamente, observe o dois pontos 
 // obrigatório no final da cláusula) 
....... // aqui estão as instruções que seguem a segunda cláusula 
break; 
case valor3 : 
........... 
break; 
default : // esta é uma cláusula opcional. As instruções que seguem esta 
 // cláusula são executadas se o resultado da expressão de 
 // controle não coincide com os valores das cláusulas anteriores 
 // ou se deixou de existir uma instrução break no final da 
 //cláusula anterior. 
....... // aqui estão as instruções que seguem a cláusula default 
} // fim do bloco do switch 
 
Vamos repetir o exemplo da seção IV.A.3.a, utilizando, agora, a instrução switch. 
 
Exemplo: 
 
unsigned char mascara_controle = 0; // define um identificador para uma 
 // variável do tipo unsigned char 
APOSTILA: LINGUAGENS DE PROGRAMAÇÃO C E C++ 
Angelo Passaro Página IV.6 Segunda revisão / 2002 
 
 
mascara_controle = LeDadosControle(); // na função chamada neste ponto são 
 // executadas instruções que podem 
 // resultar em diferentes valores para 
 // mascara_controle (por exemplo, pode 
 // estar sendo feita uma leitura de um 
 // instrumento numa instalação industrial. 
 // o processamento a seguir depende do 
 // valor de mascara_controle 
switch (mascara_controle) 
{ 
case 1: 
 AcionaAlarmeSonoro(); // executa função sem passar parâmetro 
 AcionaAlarmePainel(mascara_controle); // executa função passando a variável 
 // mascara_controle por valor. 
break; // interrompe a execução do bloco do 
 // switch, saltando a execução para a 
 // primeira instrução após o bloco. 
case 2: 
 AcionaAlarmeSonoro(); 
 TravaPortasSeguranca(); 
case 3: // o conjunto de instruções a seguir é 
 //executado se mascara_controle é igual a 
 // 3 ou na sequencia das instruções do case 
 // 2, uma vez que não foi incluida a 
 // instrução break após a execução de 
 // TravaPortasSeguranca().DesligamentoGeral(); 
break; 
default : // se mascara_controle é diferente de 1, 2 e 3 
 LuzesVerdes(); 
} // fim do bloco do switch 
 
Observação: 
A seqüência de instruções do exemplo acima parece complicada. No entanto, com a 
eliminação dos comentários o código resulta: 
 
unsigned char mascara_controle = 0; 
 
mascara_controle = LeDadosControle(); 
switch (mascara_controle) 
{ 
case 1: 
 AcionaAlarmeSonoro(); 
 AcionaAlarmePainel(mascara_controle); 
break; 
case 2: 
 AcionaAlarmeSonoro(); 
APOSTILA: LINGUAGENS DE PROGRAMAÇÃO C E C++ 
Angelo Passaro Página IV.7 Segunda revisão / 2002 
 
 TravaPortasSeguranca(); 
case 3: 
 DesligamentoGeral(); 
break; 
default : 
 LuzesVerdes(); 
} // fim do bloco switch 
 
IV.A.4. Instruções de repetição 
São instruções que permitem executar um bloco de instruções repetidas vezes. As 
instruções são repetidas enquanto uma expressão fornecida for avaliada como true (qualquer 
valor diferente de zero). 
Existem três instruções de laço em C e C++ conforme mostrado na tabela IV.1: 
• do .....while, 
• while, e 
• for 
as quais serão apresentados nas subseção a seguir. As instruções de laço podem ser aninhadas, 
ou seja, pode-se definir um laço dentro de outro laço. 
IV.A.4.a. INSTRUÇÃO DE REPETIÇÃO do ... while 
A instrução do inicia um laço cuja execução é testada no final do laço, após sua 
primeira execução. A cláusula while especifica a condição para execução do laço. O 
processamento do laço continua enquanto a expressão especificada é avaliada como true. 
 
Sintaxe: 
do 
{ 
..... // conjunto de instruções que devem ser repetidas enquanto a expressão é avaliada true 
} while (expressão) ; // fim do laço do –while. Observe o uso do caracter de 
 // terminação de instrução “;” 
 
 
Exemplo: 
#include <iostream.h> 
void main(void) 
{ 
short int i, valor; 
long int fatorial = 1; 
cout << “\n entre com o valor para calculo do fatorial: “; 
cin >> valor; 
i = valor; 
if (i >= 0) 
{ 
APOSTILA: LINGUAGENS DE PROGRAMAÇÃO C E C++ 
Angelo Passaro Página IV.8 Segunda revisão / 2002 
 
do 
{ 
fatorial *= i; // observe o uso do operador de atribuição composto *= 
i--; 
} while ( i ); // fim do bloco 
cout << “\n \a O fatorial de “<< valor << “ e : “ << fatorial << “\n”; 
} // fim do bloco if (i>=0) 
else // não calcula o fatorial para valores negativos 
cout << “\n \a Valor negativo! Fatorial não calculado\n”; 
 
} // fim do bloco de definição da função main 
 
Exercício: 
Verifique se o exemplo acima contempla o caso de fatorial de 0 (fatorial de zero 
resulta 1). Se a resposta é negativa, modifique o programa de modo a contemplar esta 
situação. Além disso escreva o programa de forma um pouco mais compacta, utilizando 
seu conhecimento do modo de operação do operador unário --. Finalmente, por que foi 
utilizada a variável valor? 
IV.A.4.b. INSTRUÇÃO DE REPETIÇÃO while 
A instrução while inicia um laço cuja execução é testada antes de sua primeira 
execução. O processamento do laço continua enquanto a expressão especificada é avaliada 
como true. 
 
Sintaxe: 
while (expressão) 
{ 
..... // conjunto de instruções que devem ser repetidas enquanto a expressão é avaliada true 
} // fim do laço while 
 
 
Exemplo: 
#include <iostream.h> 
void main(void) 
{ 
short int i, 
 valor; 
long int fatorial = 1; 
cout << “\n entre com o valor para calculo do fatorial: “; 
cin >> valor; 
i = valor; 
while ( i ) 
{ 
fatorial *= i; // observe o uso do operador de atribuição composto *= 
i--; 
APOSTILA: LINGUAGENS DE PROGRAMAÇÃO C E C++ 
Angelo Passaro Página IV.9 Segunda revisão / 2002 
 
} // fim do bloco 
cout << “\n \a O fatorial de “<< valor << “ e : “ << fatorial << “\n”; 
} // fim do bloco de definição da função main 
 
Exercício: 
Verifique se o exemplo acima contempla o caso de fatorial de 0 (zero). 
Modifique o programa para que o usuário possa calcular o fatorial de vários números, 
interativamente, e possa encerrar o programa com o acionamento da tecla f (maiúscula 
ou minúscula). 
IV.A.4.c. INSTRUÇÃO DE REPETIÇÃO for IV.A.4.c 
A instrução for inicia um laço iterativo. As condições iniciais para o laço, a expressão 
utilizada para avaliar se a execução do laço é autorizada e o processamento a ser executado no 
laço podem ser especificados na instrução for. 
O processamento do laço continua enquanto a expressão especificada é avaliada como 
true. 
Um laço for sem quaisquer operandos é um caso especial, o qual inicia um laço sem 
fim. 
 
 
Sintaxe: 
for (inicialização; condição; instruções iterativas) 
{ 
..... instruções do bloco // conjunto de instruções que devem ser repetidas 
 // enquanto a condição é avaliada true 
} // fim do laço for 
onde: 
inicialização : especifica um conjunto de instruções, separadas pelo caracter vírgula, 
avaliadas antes do laço for ser iniciado. Instruções de inicialização 
podem ser omitidas. 
condição : uma expressão que, se avaliada true (valor diferente de zero), autoriza a 
execução do laço. A cláusula de condição pode ser omitida, mas não o 
caracter ; . Se a cláusula é omitida a condição é avaliada como true. 
instruções iterativas : especifica instruções que devem ser executadas ao término de 
cada ciclo do laço. De mesma forma que nas instruções de inicialização, 
várias instruções iterativas podem ser especificadas, separadas pelo 
caracter ,. Instruções iterativas podem ser omitidas. 
instruções do bloco : especifica as instruções que são processadas repetidamente. Uma 
instrução nula (representada por um ponto e virgula ;) pode ser utilizada 
se nenhum processamento é necessário. 
 
 
Exemplos: 
 
Note o caracter ; separando os três componentes 
da instrução for 
APOSTILA: LINGUAGENS DE PROGRAMAÇÃO C E C++ 
Angelo Passaro Página IV.10 Segunda revisão / 2002 
 
// neste exemplo, as variáveis i e j são inicializada na instrução for; 
// a condição para execução do laço é que i seja menor ou igual a 8 e , 
// na cláusula de instruções iterativas a variável i é incrementada 
// O laço permite a soma dos primeiros oito números naturais 
for ( i = 1, j = 0; i <= 8; i++) 
{ 
 j += i; // observe o uso do operador de atribuição composto += 
 cout << i << ‘\n’; 
} 
cout << j<<’\n’; 
 
// este exemplo também permite a soma dos primeiros oito números naturais, mas 
// não é utilizado um bloco de instruções. A instrução for é terminada com uma instrução nula 
// ou seja o laço é terminado por um ;. Compare com o exemplo anterior. 
for ( i = 1, j = 0; i <= 8; i++, j += i); 
cout << j<<’\n’; 
 
// no exemplo é apresentado um laço sem fim 
// note-se que as cláusulas de instruções de inicialização, a de condição, e a de iteração não são 
// especificadas, mas os ponto e vírgula continuam sendo apresentados, separando as cláusulas 
// vazias. 
for ( ; ; ); 
 
// Um exemplo que utiliza a instrução break para interromper um laço for 
int i, j; 
for (i =1; i < 10; i++) 
{ 
 if ( i % 2 == 0 ) break; // interrompe o laço externo no qual i é testado 
 // outra forma de escrever esta instrução é:// if ( !( i % 2 )) break; 
// este é um bloco aninhado com apenas uma instrução 
 for ( j = 1 ; j < 3 ; j++) cout << i << “ “ << j << ‘\n’; 
 
} // fim do laço for (i) 
 
// No exemplo a seguir é calculado o fatorial de um número 
 
#include <iostream.h> 
void main(void) 
{ 
short int i, 
 valor; 
long int fatorial = 1; 
cout << “\n entre com o valor para calculo do fatorial: “; 
cin >> valor; 
for(i = valor; i ; i-- ) fatorial *= i; // há apenas uma instrução no bloco. Os caracteres 
 //de delimitação de bloco { e } podem ser omitidos. 
APOSTILA: LINGUAGENS DE PROGRAMAÇÃO C E C++ 
Angelo Passaro Página IV.11 Segunda revisão / 2002 
 
cout << “\n \a O fatorial de “<< valor << “ e : “ << fatorial << “\n”; 
} // fim do bloco de definição da função main 
 
// Novamente, o cálculo do fatorial de um número utilizando uma instrução for seguida por uma 
// instrução nula 
 
#include <iostream.h> 
void main(void) 
{ 
short int i, 
 valor; 
long int fatorial = 1; 
cout << “\n entre com o valor para calculo do fatorial: “; 
cin >> valor; 
for(i = valor; i ; fatorial *= i, i-- ); // laço terminado com instrução nula. Todo o 
 // processamento é efetuado na cláusula de 
 // instruções iterativas. 
cout << “\n \a O fatorial de “<< valor << “ e : “ << fatorial << “\n”; 
} // fim do bloco de definição da função main 
 
 
Exercício: 
Verifique se o exemplo acima contempla o caso de fatorial de 0 (zero). 
Modifique o programa para que o usuário possa calcular novos fatoriais, 
interativamente, e possa encerrar o programa com o acionamento da tecla f (maiúscula 
ou minúscula). Use um laço for para incluir essa funcionalidade ao programa. 
IV.A.5. Outras instruções 
IV.A.5.a. INSTRUÇÃO continue 
Sintaxe: 
continue; 
 
A instrução continue interrompe a iteração corrente de um laço. Contudo, ao contrário 
do que ocorre com a instrução break, o laço continua sendo executado, iniciando uma nova 
iteração. 
 
Exemplo: 
 
Imprime a seqüência dos quadrados impares dos números de 1 a 10.. 
 
int i; 
int quadrado; 
for (i = 1; i <= 10; i++) 
APOSTILA: LINGUAGENS DE PROGRAMAÇÃO C E C++ 
Angelo Passaro Página IV.12 Segunda revisão / 2002 
 
{ 
 quadrado = i * i; 
 if ( !(quadrado % 2)) continue; 
 cout << “o quadrado de “<< i << “ é : “<< quadrado << ‘\n’; 
} // fim do laço for (i) 
 
Exercícios: 
Explique se o parênteses envolvendo a expressão (quadrado % 2) é necessário. 
Escreva um programa equivalente sem usar a instrução continue. 
IV.A.5.b. INSTRUÇÃO goto 
Esta instrução causa o desvio de execução para uma instrução com o rótulo (label) 
especificado. 
 
Sintaxe: 
goto rotulo; 
 
Exemplo: 
 
int i; 
for (i = 1; i <= 10; i++) 
{ 
 if ( (i == 8) goto a1; // desvia o processamento para a 
 // instrução que apresenta o 
 // rótulo a1 
 cout << “o quadrado de “<< i << “ é : “<< (i * i) << ‘\n’; 
} // fim do laço for (i) 
return 0; 
a1: return 8; // a instrução return 8 apresenta o rotulo a1 
 
Observação : 
As regras modernas de programação estruturada (engenharia de software) 
desestimulam o uso de desvios incondicionais, no caso do C e C++ implementado 
por meio da instrução goto. De fato, seu uso impõe dificuldades principalmente na 
fase de manutenção de software (entenda-se aqui manutenção como correção de 
erros e modificações do programa impostas por mudanças de requisitos de 
software). 
 
IV.A.5.c. INSTRUÇÃO return 
Esta instrução causa o retorno explícito de uma função. Se a função retorna um valor 
(ver a declaração de função na seção II.D) este valor é apresentado no comando return. O valor 
APOSTILA: LINGUAGENS DE PROGRAMAÇÃO C E C++ 
Angelo Passaro Página IV.13 Segunda revisão / 2002 
 
de retorno sofre a ação de um operador cast (seção III.D.3) para o tipo especificado na 
declaração da função. 
 
Sintaxe : 
return valor_retorno; 
 
 
O final de uma função causa a execução de um return implícito.