// escape. 

 cout << ""Frase entre aspas" "; 

 cout << "Alguma duvida? "; 

 return 0; 

} // Fim de main() 

Saída gerada por este programa: 

"Frase entre aspas" 

Alguma duvida? 

Exercício

Escreva um programa que exiba na tela as letras do alfabeto maiúsculo, separadas por tabulações. 

VARIÁVEIS

 Podemos pensar na memória do computador como sendo uma coleção enorme de pequenas gavetas. Cada uma 

dessas gavetinhas é numerada seqüencialmente e representa um byte. 

Esse número seqüencial é conhecido como endereço de memória. Uma variável reserva uma ou mais gavetinhas 

para armazenar um determinado valor. 

O nome da variável é um rótulo que se refere a uma das gavetinhas. Isso facilita a localização e o uso dos 

endereços de memória. Uma variável pode começar em um determinado endereço e estender-se por várias 

gavetinhas, ou vários bytes, subseqüentes. 

Quando definimos uma variável em C++, precisamos informar ao compilador o tipo da variável: um número 

inteiro, um número de ponto flutuante, um caractere, e assim por diante. Essa informação diz ao compilador 

quanto espaço deve ser reservado para a variável, e o tipo de valor que será armazenado nela. 

Dissemos que cada gavetinha corresponde a um byte. Se a variável for de um tipo que ocupa dois bytes, 

precisaremos de dois bytes de memória, ou duas gavetinhas. Portanto, é o tipo da variável (por exemplo, int) que 

informa ao compilador quanta memória deve ser reservada para ela. 

Em um determinado tipo de computador/sistema operacional, cada tipo de variável ocupa um número de bytes 

definido e invariável. Ou seja, uma variável int pode ocupar dois bytes em um tipo de máquina (por exemplo, no 

MS-DOS), quatro bytes em outro tipo de máquina (por exemplo, no Windows 95), e assim por diante. 

C++ oferece um operador, chamado sizeof, que nos permite determinar o tamanho em bytes de um tipo de dados 

ou de uma variável. 

Exemplo

// TamVar.cpp 

// Ilustra o tamanho 

// das variáveis. 

#include  

int main() 

{ 

 cout << "*** Tamanhos das variaveis *** "; 

 cout << "Tamanho de int = " 

 << sizeof(int) 

<< " bytes. "; 

 cout << "Tamanho de short int = " 

 << sizeof(short) 

 << " bytes. "; 

 cout << "Tamanho de bool = " 

 << sizeof(bool) 

 << " bytes. "; 

 cout << "Tamanho de char = " 

 << sizeof(char) 

 << " bytes. "; 

 return 0; 

} // Fim de main() 

Saída gerada por este programa: 

*** Tamanhos das variaveis *** 

Tamanho de int = 4 bytes. 

Tamanho de short int = 2 bytes. 

Tamanho de bool = 1 bytes. 

Tamanho de char = 1 bytes. 

Exercício

Modifique o programa TamVar.cpp, de maneira que ele exiba na tela o tamanho em bytes das seguintes 

variáveis: long, float e double. 

ATRIBUINDO VALORES ÀS VARIÁVEIS

Para criar uma variável, precisamos declarar o seu tipo, seguido pelo nome da variável e por um caractere de 

ponto e vírgula ; 

int larg; 

Para atribuir um valor a uma variável, usamos o operador de atribuição = 

larg = 7; 

Opcionalmente, podemos combinar esses dois passos, declarando e inicializando a variável em uma só linha: 

int larg = 7; 

Mais tarde, quando tratarmos das constantes, veremos que alguns valores devem obrigatoriamente ser 

inicializados no momento da declaração, porque não podemos atribuir-lhes valores posteriormente. 

Podemos também definir mais de uma variável em uma só linha. Podemos ainda misturar declarações simples 

com inicializações. 

// Declara duas variáveis, 

// inicializa uma. 

int larg = 7, compr; 

Exemplo

// AtriVal.cpp 

// Ilustra a atribuição 

// de valores a variáveis. 

#include  

int main() 

{ 

 // Declara duas variáveis, 

 // inicializa uma. 

 int larg = 7, compr; 

 // Atribui valor. 

 compr = 8; 

 // Declara e inicializa 

 // mais uma variável. 

 int area = larg * compr; 

 // Exibe valores. 

 cout << "*** Valores finais *** "; 

 cout << "Largura = " 

 << larg << " "; 

 cout << "Comprimento = " 

 << compr << " "; 

 cout << "Area = " 

 << area << " "; 

 return 0; 

} // Fim de main() 

Saída gerada por este programa: 

*** Valores finais *** 

Largura = 7 

Comprimento = 8 

Area = 56 

Exercício

Modifique o exemplo AtriVal.cpp, de maneira que ele calcule o volume de uma caixa retangular. Para isso, 

acrescente uma variável para representar a profundidade. 

VARIÁVEIS UNSIGNED

Em C++, os tipos inteiros existem em duas variedades: signed (com sinal) e unsigned (sem sinal). A idéia é que, 

às vezes é necessário poder trabalhar com valores negativos e positivos; outras vezes, os valores são somente 

positivos. Os tipos inteiros (short, int e long), quando não são precedidos pela palavra unsigned sempre podem 

assumir valores negativos ou positivos. Os valores unsigned são sempre positivos ou iguais a zero. 

Como o mesmo número de bytes é utilizado para os inteiros signed e unsigned, o maior número que pode ser 

armazenado em um inteiro unsigned é o dobro do maior número positivo que pode ser armazenado em um 

inteiro signed. 

A tabela abaixo ilustra os valores de uma implementação típica de C++: 

Tipo Tamanho (em bytes) Valores 

unsigned short int 2 0 a 65.535 

short int 2 -32.768 a 32.767 

unsigned long int 4 0 a 4.294.967.295 

long int 4 -2.147.483.648 a 2.147.483.647 

int (16 bits) 2 -32.768 a 32.767 

int (32 bits) 4 -2.147.483.648 a 2.147.483.647 

unsigned int (16 bits) 2 0 a 65.535 

unsigned int (32 bits) 4 0 a 4.294.967.295 

char 1 256 valores de caracteres 

float 4 1,2e-38 a 3,4e38 

double 8 2,2e-308 a 1,8e308 

Exemplo

// TamUns.cpp 

// Ilustra o tamanho 

// das variáveis unsigned. 

#include  

int main() 

{ 

 cout << "*** Tamanhos das variaveis *** "; 

 cout << "Tamanho de unsigned int = " 

 << sizeof(unsigned int) 

 << " bytes. "; 

 cout << "Tamanho de unsigned short int = " 

 << sizeof(unsigned short) 

 << " bytes. "; 

 cout << "Tamanho de unsigned char = " 

 << sizeof(unsigned char) 

 << " bytes. "; 

 return 0; 

} // Fim de main() 

Saída gerada por este programa: 

*** Tamanhos das variaveis *** 

Tamanho de unsigned int = 4 bytes. 

Tamanho de unsigned short int = 2 bytes. 

Tamanho de unsigned char = 1 bytes. 

Exercício

Modifique o programa TamUns.cpp, de maneira que ele exiba o tamanho de uma variável unsigned long. 

ESTOURANDO UMA VARIÁVEL UNSIGNED

O que acontece quando tentamos armazenar em uma variável um valor fora da faixa de valores que essa variável 

pode conter? Isso depende da variável ser signed ou unsigned. 

Quando uma variável unsigned int chega a seu valor máximo, ela volta para zero, de forma similar ao que 

acontece com o marcador de quilometragem de um automóvel quando todos os dígitos indicam 9. 

Exemplo

// EstShrt.cpp 

// Ilustra "estouro" 

// de uma variável 

// unsigned short. 

#include  

int main() 

{ 

 unsigned short int usVar; 

 usVar = 65535; 

 cout << "Valor inicial = " 

 << usVar << " "; 

 // Soma 1. 

 usVar = usVar + 1; 

 cout << "Somando 1 = " 

 << usVar << " "; 

 // Soma mais 1. 

 usVar = usVar + 1; 

 cout << "Somando mais 1 = " 

 << usVar << " "; 

 return 0; 

} // Fim de main() 

Saída gerada por este programa: 

Valor inicial = 65535 

Somando 1 = 0 

Somando mais 1 = 1 

Exercício

Modifique o exemplo EstShrt.cpp de maneira que o valor estourado seja do tipo unsigned int. 

ESTOURANDO UM AVRIÁVEL SIGNED

Uma variável signed é diferente de uma variável unsigned, porque metade de seus valores são reservados para 

representar valores negativos. Assim, quando chegamos ao maior valor positivo, o "marcador de quilometragem" 

da variável signed não pula para zero, e sim para o maior valor negativo. 

Exemplo

// EstSShrt.cpp 

// Ilustra "estouro" 

// de uma variável 

// signed short. 

#include  

int main() 

{ 

 short int sVar; 

 sVar = 32767; 

 cout << "Valor inicial = " 

 << sVar << " "; 

 // Soma 1. 

 sVar = sVar + 1; 

 cout << "Somando 1 = " 

 << sVar << " "; 

 // Soma mais 1. 

 sVar = sVar + 1; 

 cout << "Somando mais 1 = " 

 << sVar << " "; 

 return 0; 

} // Fim de main() 

Saída gerada por este programa: 

Valor inicial = 32767 

Somando 1 = -32768 

Somando mais 1 = -32767 

Exercício

Reescreva o exemplo EstSShrt.cpp, de maneira que a variável estourada seja do tipo signed int. 

O TIPO STRING

Uma das atividades mais comuns em qualquer tipo de programa é a manipulação de strings de texto. Uma string 

de texto pode ser uma palavra, uma frase ou um texto mais longo, como uma série de frases. 

Por isso, a biblioteca padrão C++ oferece um tipo, chamado string, que permite realizar diversas operações úteis 

com strings de texto. 

O exemplo abaixo é uma reescrita do programa elementar AloMundo.cpp, usando o tipo string. 

Exemplo

// AloStr.cpp 

// Ilustra o uso 

// do tipo string. 

#include  

int main() 

{ 

 // Declara e inicializa 

 // uma variável do 

 // tipo string. 

 string aloTar = "Alo, Tarcisio!"; 

 // Exibe a string. 

 cout << aloTar; 

} // Fim de main() 

Saída gerada por este programa: 

Alo, Tarcisio! 

Exercício

Modifique o programa AloStr.cpp, de maneira que a saída mostrada na tela deixe uma linha vazia antes e outra 

linha vazia depois da frase Alo, Tarcisio!. 

CONCATENANDO STRINGS

O tipo string permite o uso do operador + para concatenar (somar) strings. O exemplo abaixo mostra como isso é 

feito. 

Exemplo

// SomaStr.cpp 

// Ilustra o uso 

// do operador + 

// com o tipo string. 

#include  

int main() 

{ 

 // Declara e inicializa 

 // algumas variáveis do 

 // tipo string. 

 string s1 = "Agua mole "; 

 string s2 = "em pedra dura "; 

 string s3 = "tanto bate "; 

 string s4 = "ate que fura"; 

 // Exibe usando 

 // o operador + 

 cout << s1 + s2 + 

 s3 + s4 + "!!! "; 

 // Acrescenta exclamações 

 // e salta duas linhas 

 // no final. 

} // Fim de main() 

Saída gerada por este programa: 

Agua mole em pedra dura tanto bate ate que fura!!! 

Exercício

C++ permite o uso de operadores combinados, como +=, *=, -= e =, para simplificar a escrita de operações 

como: 

a = a + b; 

// Pode ser escrito como: 

a += b; 

Escreva um programa que utilize o operador += com strings. Faça com que o resultado exibido na tela evidencie 

esse uso. 

FUNÇÕES

As funções representam um dos blocos construtivos da linguagem C++. Outro bloco construtivo básico de C++ 

são as classes de objetos, que veremos no futuro. 

Todo programa C++ tem obrigatoriamente pelo menos uma função, chamada main(). Todo comando executável 

em C++ aparece dentro de alguma função. Dito de forma simples, uma função é um grupo de comandos que 

executa uma tarefa específica, e muitas vezes retorna (envia) um valor para o comando que a chamou. 

As funções em C++ são o equivalente às procedures e functions do Pascal, ou aos procedimentos SUB e 

FUNCTION do Basic. São as funções que possibilitam a escrita de programas bem organizados. 

Em um programa bem escrito, cada função desempenha uma tarefa bem definida. 

O exemplo abaixo, AloFunc.cpp contém duas funções: main() e digaAlo(). A seção principal de execução de 

todo programa C++ é representada pela função main(), que marca onde começa e onde termina a execução. Ou 

seja, todo programa C++ tem uma e somente uma função main(). 

A execução de AloFunc.cpp (e de qualquer outro programa C++) começa no começo da função main() e termina 

quando a função main() é encerrada. 

Exemplo

// AloFunc.cpp 

// Ilustra uma 

// função elementar. 

#include  

// Definição da função 

// digaAlo() 

void digaAlo() 

{ 

 cout << " Alo, Mundo!"; 

} // Fim de digaAlo() 

int main() 

{ 

 // Chama a função C++ BÁSICO 

15

 // digaAlo() 

 digaAlo(); 

 return 0; 

} // Fim de main() 

Saída gerada por este programa: 

Alo, Mundo! 

Exercício

Acrescente ao exemplo AloFunc.cpp uma segunda função, chamada digaTchau(). A função digaTchau() deve 

exibir na tela a mensagem Tchau!. Faça com que a função digaAlo() chame a função digaTchau(), de que 

maneira que o programa produza na tela a seguinte saída: 

Alo, Mundo! 

Tchau! 

CHAMANDO UMA FUNÇÃO

Embora main() seja uma função, ela é diferente das outras. A função main() é sempre chamada para iniciar a 

execução de um programa. As outras funções são chamadas ao longo da execução do programa. 

Começando no início de main(), o programa é executado linha por linha, na ordem em que elas aparecem no 

código. Porém quando a execução chega a uma chamada a função, algo diferente acontece. O programa pula

para o código correspondente àquela função. Terminada a execução da função, o programa é retomado na linha 

que se segue imediatamente à chamada à função. 

É como se você estivesse lendo um livro, e encontrasse uma palavra desconhecida. Você suspenderia a leitura e 

consultaria um dicionário. Após descobrir o significado da nova palavra, você retomaria então a leitura do livro, 

no ponto em que havia parado. 

Exemplo

// ChamFun.cpp 

// Ilustra chamada 

// a uma função. 

#include  

// Definição da função. 

void UmaFuncao() 

{ 

 cout << "...agora, estamos em UmaFuncao()... "; 

} // Fim de UmaFuncao() 

int main() 

{ 

 cout << "Estamos em main()... "; 

 // Chama UmaFuncao(); 

 UmaFuncao(); 

 cout << "...e voltamos a main(). "; 

} // Fim de main() C++ BÁSICO 

16

Saída gerada por este programa: 

Estamos em main()... 

...agora, estamos em UmaFuncao()... 

...e voltamos a main(). 

Exercício

Modifique o programa ChamFun.cpp, definindo uma segunda função, chamada OutraFuncao(). Faça com que a 

primeira função, UmaFuncao(), chame a segunda função, OutraFuncao(). A saída mostrada na tela deve 

evidenciar essas chamadas. 

UMA FUNÇÃO COM PARÂMETROS

A definição de uma função consiste de um cabeçalho e de um corpo. O cabeçalho contém o tipo retornado, o 

nome da função e os parâmetros que ela recebe. Os parâmetros de uma função permitem que passemos valores 

para a função. Assim, se uma função deve somar dois números, esses números seriam os parâmetros da função. 

Eis um exemplo de cabeçalho de função: 

int Soma(int i, int j) 

Um parâmetro é uma declaração de qual o tipo de valor que será passado para a função. O valor passado de fato 

é chamado de argumento. 

O corpo da função consiste de uma chave de abertura {, seguida pelos comandos que executam a tarefa da

função, e finalmente, pelo chave de fechamento }. 

Exemplo

// FunSimp.cpp 

// Ilustra o uso 

// de uma função simples. 

#include  

int Soma(int i, int j) 

{ 

 cout << "Estamos na funcao Soma(). "; 

 cout << "Valores recebidos: "; 

 cout << "i = " 

 << i 

 << ", j = " 

 << j 

 << " "; 

 return (i + j); 

} // Fim de Soma(int, int) 

int main() 

{ 

 cout << "Estamos em main() "; 

 int x, y, z; 

 cout << " Digite o primeiro num. + "; 

 cin >> x; 

 cout << " Digite o segundo num. + "; 

 cin >> y; C++ BÁSICO 

17

 cout << "Chamando funcao Soma()... "; 

 z = Soma(x, y); 

 cout << "Voltamos a main() "; 

 cout << "Novo valor de z = " 

 << z 

 << " "; 

 return 0; 

} // Fim de main() 

Saída gerada por este programa: 

Estamos em main() 

Digite o primeiro num. + 48 

Digite o segundo num. + 94 

Chamando funcao Soma()... 

Estamos na funcao Soma(). 

Valores recebidos: 

i = 48, j = 94 

Voltamos a main() 

Novo valor de z = 142 

Exercício

Modifique o programa FunSimp.cpp, criando uma função chamada Multiplic(), no lugar da função Soma(). A

função Multiplic() deve multiplicar dois números inteiros, e retornar um valor inteiro. Os números a serem 

multiplicados devem ser solicitados do usuário, e o resultado da multiplicação deve ser exibido na tela. 

UMA FUNÇÃO MEMBRO DE STRING

Vimos que a biblioteca padrão de C++ contém o tipo string, usado na manipulação de strings de texto. Na 

verdade, esse tipo é implementado como uma classe de objetos, um conceito fundamental em C++. Embora 

ainda não tenhamos estudado os objetos em C++, podemos usá-los de forma mais ou menos intuitiva, para ter 

uma idéia do poder e da praticidade que representam. 

Por exemplo, os fluxos de entrada e saída cin e cout, que já usamos, são objetos de C++. O tipo string também é 

um objeto. 

Objetos contêm operações que facilitam sua manipulação. Essas operações são similares a funções que ficam 

contidas no objeto, por isso são chamadas de funções membro. Para chamar uma função membro de um objeto, 

usamos o operador ponto . Por exemplo, a linha abaixo chama a função membro substr() de um objeto da classe 

string, para acessar uma substring contida nesta string. C++ BÁSICO 

18

sobreNome = nome.substr(9, 5); 

O exemplo abaixo mostra como isso é feito. 

Exemplo

// MaiStr.cpp 

// Ilustra outras 

// funções de strings. 

#include  

int main() 

{ 

 // Declara e inicializa 

 // uma variável do 

 // tipo string. 

 string nome = "Tarcisio Lopes"; 

 // Exibe. 

 cout << "Meu nome = " 

 << nome 

 << " "; 

 // Declara outra string. 

 string sobreNome; 

 // Acessa substring que 

 // começa na posição 9 

 // e tem comprimento 5. 

 sobreNome = nome.substr(9, 5); 

 // Exibe sobrenome. 

 cout << "Meu sobrenome = " 

 << sobreNome 

 << " "; 

} // Fim de main() 

Saída gerada por este programa: 

Meu nome = Tarcisio Lopes 

Meu sobrenome = Lopes 

Exercício

Reescreva o exemplo MaiStr.cpp, utilizando a função membro substr() para acessar seu próprio nome e 

sobrenome. 

OUTRA FUNÇÃO MEMBRO DE STRING

Dissemos que os objetos têm funções membros que facilitam sua manipulação. 

Outra operação comum com strings é substituir parte de uma string. Como se trata de uma operação com strings, 

nada mais lógico que esta operação esteja contida nos objetos da classe string. Esta operação é feita com uma 

função membro de string chamada replace(). O exemplo abaixo mostra como ela pode ser utilizada. C++ BÁSICO 

19

Exemplo

// ReplStr.cpp 

// Ilustra outras 

// funções de strings. 

#include  

int main() 

{ 

 // Declara e inicializa 

 // uma variável do 

 // tipo string. 

 string nome = "Tarcisio Lopes"; 

 // Exibe. 

 cout << "Meu nome = " 

 << nome 

 << " "; 

 // Utiliza a função membro 

 // replace() para 

 // substituir parte 

 // da string. 

 // A parte substituída 

 // começa em 0 e 

 // tem o comprimento 8 

 nome.replace(0, 8, "Mateus"); 

 // Exibe nova string. 

 cout << "Nome do meu filho = " 

 << nome 

 << " "; 

} // Fim de main() 

Saída gerada por este programa: 

Meu nome = Tarcisio Lopes 

Nome do meu filho = Mateus Lopes 

Exercício

Reescreva o exemplo ReplStr.cpp utilizando seu próprio nome e o nome de alguém de sua família. 

USANDO TYPEDEF

Às vezes, o processo de declaração de variáveis pode se tornar tedioso, repetitivo e sujeito a erros. Isso acontece, 

por exemplo, se usamos muitas variáveis do tipo unsigned short int em um programa. C++ permite criar um 

novo nome para esse tipo, com o uso da palavra-chave typedef. 

Na verdade, com typedef estamos criando um sinônimo para um tipo já existente. Não estamos criando um novo 

tipo. Isso será visto em outro ponto deste curso. 

Eis a forma de uso de typedef: 

typedef unsigned short int USHORT; C++ BÁSICO 

20

A partir daí, podemos usar USHORT, ao invés de unsigned short int. 

Exemplo

// typedef.cpp 

// Ilustra o uso 

// de typedef. 

#include  

// Cria um sinônimo usando typedef. 

typedef unsigned short int USHORT; 

int main() 

{ 

 // Declara duas variáveis, 

 // inicializa uma. 

 USHORT larg = 7, compr; 

 // Atribui valor. 

 compr = 8; 

 // Declara e inicializa 

 // mais uma variável. 

 USHORT area = larg * compr; 

 // Exibe valores. 

 cout << "*** Valores finais *** "; 

 cout << "Largura = " 

 << larg << " "; 

 cout << "Comprimento = " 

 << compr << " "; 

 cout << "Area = " 

 << area << " "; 

 return 0; 

} // Fim de main() 

Saída gerada por este programa: 

*** Valores finais *** 

Largura = 7 

Comprimento = 8 

Area = 56 

Exercício

Modifique o exemplo typedef.cpp, de maneira a criar um sinônimo para o tipo unsigned long. 

CONSTANTES COM #DEFINE

Muitas vezes, é conveniente criar um nome para um valor constante. Este nome é chamado de constante 

simbólica. 

A forma mais tradicional de definir constantes simbólicas é usando a diretiva de preprocessador #define: 

#define PI 3.1416 C++ BÁSICO 

21

Observe que neste caso, PI não é declarado como sendo de nenhum tipo em particular (float, double ou qualquer 

outro). A diretiva #define faz simplesmente uma substituição de texto. Todas as vezes que o preprocessador 

encontra a palavra PI, ele a substitui pelo texto 3.1416. 

Como o preprocessador roda antes do compilador, o compilador nunca chega a encontrar a constante PI; o que 

ele encontra é o valor 3.1416. 

Exemplo

// DefTst.cpp 

// Ilustra o uso 

// de #define. 

#include  

// Para mudar a precisão, 

// basta alterar #define. 

#define PI 3.1416 

//#define PI 3.141593 

int main() 

{ 

 cout << "Area do circulo " 

 << "de raio 5 = " 

 << PI * 5 * 5 

 << " "; 

 return 0; 

} // Fim de main() 

Saída gerada por este programa: 

Area do circulo de raio 5 = 78.54 

Exercício 

A distância percorrida pela luz em um ano, conhecida como ano-luz, pode ser calculada pela seguinte fórmula: 

anoLuz = KM_POR_SEGUNDO * SEGUNDOS_POR_MINUTO * MINUTOS_POR_HORA * 

HORAS_POR_DIA * DIAS_POR_ANO; 

Utilize #define de maneira que a fórmula acima possa ser usada diretamente em um programa C++. Dica: 

velocidade da luz = 300.000 Km/s. 

CONSTANTES COM CONST

Embora a diretiva #define funcione, C++ oferece uma forma melhor de definir constantes simbólicas: usando a 

palavra-chave const. 

const float PI = 3.1416; 

Este exemplo também declara uma constante simbólica chamada PI, mas desta vez o tipo de PI é declarado

como sendo float. Este método tem diversas vantagens. Além de tornar o código mais fácil de ler e manter, ele 

dificulta a introdução de bugs. 

A principal diferença é que esta constante tem um tipo, de modo que o compilador pode checar se a constante está sendo usada de acordo com seu tipo. 

Exemplo

// CstTst.cpp 

// Ilustra o uso 

// de const. 

#include  

// Com const, a constante 

// tem um tipo definido 

// (neste caso, float) 

const float PI = 3.1416; 

//const float PI = 3.141593; 

int main() 

{ 

 cout << "Area do circulo " 

 << "de raio 5 = " 

 << PI * 5 * 5 

 << " "; 

 return 0; 

} // Fim de main() 

Saída gerada por este programa: 

Area do circulo de raio 5 = 78.54 

Exercício

Utilize a palavra-chave const para calcular a distância percorrida pela luz em um ano, conhecida como ano-luz, 

com a seguinte fórmula: 

anoLuz = KM_POR_SEGUNDO * SEGUNDOS_POR_MINUTO * MINUTOS_POR_HORA * 

HORAS_POR_DIA * DIAS_POR_ANO; 

Dica: velocidade da luz = 300.000 Km/s. 

CONSTANTES ENUMERADAS

Vimos que uma constante simbólica é um nome que usamos para representar um valor. Vimos também que em 

C++, podemos definir uma constante simbólica de duas maneiras: 

Usando #define 

#define PI 3.1416 

Usando a palavra chave const 

const float PI = 3.1416; 

Esta segunda forma é a mais recomendada na maioria dos casos. 

Podemos também definir coleções de constantes, chamadas constantes enumeradas, usando a palavra-chave 

enum. As constantes enumeradas permitem criar novos tipos e depois definir variáveis desses tipos. Os valores C++ BÁSICO 

23

assumidos ficam restritos a uma determinada coleção de valores. Por exemplo, podemos declarar uma 

enumeração para representar os dias da semana: 

enum DiasDaSemana 

{ 

Segunda, 

Terca, 

Quarta, 

Quinta, 

Sexta, 

Sabado, 

Domingo 

}; // Fim de enum DiasDaSemana. 

Depois disso, podemos definir variáveis do tipo DiasDaSemana, que somente podem assumir os valores Segunda 

= 0, Terca = 1, Quarta = 2, e assim por diante. 

Assim, cada constante enumerada tem um valor inteiro. Se não especificarmos esse valor, a primeira constante 

assumirá o valor 0, a segunda constante assumirá o valor 1, e assim por diante. Se necessário, podemos atribuir 

um valor determinado a uma dada constante. Se somente uma constante for inicializada, as constantes 

subseqüentes assumirão valores com incremento de 1, a partir daquela que foi inicializada. Por exemplo: 

enum DiasDaSemana 

{ 

Segunda = 100, 

Terca, 

Quarta, 

Quinta, 

Sexta = 200, 

Sabado, 

Domingo 

}; // Fim de enum DiasDaSemana. 

Na declaração acima, as constantes não inicializadas assumirão os seguintes valores: C++ BÁSICO 

24

Terca = 101, Quarta = 102, Quinta = 103 

Sabado = 201, Domingo = 202 

As constantes enumeradas são representadas internamente como sendo do tipo int. 

Exemplo

// Enum.cpp 

// Ilustra o uso 

// de enumerações. 

#include  

int main() 

{ 

 // Define uma enumeração. 

 enum DiasDaSemana 

 { 

 Segunda, 

 Terca, 

 Quarta, 

 Quinta, 

 Sexta, 

 Sabado, 

 Domingo 

 }; // Fim de enum DiasDaSemana. 

 // O mesmo que: 

 // const int Segunda = 0; 

 // const int Terca = 1; 

 // Etc... 

 // const int Domingo = 6; 

 // Declara uma variável do tipo 

 // enum DiasDaSemana. 

 DiasDaSemana dias; 

 // Uma variável int. 

 int i; 

 cout << "Digite um num. (0 a 6) + : "; 

 cin >> i; 

 dias = DiasDaSemana(i); 

 if((dias == Sabado) || (dias == Domingo)) 

 cout << "Voce escolheu o fim de semana. "; 

 else 

 cout << "Voce escolheu um dia util. "; 

return 0; 

} // Fim de main() 

Saída gerada por este programa: 

Digite um num. (0 a 6) + : 

5 

Voce escolheu o fim de semana. C++ BÁSICO 

25

Exercício 

Escreva um programa que declare e utilize uma enumeração chamada Horas, de maneira que a constante 

UmaHora tenha o valor 1, a constante DuasHoras tenha o valor 2, e assim por diante, até que a constante 

DozeHoras tenha o valor 12. 

EXPRESSÕES

Em C++, uma expressão é qualquer comando (statement) que após ser efetuado gera um valor. Outra forma de 

dizer isso é: uma expressão sempre retorna um valor. 

Uma expressão pode ser simples: 

3.14 // Retorna o valor 3.14 

Ou mais complicada: 

x = a + b * c / 10; 

Observe que a expressão acima retorna o valor que está sendo atribuído a x. Por isso, a expressão inteira pode ser 

atribuída a outra variável. Por exemplo: 

y = x = a + b * c / 10; 

Exemplo

// Expres.cpp 

// Ilustra o uso 

// de expressões. 

#include  

int main() 

{ 

 int a = 0, b = 0, c = 0, d = 20; 

 cout << "*** Valores iniciais *** "; 

 cout << "a = " << a 

 << ", b = " << b 

 << ", c = " << c 

 << ", d = " << d 

 << " "; 

 // Atribui novos valores. 

 a = 12; 

 b = 15; 

 // Avalia expressão. 

 c = d = a + b; 

 // Exibe novos valores. 

 cout << "*** Novos valores *** "; 

 cout << "a = " << a 

 << ", b = " << b 

 << ", c = " << c 

 << ", d = " << d 

 << " "; 

 return 0; 

} // Fim de main() 

Saída gerada por este programa: 

*** Valores iniciais *** 

a = 0, b = 0, c = 0, d = 20 

*** Novos valores *** 

a = 12, b = 15, c = 27, d = 27 

Exercício

Modifique o exemplo Expres.cpp de maneira que os novos valores das variáveis a e b sejam solicitados do 

usuário. 

OPERADORES MATEMÁTICOS

Existem cinco operadores matemáticos em C++: 

+ adição 

- subtração 

* multiplicação 

/ divisão 

% módulo 

Os quatro primeiros operadores, funcionam da forma que seria de se esperar, com base na matemática elementar. 

O operador módulo % fornece como resultado o resto de uma divisão inteira. Por exemplo, quando fazemos a 

divisão inteira 31 por 5, o resultado é 6, e o resto é 1. (Lembre-se, inteiros não podem ter parte fracionária.) Para 

achar o resto da divisão inteira, usamos o operador módulo %. Assim, 31 % 5 é igual a 1. 

Exemplo

// Resto.cpp 

// Ilustra o uso 

// do operador 

// módulo. 

#include  

int main() 

{ 

 cout << "*** Resto da divisao inteira *** "; 

 cout << "40 % 4 = " 

 << 40 % 4 

 << " "; 

 cout << "41 % 4 = " 

 << 41 % 4 

 << " "; 

 cout << "42 % 4 = " 

 << 42 % 4 

 << " "; C++ BÁSICO 

27

 cout << "43 % 4 = " 

 << 43 % 4 

 << " "; 

 cout << "44 % 4 = " 

 << 44 % 4 

 << " "; 

 return 0; 

} // Fim de main() 

Saída gerada por este programa: 

*** Resto da divisao inteira *** 

40 % 4 = 0 

41 % 4 = 1 

42 % 4 = 2 

43 % 4 = 3 

44 % 4 = 0 

Exercício

Modifique o programa Resto.cpp, de maneira que sejam exibidos os restos da divisão inteira por 5 de cada um 

dos números entre 40 e 45, inclusive. 

SUBTRAÇÃO COM UNSIGNED

Vimos que uma variável unsigned somente pode assumir valores não-negativos. O que acontece quando 

tentamos armazenar um valor negativo em uma variável unsigned? Isso pode acontecer como resultado de uma 

subtração, conforme ilustrado abaixo. 

Exemplo

// EstDif.cpp 

// Ilustra estouro 

// de uma variável unsigned 

// como resultado de uma 

// operação matemática. 

#include  

int main() 

{ 

 unsigned int diferenca; 

 unsigned int numMaior = 1000; 

 unsigned int numMenor = 300; 

 cout << " numMaior = " 

 << numMaior 

 << ", numMenor = " 

 << numMenor 

 << " "; C++ BÁSICO 

28

 diferenca = numMaior - numMenor; 

 cout << " numMaior - numMenor = " 

 << diferenca 

 << " "; 

 diferenca = numMenor - numMaior; 

 cout << " numMenor - numMaior = " 

 << diferenca 

 << " "; 

 return 0; 

} // Fim de main() 

Saída gerada por este programa: 

numMaior = 1000, numMenor = 300 

numMaior - numMenor = 700 

numMenor - numMaior = 4294966596 

Exercício

Modifique o exemplo EstDif.cpp, de maneira que a operação de subtração não cause o estouro da variável. 

OPERADORES EM PREFIXO E SUFIXO

Dois operadores muito importantes e úteis em C++ são o operador de incremento ++ e o operador de decremento 

-- 

O operador de incremento aumenta em 1 o valor da variável à qual é aplicado; o operador de decremento 

diminui 1. 

A posição dos operadores ++ e -- em relação a variável (prefixo ou sufixo) é muito importante. Na posição de 

prefixo, o operador é aplicado primeiro, depois o valor da variável é acessado. Na posição de sufixo, o valor da 

variável é acessado primeiro, depois o operador é aplicado. 

Exemplo

// PreSuf.cpp 

// Ilustra o uso de 

// operadores em prefixo 

// e sufixo. 

#include  

int main() 

{ 

 int i = 10, j = 10; 

 cout << " *** Valores iniciais *** "; 

 cout << "i = " << i 

 << ", j = " << j; 

 // Aplica operadores. 

 i++; C++ BÁSICO 

29

 ++j; 

 cout << " *** Apos operadores *** "; 

 cout << "i = " << i 

 << ", j = " << j; 

 cout << " *** Exibindo usando operadores *** "; 

 cout << "i = " << i++ 

 << ", j = " << ++j; 

 return 0; 

} // Fim de main() 

Saída gerada por este programa: 

*** Valores iniciais *** 

i = 10, j = 10 

*** Apos operadores *** 

i = 11, j = 11 

*** Exibindo usando operadores *** 

i = 11, j = 12 

Exercício

Modifique o exemplo PreSuf.cpp. Faça com que operadores em sufixo e prefixo sejam aplicados às duas 

variáveis, i e j. Depois inverta a ordem da aplicação dos operadores. 

O COMANDO IF

O fluxo de execução de um programa faz com que as linhas sejam executadas na ordem em que aparecem no 

código. Entretanto, é muito comum que um programa precise dar saltos em sua execução, em resposta a 

determinadas condições. O comando if permite testar uma condição (por exemplo, se duas variáveis são iguais) e 

seguir para uma parte diferente do código, dependendo do resultado desse teste. 

A forma mais simples do comando if é: 

if(expressão) 

comando; 

A expressão entre parênteses pode ser de qualquer tipo. O mais comum é que seja uma expressão relacional. Se 

o valor da expressão for zero, ela é considerada falsa, e o comando não é executado. Se o valor da expressão for 

diferente de zero, ela é considerada verdadeira, e o comando é executado. 

No exemplo: 

if(a > b) 

a = b; C++ BÁSICO 

30

somente se a for maior que b, a segunda linha será executada. 

Um bloco de comandos contidos entre chaves { } tem efeito similar ao de um único comando. Portanto, o 

comando if pode ser também utilizado da seguinte forma: 

if(expressao) 

{ 

comando1; 

comando2; 

// etc. 

} 

Exemplo

// DemoIf.cpp 

// Ilustra o uso 

// do comando if. 

#include  

int main() 

{ 

 int golsBrasil, golsHolanda; 

 cout << " *** Placar Brasil X Holanda *** "; 

 cout << "Digite gols do Brasil: "; 

 cin >> golsBrasil; 

 cout << " Digite gols da Holanda: "; 

 cin >> golsHolanda; 

 if(golsBrasil > golsHolanda) 

 cout << "A festa e' verde e amarela!!! "; 

 if(golsHolanda > golsBrasil) 

 cout << "A festa e' holandesa!!! "; 

 return 0; 

} // Fim de main() 

Saída gerada por este programa: 

*** Placar Brasil X Holanda *** 

Digite gols do Brasil: 5 

Digite gols da Holanda: 3 

A festa e' verde e amarela!!! 

Exercício

Modifique o exemplo DemoIf.cpp para levar em consideração a possibilidade de empate. C++ BÁSICO 

31

O COMANDO ELSE

Muitas vezes, um programa precisa seguir um caminho de execução se uma dada condição for verdadeira, e

outro caminho de execução se a mesma condição for falsa. Para isto, C++ oferece a combinação if... else. Eis a 

forma genérica: 

if(expressao) 

comando1; 

else 

comando2; 

Exemplo

// DemElse.cpp 

// Ilustra o uso 

// de else. 

#include  

int main() 

{ 

 int numMaior, numMenor; 

 cout << "Digite numMaior + : "; 

 cin >> numMaior; 

 cout << "Digite numMenor + : "; 

 cin >> numMenor; 

 if(numMaior > numMenor) 

 cout << " Ok. numMaior e' maior " 

 "que numMenor. "; 

 else 

 cout << "Erro!!! numMaior e' menor " 

 "ou igual a numMenor! "; 

 return 0; 

} // Fim de main() 

Saída gerada por este programa: 

Digite numMaior + : 10 

Digite numMenor + : 18 

Erro!!! numMaior e' menor ou igual a numMenor! 

Exercício

Modifique o exemplo DemElse.cpp de maneira que o programa cheque inicialmente se os dois números são 

diferentes, e exiba uma mensagem se eles forem iguais. C++ BÁSICO 

32

MAIS SOBRE IF / ELSE

Qualquer comando pode aparecer dentro da cláusula if... else. Isso inclui até mesmo outra cláusula if... else. 

O exemplo abaixo ilustra esse fato. 

Exemplo

// IfElse.cpp 

// Outro exemplo 

// de if/else. 

#include  

int main() 

{ 

 int numMaior, numMenor; 

 cout << "Digite numMaior + : "; 

 cin >> numMaior; 

 cout << "Digite numMenor + : "; 

 cin >> numMenor; 

 if(numMaior >= numMenor) 

 { 

 if((numMaior % numMenor) == 0) 

 { 

 if(numMaior == numMenor) 

 cout << "numMaior e' igual a numMenor. "; 

 else 

 cout << "numMaior e' multiplo " 

 "de numMenor "; 

 } // Fim de if((numMaior % numMenor) == 0) 

 else 

 cout << "A divisao nao e' exata. "; 

 } // Fim de if(numMaior >= numMenor) 

 else 

 cout << "Erro!!! numMenor e' maior " 

 "que numMaior! "; 

 return 0; 

} // Fim de main() 

Saída gerada por este programa: 

Digite numMaior + : 44 

Digite numMenor + : 39 

A divisao nao e' exata. 

Exercício

Reescreva o programa IfElse.cpp, de maneira que o programa cheque primeiro se os dois números são iguais e 

utilize a construção else if para checar se numMaior é maior que numMenor. C++ BÁSICO 

33

IDENTAÇÃO

As cláusulas if...else podem ser aninhadas indefinidamente. Isso quer dizer que uma cláusula if...else pode conter 

outra cláusula if...else, que pode conter uma terceira cláusula if...else, a qual pode conter uma quarta cláusula 

if...else, e assim por diante. 

Esse tipo de código pode se tornar difícil de ler, e induzir a erros. Por isso é importante usar adequadamente o 

recurso da indentação do código e as chaves { }. 

A indentação consiste em indicar níveis de aninhamento, afastando gradualmente os blocos de código da 

margem esquerda da página. Isso geralmente é feito com o uso da tecla . 

Exemplo

// Indent.cpp 

// ATENÇÃO: ESTE PROGRAMA 

// CONTÉM ERROS PROPOSITAIS!!! 

// Ilustra a importância da 

// indentação e do uso 

// de chaves. 

#include  

int main() 

{ 

cout << " Digite um num. menor que 5 " 

"ou maior que 10: "; 

int num; 

cin >> num; 

if(num >= 5) 

if(num > 10) 

cout << " Voce digitou maior que 10. "; 

else 

cout << " Voce digitou menor que 5. "; 

// Erro no casamento if/else. 

return 0; 

} // Fim de main() 

Saída gerada por este programa: 

Digite um num. menor que 5 ou maior que 10: 7 

Voce digitou menor que 5. 

Exercício

Modifique o programa Indent.cpp, de maneira que ele apresente o comportamento correto. Utiliza a indentação 

para facilitar a leitura do código fonte. 

OPERADORES LÓGICOS

Muitas vezes, pode surgir a necessidade de fazer mais de uma pergunta relacional de uma só vez. Por exemplo, 

"x é maior que y e, ao mesmo tempo, y é maior que z?" C++ BÁSICO 

34

Pode ser necessário determinar se essas duas condições são verdadeiras ao mesmo tempo, dentro de um 

determinado programa. 

Os operadores lógicos mostrados abaixo são usados nesse tipo de situação. 

Operador Símbolo Exemplo

AND && expressao1 && expressao2 

OR || expressao1 || expressao2 

NOT ! !expressao 

O operador lógico AND avalia duas expressões. Se as duas forem verdadeiras, o resultado da operação lógica 

AND será verdadeiro. Ou seja, é preciso que ambos os lados da operação seja verdadeira, para que a expressão 

completa seja verdadeira. 

O operador lógico OR avalia duas expressões. Se qualquer uma delas for verdadeira, o resultado da operação 

lógica OR será verdadeiro. Ou seja, basta que um dos lados da operação seja verdadeiro, para que a expressão 

completa seja verdadeira. 

O operador lógico NOT avalia uma só expressão. O resultado é verdadeiro se a expressão avaliada for falsa, e 

vice versa. 

Exemplo

// AndTst.cpp 

// Ilustra o uso 

// do operador lógico 

// AND. 

#include  

int main() 

{ 

 int a; 

 cout << " Digite um num. positivo " 

 "e menor que 10: "; 

 cin >> a; 

 if((a > 0) && (a < 10)) 

 cout << " Voce digitou corretamente..."; 

 cout << " Digite um num. negativo " 

 "ou maior que 1000: "; 

 cin >> a; 

 if((a < 0) || (a > 1000)) 

 cout << " Voce acertou de novo..."; 

 return 0; 

} // Fim de main() 

Saída gerada por este programa: 

Digite um num. positivo e menor que 10: 12 

Digite um num. negativo ou maior que 1000: 1001 

Voce acertou de novo... C++ BÁSICO 

35

Exercício

Modifique o exemplo AndTst.cpp, usando o operador NOT ! para exibir mensagens caso o usuário digite valores 

errados. 

O OPERADOR CONDICIONAL TERNÁRIO

O operador condicional ? : é o único operador ternário de C++. Ou seja, ele recebe três termos. 

O operador condicional recebe três expressões e retorna um valor. 

(expressao1) ? (expressao2) : (expressao3); 

Esta operação pode ser interpretada da seguinte forma: se expressao1 for verdadeira, retorne o valor de 

expressao2; caso contrario, retorne o valor de expressao3. 

Exemplo

// OpTern.cpp 

// Ilustra o uso do 

// operador condicional 

// ternário. 

#include  

int main() 

{ 

 int a, b, c; 

 cout << "Digite um num. + : "; 

 cin >> a; 

 cout << " Digite outro num. + : "; 

 cin >> b; 

 if(a == b) 

 cout << "Os numeros sao iguais. " 

 "Tente novamente. "; 

 else 

 { 

 // Atribui o valor 

 // mais alto à 

 // variável c. 

 c = (a > b) ? a : b; 

 // Exibe os valores. 

 cout << " *** Valores finais *** "; 

 cout << "a = " << a << " "; 

 cout << "b = " << b << " "; 

 cout << "c = " << c << " "; 

 } // Fim de else. 

 return 0; 

} // Fim de main() 

Saída gerada por este programa: 

Digite um num. + : 99 

Digite outro num. + : 98 C++ BÁSICO 

36

*** Valores finais *** 

a = 99 

b = 98 

c = 99 

Exercício

Reescreva a atribuição de OpTern.cpp usando if...else. 

PROTÓTIPOS DE FUNÇÕES

O protótipo de uma função é uma declaração que indica o tipo que a função retorna, o nome da função e os 

parâmetros que recebe. Eis um exemplo de protótipo de função: 

int CalcArea(int compr, int larg); 

O protótipo e a definição da função devem conter exatamente o mesmo tipo retornado, o mesmo nome e a 

mesma lista de parâmetros. Se houver alguma discordância, isso gerará um erro de compilação. Porém o 

protótipo da função não precisa conter os nomes dos parâmetros, somente seus tipos. Por exemplo, o protótipo 

acima poderia ser reescrito da seguinte forma: 

int CalcArea(int, int); 

Este protótipo declara uma função chamada CalcArea(), que retorna um valor int e recebe dois parâmetros, 

também int. 

Todas as funções retornam um tipo, ou void. Se o tipo retornado não for especificado explicitamente, fica 

entendido que o tipo é int. 

Muitas das funções que usamos em nossos programas já existem como parte da biblioteca padrão que 

acompanha o compilador C++. Para usar uma dessas funções, é necessário incluir no programa o arquivo que 

contém o protótipo da função desejada, usando a diretiva #include. Para as funções que nós mesmos escrevemos, 

precisamos escrever o protótipo. 

Exemplo

// IntrFun.cpp 

// Introduz o uso 

// de funções. 

#include  

// Protótipo. 

int CalcArea(int compr, int larg); 

int main() 

{ 

 int comp, lrg, area; 

 cout << "*** Calculo da area" 

 " de um retangulo *** "; 

 cout << "Digite o comprimento " 

 "(metros) + : "; 

 cin >> comp; 

 cout << " Digite a largura " C++ BÁSICO 

37

 "(metros) + : "; 

 cin >> lrg; 

 // Calcula area usando 

 // a funcao CalcArea() 

 area = CalcArea(comp, lrg); 

 cout << " Area = " 

 << area 

 << " metros quadrados. "; 

 return 0; 

} // Fim de main() 

// Definição da função. 

int CalcArea(int compr, int larg) 

{ 

 return compr * larg; 

} // Fim de CalcArea() 

Saída gerada por este programa: 

*** Calculo da area de um retangulo *** 

Digite o comprimento (metros) + : 12 

Digite a largura (metros) + : 15 

Area = 180 metros quadrados. 

Exercício

Reescreva o programa IntrFun.cpp. No lugar da função CalcArea(), crie uma função CalcVolume(), que calcula 

o volume de uma caixa retangular. 

FUNÇÕES: VARIÁVEIS LOCAIS

Além de podermos passar variáveis para uma função, na forma de argumentos, podemos também declarar 

variáveis dentro do corpo da função. Essas variáveis são chamadas locais, porque somente existem localmente, 

dentro da função. Quando a função retorna, a variável deixa de existir. 

As variáveis locais são definidas da mesma forma que as outras variáveis. Os parâmetros da função são também 

considerados variáveis locais, e podem ser usados exatamente como se tivessem sido definidos dentro do corpo 

da função. 

Exemplo

// Local.cpp 

// Ilustra o uso de 

// variáveis locais. 

#include  

// Protótipo. 

// Converte temperatura em graus 

// Fahrenheit para graus centígrados. 

double FahrParaCent(double); 

int main() 

{ 

 double tempFahr, tempCent; 

 cout << " *** Conversao de graus Fahrenheit " C++ BÁSICO 

38

 "para graus Centigrados *** "; 

 cout << "Digite a temperatura em Fahrenheit: "; 

 cin >> tempFahr; 

 tempCent = FahrParaCent(tempFahr); 

 cout << " " 

 << tempFahr 

 << " graus Fahrenheit = " 

 << tempCent 

 << " graus Centigrados. "; 

 return 0; 

} // Fim de main() 

// Definição da função. 

double FahrParaCent(double fahr) 

{ 

 // Variável local. 

 double cent; 

 cent = ((fahr - 32) * 5) / 9; 

 return cent; 

} // Fim de FahrParaCent(double fahr) 

Saída gerada por este programa: 

*** Conversao de graus Fahrenheit para graus Centigrados *** 

Digite a temperatura em Fahrenheit: 65 

65 graus Fahrenheit = 18.3333 graus Centigrados. 

Exercício

Reescreva o programa Local.cpp, de maneira que a função faça a conversão de graus centígrados para graus 

Fahrenheit. 

FUNÇÕES: VARIÁVEIS GLOBAIS

 Além de podermos passar variáveis para uma função, na forma de argumentos, podemos também declarar 

variáveis dentro do corpo da função. Essas variáveis são chamadas locais, porque somente existem localmente, 

dentro da função. Quando a função retorna, a variável deixa de existir. 

As variáveis locais são definidas da mesma forma que as outras variáveis. Os parâmetros da função são também 

considerados variáveis locais, e podem ser usados exatamente como se tivessem sido definidos dentro do corpo 

da função. 

Exemplo

// Local.cpp 

// Ilustra o uso de 

// variáveis locais. 

#include  

// Protótipo. 

// Converte temperatura em graus 

// Fahrenheit para graus centígrados. 

double FahrParaCent(double);