380196 Apostila C++ 2010b

Prévia do material em texto

Estrutura de um programa em C++ 
Provavelmente a melhor maneira de começar a aprender uma linguagem de programação é com um 
programa. Então aqui está nosso primeiro programa: 
// meu primeiro programa em C++
 
#include <iostream>
using namespace std;
 
int main ()
{
 cout << "Ola Mundo!";
 return 0;
}
Ola Mundo! 
O lado esquerdo mostra o código-fonte de nosso primeiro programa, no qual podemos nomeá-lo, 
por exemplo, como hiworld.cpp. O lado direito mostra o resultado do programa depois de 
compilado e executado. A maneira de editar e compilar um programa depende do compilador que 
você estiver usando. Dependendo se tem ou não uma interface de desenvolvimento e da versão. 
Consulte o manual ou a ajuda inclusa no seu compilador se tiver dúvidas em como compilar um 
programa de console em C++. 
O programa anterior é o primeiro programa que a maioria dos aprendizes codificam, e o resultado é 
a impressão da frase "Ola Mundo!" na tela. É um dos programas mais simples que pode ser 
codificado em C++, mas já inclui os componentes básicos que todos os programas em C++ 
possuem. Nós iremos analisá-los um por um: 
// meu primeiro programa em C++
Essa é uma linha de comentário. Todas as linhas que iniciarem com duas barras (//) são 
consideradas comentários e não tem nenhum efeito no comportamento do programa. Elas 
podem ser usadas pelo programador para incluir explicações ou observações curtas dentro 
do próprio código. Nesse caso, essa linha é uma breve descrição do que o nosso programa 
faz. 
#include <iostream>
Comandos que começam um sinal de numeração (#) são diretivas do pré-processador. Elas 
não são linhas de código executáveis, mas indicações para o compilador. Nesse caso, o 
comando #include <iostream> diz ao pré-processador do compilador para incluir o 
arquivo de cabeçalho padrão iostream. Esse arquivo específico inclui as declarações da 
biblioteca básica de entrada-saída do C++, e está sendo usado porque suas funcionalidades 
serão usadas mais tarde nesse programa. 
Using namespace std
Nome do espaço onde estão colocadas as funções básicas da linguagem.
int main ()
Essa linha corresponde ao início da declaração da função main. A função main é o ponto 
pelo qual todos os programas em C++ iniciam a execução. Não faz diferença se estiver no 
início, no fim, ou no meio do código – seu conteúdo é sempre o primeiro a ser executado 
quando um programa inicia. Além disso, pelo mesmo motivo, é obrigatório que todos os 
programas em C++ tenham uma função main. 
Depois de main há um par de parênteses () porque é uma função. Em C++ todas as funções 
são seguidas por um par de parênteses () que, opcionalmente, podem incluir argumento 
dentro deles. O conteúdo da função main segue imediatamente após sua declaração formal e 
é coberto entre chaves ({}), como em nosso exemplo. 
cout << "Ola Mundo!";
Essa instrução faz a coisa mais importante nesse programa. cout é o dispositivo de saída 
padrão no C++ (geralmente o monitor), e a frase completa insere uma sequência de 
caracteres ("Ola Mundo!" nesse caso) no dispositivo de saída (o monitor). cout é declarado 
no arquivo de cabeçalho iostream.h, então pra que seja possível utiliza-lo, esse arquivo 
precisa ser incluso. 
Note que a frase termina com um caractere ponto-e-vírgula (;). Esse caractere significa o 
fim da instrução e precisa ser incluído após toda instrução em qualquer programa em C++ 
(um dos erros mais comuns dos programadores de C++ é devido ao fato de esquecerem de 
incluir um ponto-e-vírgula ; no final de cada instrução). 
return 0;
A instrução return faz com que a função main() termine e retorne o código que segue a 
instrução, nesse caso o 0. Essa é a maneira mais comum de terminar um programa que não 
encontrou nenhum erro durante sua execução. Como você verá em exemplos seguintes, 
todos os programas em C++ terminam com um comando parecido com esse. 
Sendo assim, você deve ter notado que nem todas as linhas desse programa realizaram uma ação. 
Havia linhas contendo apenas comentários (aquelas iniciadas por //), linhas com instruções para o 
pré-processador do compilador (aquelas iniciadas por #), também haviam linhas que iniciavam a 
declaração de uma função (nesse caso, a função main) e, finalmente linhas com instruções (como a 
chamada à cout <<), todas essas últimas foram incluídas dentro do bloco delimitado pelas chaves 
({}) da função main. 
O programa foi estruturado em linhas diferentes para que seja mais fácil lê-lo, mas isso não é 
obrigatório. Por exemplo, ao invés de: 
 
int main ()
{
 cout << " Ola Mundo! ";
 return 0;
}
poderíamos ter escrito: 
int main () { cout << " Ola Mundo! "; return 0; } 
em apenas uma linha e isso teria exatamente o mesmo significado. 
Em C++, a separação entre instruções é especificada com um ponto-e-vírgula (;) no final de cada 
instrução. A divisão do código em linhas diferentes serve somente para torná-lo mais legível e 
esquemático para seres humanos. 
Aqui está um programa com mais instruções: 
// meu segundo programa em C++
 
#include <iostream>
using namespace std;
 
int main ()
{
 cout << "Ola Mundo! ";
 cout << "Eu sou um programa em C++";
 return 0;
}
Ola Mundo! Eu sou um programa em C++ 
Nesse caso nós usamos o método cout << duas vezes em duas instruções diferentes. Mais uma vez, 
a separação do código em linhas diferentes só foi feita para dar maior legibilidade ao programa, já 
que main poderia ter sido definida perfeitamente assim: 
int main () { cout << " Ola Mundo! "; cout << " Eu sou um programa em C++ "; 
return 0; } 
Nós também poderíamos dividir o código em mais linhas se considerássemos conveniente: 
 
int main ()
{
 cout <<
 "Ola Mundo!";
 cout
 << "Eu sou um programa em C++";
 return 0;
}
E o resultado teria sido exatamente o mesmo dos exemplos anteriores. 
As diretivas de pré-processador (aquelas que começam por #) estão fora dessa regra já que elas não 
são instruções verdadeiras. Elas são linhas lidas e descartadas pelo pré-processador e não produzem 
nenhum código. Essas precisam ser especificadas em suas próprias linhas e não requerem a inclusão 
de um ponto-e-vírgula (;) no final. 
Comentários.
Comentários são pedaços de código-fonte descartados do código pelo compilador. Eles não fazem 
nada. O objetivo deles é somente permitir que o programador insira notas ou descrições dentro do 
código-fonte. 
O C++ suporta duas maneiras para inserir comentários: 
// comentário de linha
/* comentário de bloco */ 
O primeiro deles, o comentário de linha, descarta tudo desde onde o par de barras (//) é achado até 
o final daquela mesma linha. O segundo deles, o comentário de bloco, descarta tudo entre os 
caracteres /* e a próxima aparição dos caracteres */, com a possibilidade de incluir diversas linhas. 
Nós iremos adicionar comentários ao nosso segundo programa: 
 
/* meu segundo programa em C++
 com mais comentários */
 
#include <iostream>
using namespace std;
 
int main ()
{
 cout << "Ola Mundo! "; //diz Ola Mundo!
 cout << "Sou programa em C++"; //diz Sou programa em C++
 return 0;
}
Ola Mundo! Sou 
programa em C++ 
Se você incluir comentários dentro do código-fonte de seus programas sem usar as combinações de 
caracteres //, ou /* e */, o compilador ira entendê-los como se fossem instruções C++ e, na 
maioria das vezes, irá causar um ou mais mensagens de erro.
Variáveis. Tipos de dados. Constantes. 
A utilidade dos programas "Ola Mundo" mostrados na seção anterior são coisas mais que 
questionáveis. Nós tivemos que digitar diversas linhas de código, compilá-las, e então executar o 
programa resultante somente para obter uma frase no monitor como resultado. É verdade que teria 
sido muito mais rápido simplesmente digitar a frase de saída sozinho,mas a programação não é 
limitada somente à impressão de textos no monitor. Para nos aprofundar um pouco mais sermos 
capazes de codificar programas que desempenham tarefas úteis e que realmente nos ajudam, 
precisamos introduzir o conceito de variável. 
Vamos imaginar que eu lhe peça para memorizar o número 5 em sua memória mental, e então eu 
lhe peça para memorizar o número 2 também. Você acabou de guardar dois valores em sua 
memória. Agora, se eu lhe pedir para adicionar 1 ao primeiro número que eu lhe disse, você deve 
estar guardando os números 6 (que é 5+1) e 2 em sua memória. Valores no qual poderíamos subtrair 
e obter 4 como resultado. 
Todo esse processo que você fez é similar ao que um computador pode fazer com duas variáveis. 
Esse mesmo processo pode ser expresso em C++ com o seguinte conjunto de instruções: 
 
a = 5;
b = 2;
a = a + 1;
result = a - b;
Obviamente esse é um exemplo muito simples já que nós só utilizamos dois pequenos valores 
inteiros, mas considere que seu computador pode guardar milhões de números como esses ao 
mesmo tempo e conduzir operações matemáticas sofisticadas com eles. 
Sendo assim, nós podemos definir uma variável como uma porção de memória que guarda um valor 
determinado. 
Cada variável precisa de um identificador que a distingue das outras, por exemplo, no código 
anterior os identificadores de variáveis eram a, b e result, mas nós poderíamos chamá-las de 
qualquer nome que inventássemos, contanto que fossem identificadores válidos. 
Identificadores
Um identificador válido é uma sequência de uma ou mais letras, dígitos ou símbolos de underscore 
( _ ). O tamanho de um identificador não tem limite, mas para alguns compiladores, somente os 32 
primeiros caracteres de um identificador são significativos (o resto não é considerado). 
Nem espaços nem letras marcadas podem fazer parte de um identificador. Somente letras, dígitos e 
caracteres de underscore são válidos. Além disso, identificadores de variáveis sempre devem 
começar com uma letra. Eles também podem começar com um caractere de underscore ( _ ), mas 
isso é geralmente reservado para links externos. Eles nunca podem começar com um dígito. 
Outra regra que você precisa considerar ao inventar seus próprios identificadores é que eles não 
podem ser iguais a nenhuma palavra-chave da linguagem C++ nem com nenhuma específica do 
seu compilador, já que podem se confundir. Por exemplo, as seguintes expressões são sempre 
consideradas palavras-chave de acordo com o padrão ANSI-C++ e, sendo assim, elas não podem ser 
usadas como identificadores: 
asm, auto, bool, break, case, catch, char, class, const, const_cast, continue, 
default, delete, do, double, dynamic_cast, else, enum, explicit, 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, static_cast, struct, switch, template, this, throw, 
true, try, typedef, typeid, typename, union, unsigned, using, virtual, void, 
volatile, wchar_t 
Adicionalmente, representações alternativas para alguns operadores não devem ser usados já que 
são palavras reservadas sob algumas circunstâncias: 
and, and_eq, bitand, bitor, compl, not, not_eq, or, or_eq, xor, xor_eq 
Seu compilador também pode incluir mais algumas palavras-chave reservadas. Por exemplo, muitos 
compiladores que geram código de 16 bits (como alguns compiladores para DOS) também incluem 
far, huge e near como palavras-chave. 
Muito importante: A linguagem C++ é sensível ao contexto, o que significa dizer que um 
identificador escrito em letras maiúsculas não é equivalente a outro com o mesmo nome mas escrito 
em letras minúsculas. Assim, por exemplo, a variável RESULT não é a mesma que result nem que a 
variável Result. 
Tipos de dados
Ao programar, nós guardamos as variáveis na memória do nosso computador, mas o computador 
precisa saber o que nós queremos guardar nele já que guardar um número simples, uma letra, ou um 
número grande não irá ocupar o mesmo espaço na memória. 
A memória do nosso computador está organizada byte é a quantidade mínima de memória que 
podemos gerenciar. Um byte pode guardar uma quantidade relativamente pequena de dados, 
geralmente um número inteiro entre 0 e 255 ou um único caractere. Mas além disso, o computador 
pode manipular tipos de dados mais complexos que são a união de diversos bytes, como números 
compridos ou números com decimais. A seguir você tem uma lista dos tipos de dados fundamentais 
existentes em C++, assim como o intervalo dos valores que podem ser representados com cada um 
deles: 
DATA TYPES 
Nome Bytes* Descrição Intervalo*
char 1 caractere ou número inteiro com tamanho de 8 bits.
signed: -128 até 
127
unsigned: 0 até 
255
short 2 número inteiro com tamanho de 16 bits.
signed: -32768 
até 32767
unsigned: 0 até 
65535
long 4 número inteiro com tamanho de 32 bits. signed:-
2147483648 até 
2147483647
unsigned: 0 até 
4294967295
int *
Número inteiro. Seu tamanho tradicionalmente 
depende no tamanho do tipo Word do sistema, assim 
no MSDOS possui 16 bits, enquanto em sistemas de 
32 bits (como Windows 9x/2000/NT e sistemas que 
funcionam sob modo protegido em sistemas x86) 
possui 32 bits (4 bytes).
Veja short, long
float 4 número real. 3.4e + / - 38 (7 digitos)
double 8 número real com dupla precisão. 1.7e + / - 308 (15 digitos)
long 
double 10 número real comprido com dupla precisão.
1.2e + / - 4932 
(19 digitos)
bool 1
Valor boleano. Pode assumir um dos dois valores: 
true ou false NOTA: esse é um tipo que foi 
adicionado recentemente pelo padrão ANSI-C++. Nem 
todos os compiladores suportam-no.
true ou false
wchar_t 2
Caractere largo. Foi projetado como um tipo para 
guardar caracteres internacionais de um conjunto de 
caracteres de dois bytes. NOTA: esse é um tipo que foi 
adicionado recentemente pelo padrão ANSI-C++. Nem 
todos os compiladores suportam-no.
caracteres largos
* Os valores das colunas Bytes e Intervalo podem variar dependendo do seu sistema. Os valores 
incluídos aqui são os mais comuns e usados pela maioria dos compiladores. 
Além desses tipos de dados fundamentais, também existem os ponteiros e a especificação de tipo 
de parâmetro void, que veremos mais tarde. 
Declaração de variáveis
Para que se possa utilizar uma variável no C++, primeiro precisamos declará-la especificando qual 
dos tipos de dados acima nós queremos que seja. A sintaxe para declarar uma nova variável é digitar 
o especificador do tipo de dados que queremos (como int, short, float...) seguido por um 
identificador de variável válido. Por exemplo:
int a;
float mynumber;
são declarações válidas de variáveis. A primeira declara uma variável do tipo int com um 
identificador a. A segunda declara uma variável do tipo float com um identificador mynumber. 
Uma vez declaradas, as variáveis a e mynumber podem ser usadas dentro do resto de seu escopo no 
programa. 
Se você precisar declarar diversas variáveis do mesmo tipo e você quiser poupar um pouco de 
trabalho de escrita, você pode declarar todas elas na mesma linha, separando os identificadores por 
vírgulas. Por exemplo:
int a, b, c;
declara três variáveis (a, b e c) do tipo int , e tem exatamente o mesmo significado se tivesse sido 
escrito:: 
int a;
int b;
int c;
Tipos de dados inteiros (char, short, long e int) podem ser sinalizados (signed) ou não 
sinalizados (unsigned) de acordo com o intervalo de números que nós precisamos representar. 
Assim, para especificar um tipo de dado inteiro nós fazemos isso colocando a palavra-chave signed 
ou unsigned antes do tipo de dado. Por exemplo: 
unsigned short NumberOfSons;
signed int MyAccountBalance;
Por padrão, se não especificarmos signed ou unsigned será assumido que o tipo é signed, sendoassim, na segunda declaração nós poderíamos ter escrito:
int MyAccountBalance;
com exatamente o mesmo significado e, já que essa é a maneira mais usual, poucos códigos-fonte 
incluem a palavra-chave signed como parte de um tipo de nome composto. 
A única exceção para essa regra é o tipo char que existe por si só e é considerado um tipo diferente 
de signed char e unsigned char. 
Finalmente, signed e unsigned também podem ser usados como tipos simples, significando o 
mesmo que signed int e unsigned int respectivamente. As duas declarações seguintes são 
equivalentes: 
unsigned MyBirthYear;
unsigned int MyBirthYear;
Para vermos como uma declaração de variável se parece em um programa de verdade, mostraremos 
o código C++ do exemplo sobre sua memória mental proposto no início dessa seção: 
// operando com variáveis
 
#include <iostream>
using namespace std;
 
int main ()
{
 // declarando variáveis:
 int a, b;
 int result;
 
4 
x
Highlight
x
Highlight
x
Highlight
 // processo:
 a = 5;
 b = 2;
 a = a + 1;
 result = a - b;
 
 // imprime o resultado:
 cout << result;
 
 // termina o programa:
 return 0;
}
Não se preocupe se algo a respeito de declaração de variáveis parece um pouco estranho para você. 
Você verá o resto em detalhes nas próximas seções. 
Inicialização de variáveis
Ao declarar uma variável local, seu valor é indeterminado por padrão. Mas você pode querer que 
uma variável guarde um valor concreto no momento em que for declarada. Para fazer isso, você 
precisa colocar um sinal de igual seguido pelo valor que você quer para a declaração da variável: 
tipo identificador = valor_inicial ; 
Por exemplo, se quiséssemos declarar uma variável int chamada a que contém o valor 0 no 
momento em que fosse declarada, poderíamos escrever: 
int a = 0;
Além dessa maneira de inicializar variáveis (conhecida como parecida-com-c), C++ adicionou uma 
nova maneira de inicializar variáveis: colocando o valor inicial entre parêntesis (): 
tipo identificador (valor_inicial) ; 
Por exemplo: 
int a (0); 
As duas maneiras são válidas e equivalentes no C++. 
Escopo de variáveis
Todas as variáveis que iremos utilizar precisam ter sido previamente declaradas. Uma diferença 
importante nas linguagens C e C++, é que em C++ nós podemos declarar variáveis em qualquer 
lugar do código-fonte, mesmo entre dois comandos executáveis, e não somente no início de um 
bloco de instruções, como acontece em C. 
De qualquer maneira, é recomendado, sob certas circunstâncias, seguir as indicações da linguagem 
x
Highlight
x
Highlight
x
Highlight
x
Highlight
x
Highlight
x
Highlight
x
Highlight
x
Highlight
x
Highlight
x
Highlight
x
Highlight
x
Highlight
x
Highlight
x
Highlight
x
Highlight
x
Highlight
C ao declarar variáveis, já que pode ser útil na depuração de um programa ter todas as declarações 
agrupadas. Sendo assim, a maneira tradicional parecida-com-C de se declarar variáveis, é incluir as 
declarações no início de cada função (para variáveis locais) ou diretamente no corpo do programa 
fora de qualquer função (para variáveis globais). 
 
Variáveis globais podem ser referenciadas em qualquer lugar do código, dentro de qualquer função, 
contanto que esteja depois de sua declaração. 
O escopo das variáveis locais é limitado ao nível de código no qual elas foram declaradas. Se elas 
foram declaradas no início de uma função (como em main) seu escopo é a função main. No 
exemplo acima, isso significa que se outra função além de main() existisse, as variáveis locais de 
main não poderiam ter sido usadas em outra função e vice-versa. 
Em C++, o escopo de uma variável local é dado pelo bloco no qual foi declarada (um bloco é um 
grupo de instruções agrupadas dentro de chaves {}). Se for declarada dentro de uma função, será 
uma variável com escopo de função, se for declarada em um loop, seu escopo será somente o loop, 
etc... 
Além de escopos local e global, também existe o escopo externo, que faz com que uma variável 
seja vista não somente pelo mesmo código-fonte, mas em todos outros arquivos que serão unidos.
Constantes: Literais.
Uma constante é uma expressão que possui um valor fixo. Elas podem ser divididas , Números 
Reais, Caracteres e Strings. 
Números Inteiros
1776
707
-273
Elas são constantes numéricas que identificam números inteiros decimais. Note que para expressar 
uma constante numérica, nós não precisamos digitar aspas duplas (") nem qualquer outro caractere 
especial. Não há dúvida que é uma constante: sempre que escrevermos 1776 em um programa, 
estaremos nos referenciando ao valor 1776. 
Além de números decimais (aqueles que todos nós já conhecemos) C++ permite o uso de constantes 
literais de números octais (base 8) e números hexadecimais (base 16). Se quisermos expressar um 
número octal, precisamos precedê-lo com um caractere 0 (zero). E para expressar um número 
hexadecimal, precisamos precedê-lo pelos caracteres 0x (zero, x). 
x
Highlight
x
Highlight
x
Highlight
Por exemplo, as seguintes constantes literais são todas equivalentes entre si: 
 
75 // decimal
0113 // octal
0x4b // hexadecimal
Todas elas representam o mesmo número: 75 (setenta e cinco) expresso como um número de radial 
10, octal e hexadecimal, respectivamente. 
Números Reais 
Elas expressam números com decimais e/ou expoentes. Elas podem incluir um ponto decimal, um 
caractere e (que expressa "vezes 10 elevado a N-ésima potência", no qual N é o seguinte valor 
inteiro) ou ambos. 
 
3.14159 // 3.14159
6.02e23 // 6.02 x 1023
1.6e-19 // 1.6 x 10-19
3.0 // 3.0
Esses são quatro números com decimais válidos expressos em C++. O primeiro número é PI, o 
segundo é o número de Avogadro, o terceiro é a carga elétrica de um elétron (um número 
extremamente pequeno) –todos eles aproximados- e o último é o número 3 expresso como um 
literal numérico real. 
Caracteres e strings
Também existem constantes não-numéricas, como: 
'z'
'p'
"Ola mundo"
"Como esta voce?" 
As duas primeiras expressões representam caracteres únicos, e as duas seguintes representam 
strings com diversos caracteres. Note que para representar um único caractere, nós o colocamos 
entre aspas simples ('), e para expressar uma string com mais de um caractere, nós a colocamos 
entre aspas duplas ("). 
Ao escrever caracteres únicos e strings de caracteres como sendo constantes, é necessário colocar 
aspas para distingui-los de possíveis identificadores de variáveis ou palavras reservadas. Note o 
seguinte: 
x
'x' 
x se refere à variável x, onde 'x' se refere à constante de caractere 'x'. 
Constantes de caractere e constantes de strings possuem certas peculiaridades, como os códigos de 
escape. Esses são caracteres especiais que não podem ser expressos de outra maneira no código-
fonte de um programa, como nova linha (\n) ou tab (\t). Todos eles são precedidos por uma barra 
invertida (\). Aqui você tem uma lista dos códigos de escape: 
x
Highlight
\n Nova linha
\r Retorno de Carro
\t Tabulação
\v tabulação Vertical
\b Backspace
\f page Feed
\a Alerta (beep)
\' aspas simples (')
\" aspas duplas (")
\? sinal de interrogação (?)
\\ barra invertida (\)
Por exemplo: 
'\n'
'\t'
"Left \t Right"
"one\ntwo\nthree" 
Além disso, você pode expressar qualquer caractere através de seu código ASCII escrevendo um 
caractere de barra invertida (\) seguido pelo código ASCII expresso como um número octal (radial 
8) ou hexadecimal (radial 16). No primeiro caso (octal), o número precisa seguir a barra invertida 
imediatamente (por exemplo \23 ou \40), no segundo caso (hexadecimal), você precisa colocar um 
caractere x antes do número (por exemplo \x20 ou \x4A).
Constantes de string decaracteres podem ser estendidas para mais de uma única linha de código se 
cada linha de código terminar com uma barra invertida (\): 
"string expressa em \
duas linhas" 
Você também pode concatenar diversas constantes de string separando-as por um ou mais espaços 
em branco, tabuladores, nova linha ou qualquer outro caractere vazio válido: 
 
"nós formamos" "uma única" "string" "de caracteres"
x
Highlight
Constantes definidas (#define)
Você pode definir seus próprios nomes para constantes que você usa constantemente sem ter que 
utilizar variáveis simplesmente usando a diretiva de pré-processador #define. Esse é seu formato: 
#define identificador valor 
Por exemplo: 
#define PI 3.14159265
#define NEWLINE '\n'
#define WIDTH 100
definem três novas constantes. Uma vez declaradas, você pode usá-las no resto do seu código como 
se fossem qualquer outra constante, por exemplo: 
circle = 2 * PI * r;
cout << NEWLINE; 
De fato, a única coisa que o pré-processador faz ao encontrar diretivas #define é substituir 
literalmente qualquer ocorrência que houver delas (no exemplo anterior, PI, NEWLINE ou WIDTH) 
pelo código no qual elas tenham sido definidas (3.14159265, '\n' e 100, respectivamente). Por 
essa razão, constantes #define são consideradas constantes macro. 
A diretiva #define não é uma instrução de código, é uma diretiva para o pré-processador, e sendo 
assim, assume a linha toda como diretiva e não requer um ponto-e-vírgula (;) no final. Se você 
incluir um caractere de ponto-e-vírgula (;) no final, também será adicionado quando o pré-
processador substituir qualquer ocorrência dessa constante definida dentro do corpo do programa. 
Constantes declaradas (const)
Com o prefixo const você pode declarar constantes com um tipo específico exatamente como faria 
com uma variável: 
const int width = 100;
const char tab = '\t';
const zip = 12440;
Em caso do tipo não ter sido especificado (como no último exemplo) o compilador assume que é do 
tipo int. 
Operadores. 
Agora que você já conhece a existência de variáveis e constantes, podemos começar a utilizá-las. 
Para isso, C++ provê os operadores, no qual nessa linguagem são um conjunto de palavras-chave e 
símbolos que não fazem parte do alfabeto, mas estão disponíveis em todos os teclados. É importante 
conhecê-los já que eles formam a base da linguagem C++. 
Você não precisa memorizar todo o conteúdo dessa página, pois os detalhes são dados somente para 
servirem como uma futura referência caso você precise. 
x
Highlight
x
Highlight
x
Highlight
x
Highlight
x
Highlight
x
Highlight
x
Highlight
Atribuição (=). 
O operador de atribuição serve para atribuir um valor a uma variável.
a = 5;
atribui o valor inteiro 5 para a variável a. A parte da esquerda do operador = é conhecida 
como lvalue (left value – valor da esquerda) e a da direita como rvalue (right value – valor 
da direita). lvalue precisa sempre ser uma variável, enquanto o lado direito pode ser uma 
constante, uma variável, o resultado de uma operação ou qualquer combinação entre eles. 
É preciso enfatizar que a operação de atribuição sempre funciona da direita para a esquerda 
e nunca o oposto.
a = b;
atribui para a variável a (lvalue) o valor contido na variável b (rvalue) independentemente 
do valor que estiver guardado em a nesse momento. Considere também que estamos apenas 
atribuindo o valor de b para a e que uma mudança futura em b não afetará o valor de a. 
Por exemplo, se usarmos esse código (com a evolução das variáveis em cor verde): 
 
int a, b; // a:? b:?
a = 10; // a:10 b:?
b = 4; // a:10 b:4
a = b; // a:4 b:4
b = 7; // a:4 b:7
isso nos dará o resultado que o valor contido em a é 4 e o valor contido em b é modificação 
final de b não afetou a, mesmo sabendo que havíamos declarado a = b; (regra da direita-
para-esquerda). 
Uma propriedade que C++ tem sobre outras linguagens de programação é que a operação de 
atribuição pode ser usada como rvalue (ou parte de um rvalue) para outra atribuição. Por 
exemplo: 
a = 2 + (b = 5);
é equivalente a: 
b = 5;
a = 2 + b;
isso significa: primeiro atribui 5 para a variável b e então atribui para a o valor 2 mais o 
resultado a atribuição anterior de b (que é 5), deixando a com um valor final de 7. Assim, a 
seguinte expressão também é válida em C++: 
a = b = c = 5;
atribui 5 às três variáveis: a, b e c. 
x
Highlight
x
Highlight
x
Highlight
Operadores aritméticos ( +, -, *, /, % )
As cinco operações aritméticas suportadas pela linguagem são: 
+ Adição
- Subtração
* Multiplicação
/ Divisão
% Módulo
Operações de adição, subtração, multiplicação, e divisão não são um desafio de 
entendimento para você, já que elas correspondem literalmente com seus respectivos 
operadores matemáticos. 
O único que pode não ser conhecido por você é o módulo, especificado com o sinal de 
porcentagem (%). Módulo é a operação que dá o resto de uma divisão de dois valores 
inteiros. Por exemplo, se escrevermos a = 11 % 3;, a variável a irá conter 2 como 
resultado já que 2 é o resto da divisão de 11 por 3. 
Operadores de atribuição compostos (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=)
Uma característica de atribuição em C++ que contribui para sua fama de boa escrita de 
linguagem são os operadores de atribuição compostos (+=, -=, *= e /= entre outros), que 
permitem modificar o valor de uma variável com um dos operadores básicos:
value += increase; é equivalente a value = value + increase;
a -= 5; é equivalente a a = a - 5;
a /= b; é equivalente a a = a / b;
price *= units + 1; é equivalente a price = price * (units + 1);
e o mesmo para todas as outra operações. 
Incremento e decremento.
Outro exemplo de linguagem econômica ao digitar código são os operadores de incremento 
(++) e os operadores de decremento (--). Eles aumentam ou reduzem 1 ao valor guardado na 
variável. São equivalentes a +=1 e a -=1, respectivamente. Assim:
a++;
a+=1;
a=a+1; 
são todos equivalentes e suas funcionalidades são incrementar 1 no valor de a. 
Sua existência é devido ao fato de que nos primeiros compiladores de C, os três exemplos 
anteriores produziam código executável diferente de acordo com qual deles fosse usado. 
Hoje em dia esse tipo de otimização de código é geralmente feito automaticamente pelo 
compilador. 
Uma característica desse operador é que pode ser usado tanto como prefixo ou como sufixo. 
Isso significa que pode ser escrito antes do identificador da variável (++a) ou depois (a++). 
Embora em expressões simples, como a++ ou ++a, eles tenham exatamente o mesmo 
significado, em outras operações no qual o resultado da operação de incremento ou 
decremento é avaliado como outra expressão eles podem ter uma diferença importante em 
seus significados: em caso do operador de incremento ser usado como prefixo (++a), o valor 
é incrementado antes de a expressão ser avaliada e, sendo assim, o valor incrementado é 
x
Highlight
x
Highlight
x
Typewriter
importante
x
Typewriter
 se necessarionull
considerado na expressão; em caso de ser usado como sufixo (a++), o valor guardado em a é 
incrementado depois de ter sido avaliada e, sendo assim, o valor guardado antes da operação 
de incremento é avaliada na expressão. Note a diferença: 
Exemplo 1 Exemplo 2
B=3;
A=++B;
// A é 4, B é 4
B=3;
A=B++;
// A é 3, B é 4
No Exemplo 1, B é incrementado antes que seu valor seja copiado para A. Enquanto no 
Exemplo 2, o valor de B é copiado para A e B é incrementado depois. 
Operadores relacionais ( ==, !=, >, <, >=, <= )
Para que seja possível avaliar uma comparação entre duas expressões, podemos usar os 
operadores relacionais. Conforme especificado no padrão ANSI-C++, o resultado de uma 
operação relacional é um valor bool que pode ser somente true ou false, de acordo com o 
resultado dacomparação. 
Nós podemos querer comparar duas expressões, por exemplo, para saber se elas são iguais 
ou se uma delas é maior que a outra. Aqui está uma lista com os operadores relacionais que 
podem ser utilizados no C++: 
== Igual a
!= Diferente de
> Maior que
< Menor que 
>= Maior ou igual a
<= Menor ou igual a
Aqui você tem alguns exemplos:
(7 == 5) Retornaria false.
(5 > 4) Retornaria true.
(3 != 2) Retornaria true.
(6 >= 6) Retornaria true.
(5 < 5) Retornaria false.
é claro que, ao invés de usar somente constantes numéricas, podemos usar qualquer 
expressão válida, incluindo variáveis. Suponha que a=2, b=3 e c=6,
(a == 5) Retornaria false.
(a*b >= c) Retornaria true já que (2*3 >= 6) é verdadeiro.
(b+4 > a*c) Retornaria false já que (3+4 > 2*6) é falso.
x
Highlight
((b=2) == a) Retornaria true.
Fique atento: o operador = (um sinal de igual) não é o mesmo que o operador == (dois sinais 
de igual), o primeiro é um operador de atribuição (atribui o lado direito da expressão à 
variável da esquerda) e o outro (==) é um operador relacional de igualdade que compara se 
as duas expressões nos dois lados do operador são iguais entre si. Assim, na última 
expressão ((b=2) == a), nós atribuímos primeiramente o valor b e então o comparamos 
com a, que também guarda o valor 2, então o resultado da operação é true. 
Em muitos compiladores feitos antes da publicação do padrão ANSI-C++, assim como na 
linguagem C, as operações relacionais não retornavam um valor bool true ou false, ao invés 
disso, retornavam um int como resultado com um valor 0 para representar "false" e um valor 
diferente de 0 (geralmente 1) para representar "true". 
Operadores lógicos ( !, &&, || ).
O operador ! é equivalente à operação boleana NOT, possui somente um operando 
localizado à direita, e a única coisa que faz é inverter o valor desse operando, gerando false 
se o operando for true e true se o operando for false. É o mesmo que dizer que retorna o 
resultado oposto da avaliação do operando. Por exemplo:
!(5 == 5) Retorna false porque a expressão à direita (5 == 5) seria true.
!(6 <= 4) Retorna true porque (6 <= 4) seria false.
!true Retorna false.
!false Retorna true.
Os operadores lógicos && e || são usados ao avaliar duas expressões para obter um 
resultado único. Eles correspondem às operações lógicas boleanas AND e OR 
respectivamente. Seus resultados dependem da relação entre seus dois operandos:
Primeiro
Operando
a
Segundo
Operando
b
resultado
a && b
resultado
a || b
true true true true
true false false true
false true false true
false false false false
Por exemplo:
( (5 == 5) && (3 > 6) ) retorna false ( true && false ).
( (5 == 5) || (3 > 6)) retorna true ( true || false ).
x
Highlight
x
Highlight
x
Highlight
Operador condicional ( ? ).
O operador condicional avalia uma expressão e retorna um valor diferente de acordo com a 
expressão avaliada, dependendo se for true ou false. Seu formato é: 
condição ? result1 : result2
se condição for true a expressão retornará result1, caso contrário retornará result2.
7==5 ? 4 : 3 retorna 3 pois 7 não é igual a 5.
7==5+2 ? 4 : 3 retorna 4 pois 7 é igual a 5+2.
5>3 ? a : b retorna a, pois 5 é maior que 3.
a>b ? a : b retorna o maior deles, a ou b.
Operadores de Bits ( &, |, ^, ~, <<, >> ).
Operadores de Bits modificam as variáveis considerando os bits que representam os valores 
que elas guardam, ou seja, suas representações binárias. 
op asm Descrição
& AND AND lógico
| OR OR lógico
^ XOR eXclusive OR lógico
~ NOT Complemento de um (inversão de bit)
<< SHL Deslizar à esquerda
>> SHR Deslizar à direita
Operadores de conversão de tipos explícita
Operadores de conversão de tipos nos permitem converter um dado de um determinado tipo 
para outro. Há diversas maneiras para se fazer isso em C++, e a mais popular e compatível 
com a linguagem C, é preceder a expressão a ser convertida pelo novo tipo colocado entre 
parênteses (): 
int i;
float f = 3.14;
i = (int) f;
O código anterior converte um número real 3.14 para um valor inteiro (3). Aqui, o operador 
de conversão de tipos foi (int). Outra maneira de se fazer isso em C++ é usar a forma de 
construtor: precedendo a expressão a ser convertida pelo tipo e colocando a expressão entre 
parênteses: 
i = int ( f ); 
As duas maneiras de conversão de tipos são válidas em C++. Além disso, o ANSI-C++ 
adicionou novos operadores de conversão de tipos mais específicos para programação 
orientada a objetos. 
x
Highlight
x
Highlight
x
Highlight
x
Highlight
sizeof()
Esse operador aceita um parâmetro, que pode ser tanto um tipo de variável como uma 
própria variável, e retorna o tamanho daquele tipo ou objeto em bytes: 
a = sizeof (char);
Isso irá retornar a porque char é um tipo com tamanho de 1 byte.
O valor retornado por sizeof é uma constante, então é sempre determinado antes da 
execução do programa. 
Outros operadores
Mais a frente nesse tutorial iremos ver mais alguns operadores, como os que se referenciam 
a ponteiros ou os específicos para programação orientada a objetos. Cada um é tratado em 
sua seção respectiva. 
Prioridade de operadores
Ao se fazer expressões complexas com diversos operandos, podemos ter algumas dúvidas sobre 
qual operando é avaliado antes e qual é avaliado depois. Por exemplo, nessa expressão:
a = 5 + 7 % 2
podemos questionar se realmente significa:
a = 5 + (7 % 2) com resultado 6, ou
a = (5 + 7) % 2 com resultado 0
A resposta correta é a primeira das duas expressões, com resultado 6. Há uma ordem estabelecida 
com a prioridade de cada operador, e não somente os aritméticos (aqueles cuja preferência 
possamos já saber devido a matemática) mas para todos os operadores que possam aparecer em C+
+. Da prioridade maior para a menor, a ordem é a seguinte: 
Prioridade Operador Descrição Associatividade
1 :: Escopo Esquerda
2 () [ ] -> . sizeof Esquerda
3
++ -- Incremento/Decremento
Direita
~ Complemento de um (bit)
! NOT unário
& * Referência e Apontamento (ponteiros)
(type) Conversão de tipo
+ - Sinal de menos unário
4 * / % Operações aritméticas Esquerda
5 + - Operações aritméticas Esquerda
6 << >> Deslizamento de bits Esquerda
7 < <= > >= Operadores relacionais Esquerda
8 == != Operadores relacionais Esquerda
9 & ^ | Operadores de bits Esquerda
10 && || Operadores lógicos Esquerda
11 ?: Condicional Direita
12 = += -= *= /= %=>>= <<= &= ^= |= Atribuição Direita
13 , Vírgula, Separador Esquerda
Associativdade define –caso haja diversos operadores do mesmo nível de prioridade- qual será 
avaliado primeiro, o que está mais à direita ou o que está mais à esquerda.
Todos esses níveis de precedência para operadores podem ser manipulados ou se tornarem mais 
legíveis com o uso de parênteses ( e ), como nesse exemplo:
a = 5 + 7 % 2;
pode ser escrito como:
a = 5 + (7 % 2); ou 
a = (5 + 7) % 2;
de acordo com a operação que queremos realizar. 
Então caso você queira escrever uma expressão complicada e não tem certeza dos níveis de 
precedência, sempre inclua parênteses. Provavelmente também será um código mais legível.
Estruturas de controle. 
Um programa geralmente não é limitado a uma sequência linear de instruções. Durante o processo, 
pode bifurcar, repetir código, ou tomar decisões. Por esse motivo, C++ provê estruturas de controle 
que servem para especificar o que precisa ser feito para executar nosso programa. 
Com a introdução das sequências de controle, teremos que introduzir um novo conceito: o bloco de 
instruções. Um bloco de instruções é um grupo de instruções separados por pontos-e-vírgulas (;), 
mas agrupados em um bloco delimitado por sinais de chaves: { e }. 
A maioria das estruturas de controle que veremos nessa seção permitemum conteúdo genérico 
como parâmetro, isso se refere a uma única instrução ou a um bloco de instruções, como quisermos. 
Se quisermos que o conteúdo seja uma única instrução, não precisamos colocá-la entre chaves ({}). 
Se quisermos que o conteúdo seja mais que uma única instrução, precisamos colocá-la entre chaves 
({}) formando um bloco de instruções. 
Estrutura condicional: if e else
É usada para executar uma instrução ou bloco de instruções somente se uma condição for satisfeita. 
Sua forma é:
if (condição) conteúdo
onde condição é a expressão que está sendo avaliada. Se a condição for true, o conteúdo é 
executado. Se for false, o conteúdo é ignorado (não é executado) e o programa continua na 
próxima instrução depois da estrutura condicional. 
Por exemplo, o seguinte fragmento de código imprime x e 100 somente se o valor guardado na 
variável x for igual a 100:
if (x == 100)
 cout << "x e 100";
Se quisermos que mais de uma única instrução seja executada no caso da condição ser true, 
precisamos especificar um bloco de instruções usando chaves { }: 
if (x == 100)
 {
 cout << "x e ";
 cout << x;
 }
Podemos especificar também o que queremos que aconteça caso a condição não seja satisfeita 
usando a palavra-chave else. Sua forma usada em conjunto com if é:
if (condição) conteúdo1 else conteúdo2
Por exemplo:
if (x == 100)
 cout << "x e 100";
else
 cout << "x nao e 100";
imprime na tela x e 100 se x for igual a 100, mas se não for –e somente se não for- imprime x não 
e 100. 
As estruturas if + else podem ser concatenadas com a intenção de verificar um intervalo de valores. 
O seguinte exemplo mostra seu uso dizendo se o valor presente guardado em x é positivo, negativo 
ou nenhum dos anteriores, ou seja, igual a zero.
if (x > 0)
 cout << "x e positivo";
else if (x < 0)
 cout << "x e negativo";
else
 cout << "x e 0";
Lembre-se que caso queiramos que mais de uma única instrução seja executada, precisamos agrupá-
las em um bloco de instruções usando chaves { }. 
Estruturas repetitivas ou loops
Loops tem como objetivo repetir um conteúdo um certo número de vezes ou enquanto uma 
condição seja satisfeita. 
O loop while.
Seu formato é:
while (expressão) conteúdo
e sua função é simplesmente repetir o conteúdo enquanto a expressão for verdadeira. 
Por exemplo, iremos fazer um programa que faz uma contagem regressiva usando um loop 
while:
// contagem regressiva customizada usando while
#include <iostream>
using namespace std;
int main ()
{
 int n;
 cout << "Entre com o numero inicial > ";
 cin >> n;
 while (n>0) {
 cout << n << ", ";
 --n;
 }
 cout << "FOGO!";
 return 0;
}
Entre com o numero 
inicial > 8
8, 7, 6, 5, 4, 3, 2, 1, 
FOGO! 
Quando o programa inicia, é pedido ao usuário que insira um número inicial para a 
contagem regressiva. Então quando o loop while inicia, se o valor entrado pelo usuário 
satisfizer a condição n>0 (de que n é maior que 0 ), o bloco de instruções seguinte será 
executado um número indefinido de vezes enquanto a condição (n>0) permanecer 
verdadeira. 
Todo o processo no programa acima pode ser interpretado de acordo com o seguinte script: 
iniciando em main: 
• 1. O usuário atribui um valor para n. 
• instrução while checa se (n>0). Nesse ponto há duas possibilidades: 
o true: executa o conteúdo (passo 3,) 
o false: pula o conteúdo. O programa segue para o passo 5..
• 3. Executa o conteúdo:
cout << n << ", ";
--n;
(imprime n na tela e decrementa 1 de n). 
• 4. Fim do bloco. Retorna automaticamente ao passo 2. 
• 5. Continua o programa depois do bloco: imprime FOGO! e termina o programa. 
Precisamos considerar que o loop precisa terminar alguma hora, sendo assim, dentro do 
bloco de instruções (o conteúdo do loop) precisamos prover algum método que força a 
condição a se tornar falsa em algum momento, ou em caso contrário, o loop continuará se 
repetindo para sempre. Nesse caso nós incluímos --n; que faz com que a condição se torne 
false depois de algumas repetições de loop: quando n se torna 0, que é quando nossa 
contagem regressiva termina. 
É claro que essa é uma ação bastante simples para nosso computador que toda a contagem 
regressiva é feita de maneira instantânea sem um atraso prático entre os números. 
O loop do-while.
Formato:
do conteúdo while (condição);
Sua funcionalidade é exatamente a mesma que a do loop while, com exceção que a 
condição do do-while é avaliada depois da execução da conteúdo ao invés de antes, 
garantindo pelo menos uma execução do conteúdo mesmo se a condição nunca for 
satisfeita. Por exemplo, o seguinte programa repete qualquer número que você entre, até que 
você entre 0. 
// repetidor de número
#include <iostream>
using namespace std;
int main ()
{
 unsigned long n;
 do {
 cout << "Entre com um numero (0 para sair): ";
 cin >> n;
 cout << "Você entrou o numero: " << n << "\n";
Entre com um numero 
(0 para sair): 12345
Você entrou o numero: 
12345
Entre com um numero 
(0 para sair): 160277
Você entrou o numero: 
160277
Entre com um numero 
(0 para sair): 0
Você entrou o numero: 
0
 } while (n != 0);
 return 0;
}
O loop do-while geralmente é usado quando a condição que determina se chegou ao fim está 
dentro do conteúdo do loop, como no caso anterior, no qual a entrada do usuário dentro do 
bloco de instruções é o que determinar o fim do loop. Se você nunca entrar com o valor 0 no 
exemplo anterior, o loop não terminará nunca. 
O loop for.
Seu formato és:
for (inicialização; condição; incremento) conteúdo;
e sua principal função é repetir o conteúdo enquanto a condição permanecer verdadeira, 
como no loop while. Mas, além disso, o for provê lugares para especificar a instrução de 
inicialização e a instrução de incremento. Então esse loop é projetado especialmente 
para realizar uma ação repetitiva com um contador. 
Funciona da seguinte maneira:
inicialização é executada. Geralmente é a configuração de um valor inicial para um 
contador. É executado somente uma vez.
2, a condição é checada, se for true o loop continua, caso contrário o loop termina e o 
conteúdo é pulado.
3, o conteúdo é executado. Como sempre, pode ser tanto uma única instrução ou um bloco 
de instruções colocadas entre chaves { }.
4, finalmente, o que quer que seja que estiver especificado no campo de incremento, é 
executado e o loop volta ao passo 2.
Aqui está um exemplo de contagem regressiva usando o loop for. 
// ccontagem regressiva usando um loop for
#include <iostream>
using namespace std;
int main ()
{
 for (int n=10; n>0; n--) {
 cout << n << ", ";
 }
 cout << "FOGO!";
 return 0;
}
10, 9, 8, 7, 6, 5, 4, 3, 2, 
1, FOGO! 
Os campos de inicialização e de incremento são opcionais. Eles podem ser evitados, 
mas não os pontos-e-vírgulas dentre eles. 
Por exemplo, poderíamos escrever: for (;n<10;) se não quiséssemos especificar nenhuma 
inicialização nem incremento; ou for (;n<10;n++) se quiséssemos incluir um campo 
de incremento, mas não uma inicialização. 
Opcionalmente, usando uma vírgula (,), podemos especificar mais de uma instrução em 
qualquer dos campos inclusos em um loop for, como na inicialização, por exemplo. A 
vírgula (,) é um separador de instrução, e serve para separar mais de uma instrução quando 
somente uma instrução é esperada. Por exemplo, suponha que queiramos inicializar mais de 
uma variável em nosso loop: 
 
for ( n=0, i=100 ; n!=i ; n++, i-- )
{
 // qualquer coisa aqui...
}
O loop irá executar 50 vezes caso nenhuma das variáveis n ou i sejam modificadas dentro 
do loop: 
 
n começa com 0 e i com condição é (n!=i) (que n não seja igual a i). Devido ao fato de n 
ser incrementado por um e i decrementado por um, a condiçãodo loop se tornará false 
depois do 50° loop, quando ambas n e i forem iguais a 50. 
Bifurcação de controles e pulos.
A instrução break.
Usando break, podemos deixar um loop mesmo que a condição para o fim não seja 
satisfeita. Pode ser usado para terminar um loop infinito, ou forçá-lo a terminar antes de seu 
término natural. Por exemplo, iremos terminar a contagem regressiva antes que termine 
naturalmente (uma falha no mecanismo talvez): 
// exemplo de loop com break
#include <iostream>
using namespace std;
int main ()
{
 int n;
 for (n=10; n>0; n--) {
 cout << n << ", ";
 if (n==3)
10, 9, 8, 7, 6, 5, 4, 3, 
contagem regressiva 
abortada! 
 {
 cout << "contagem regressiva abortada!";
 break;
 }
 }
 return 0;
}
A instrução continue.
A instrução continue faz com que o programa ignore o resto do loop na iteração presente 
como se o final do bloco de conteúdo tivesse sido alcançado, fazendo com que vá para a 
próxima iteração. Por exemplo, iremos ignorar o número 5 em nossa contagem regressiva: 
// exemplo de loop com continue
#include <iostream>
using namespace std;
int main ()
{
 for (int n=10; n>0; n--) {
 if (n==5) continue;
 cout << n << ", ";
 }
 cout << "FOGO!";
 return 0;
}
10, 9, 8, 7, 6, 4, 3, 2, 1, FOGO! 
A instrução goto.
Permite fazer um pulo absoluto para outro ponto do programa. Você deve usar essa 
característica com cuidado há que sua execução ignora qualquer tipo de limitação de 
aninhamento. 
O ponto de destino é identificado por uma etiqueta, no qual é usado como argumento para a 
instrução goto. Uma etiqueta é feita de um identificador válido seguido por dois pontos (:). 
Essa instrução não tem uma utilidade concreta em programação estruturada ou orientada a 
objetos além das que o fãs de programação de baixo nível possam encontrar para ela. Por 
exemplo, aqui está nosso loop de contagem regressiva usando 
goto: 
// exemplo de loop com goto
#include <iostream>
using namespace std;
int main ()
{
 int n=10;
 loop:
 cout << n << ", ";
 n--;
 if (n>0) goto loop;
 cout << "FOGO!";
 return 0;
}
10, 9, 8, 7, 6, 5, 4, 3, 2, 1, FOGO! 
A função exit.
exit é uma função definida na bilioteca cstdlib (stdlib.h). 
O propósito de exit é terminar um programa em execução com um código de saída 
específico. Seu protótipo é:
void exit (int código de saída); 
O código de saída é usado por alguns sistemas operacionais e pode ser usado para 
chamar programas. Por convenção, um código de 0 significa que o programa terminou 
normalmente e qualquer outro valor significa que um erro aconteceu. 
A estrutura seletiva: switch.
A sintaxe da instrução switch é um pouco peculiar. Seu objetivo é checar diversos valores 
constantes possíveis para uma expressão, algo parecido com o que fizemos no início dessa seção 
com a junção de diversos comandos if e else if. Sua forma é a seguinte:
switch (expressão) {
 case constante1:
 bloco de instruções 1
 break;
 case constante2:
 bloco de instruções 2
 break;
 .
 .
 .
 default:
 bloco de instruções padrão
 }
Funciona da seguinte maneira: o switch avalia a expressão e checa se é equivalente à constante1, 
e se for, executa o bloco de instruções 1 até achar a palavra-chave break, então o programa irá 
pular para o fim da estrutura seletiva switch.
Se a expressão não for igual à constante1, irá checar se a expressão é equivalente à 
constante2. E se for, irá executar o bloco de instruções 2 até achar a palavra-chave break.
Finalmente, de o valor da expressão não foi equivalente à nenhuma constante especificada 
anteriormente (você pode especificar quantos comandos case como valores você quiser), o 
programa irá executar as instruções incluídas na seção default: se existir, já que é opcional. 
Ambos os fragmentos de código seguintes são equivalentes: 
Exemplo de switch if-else equivalente 
switch (x) {
 case 1:
 cout << "x e 1";
 break;
 case 2:
 cout << "x e 2";
 break;
 default:
 cout << "valor de x desconhecido";
 }
if (x == 1) {
 cout << "x e 1";
 }
else if (x == 2) {
 cout << "x e 2";
 }
else {
 cout << "valor de x desconhecido";
 }
Eu comentei anteriormente que a sintaxe da instrução switch é um pouco peculiar. Note a inclusão 
da instrução break no final de cada bloco. Isso é necessário porque se, por exemplo, não a 
incluíssemos no bloco de instruções 1, o programa não iria pular para o final do bloco seletivo 
switch (}) e continuaria executando o resto dos blocos de instruções até que a instrução break 
aparecesse pela primeira vez ou chegasse ao fim do bloco seletivo switch. Isso faz com que seja 
desnecessário incluir chaves { } em cada um dos casos, e também pode ser útil para executar o 
mesmo bloco de instruções para valores possivelmente diferentes da expressão avaliada. Por 
exemplo: 
switch (x) {
 case 1:
 case 2:
 case 3:
 cout << "x e 1, 2 ou 3";
 break;
 default:
 cout << "x nao e 1, 2 nem 3";
 }
Note que o switch só pode ser usado para comparar uma expressão com constantes diferentes. 
Sendo assim, não podemos colocar variáveis (case (n*2):) ou intervalos (case (1..3):) porque 
não são constantes válidas. 
Se precisar checar intervalos ou valores que não são constantes, use uma concatenação de 
comandos if e else if.
Básico de C++: Funções (I)
Usando funções podemos estruturar nosso programa de uma maneira mais modular, usando todo o 
potencial que a programação estruturada do C++ pode nos oferecer. 
Uma função é um bloco de instruções que é executado quando é chamada de algum outro ponto do 
programa. Seu formato é o seguinte:
tipo nome ( argumento1, argumento2, ...) conteúdo
no qual:
 · tipo é o tipo de dados que a função retorna.
 · nome é o nome pelo qual será possível chamar a função.
 · argumentos (podem ser especificados quantos você quiser). Cada argumento consiste em um 
tipo de dados seguido pelo seu identificador, como na declaração de uma variável (por exemplo, 
int x) e que funciona dentro da função como qualquer outra variável. Eles permitem a passagem 
de parâmetros para a função quando é chamada. Os parâmetros diferentes são separados por 
vírgulas.
 · conteúdo é o corpo da função. Pode ser uma única instrução ou um bloco de instruções. No 
último caso, precisa ser delimitado por chaves {}.
Aqui você tem o primeiro exemplo de função: 
// exemplo de função
#include <iostream>
using namespace std;
 
int addition (int a, int b)
{
 int r;
 r=a+b;
 return (r);
}
O resultado e 8 
 
int main ()
{
 int z;
 z = addition (5,3);
 cout << "O resultado e " << z;
 return 0;
}
Para que se possa analisar esse código, primeiro de tudo lembre-se de algo que foi dito no início 
desse tutorial: um programa em C++ sempre começa sua execução pela função main. Então 
iniciaremos por ela. 
Podemos ver como a função main começa declarando a variável z do tipo int. Logo depois disso, 
vemos uma chamada para a função addition. Se prestarmos atenção, veremos a semelhança entre 
a estrutura da chamada da função com a própria declaração da função nas linhas de código acima: 
 
Os parâmetros têm uma correspondência clara. Dentro da função main, chamamos a addition 
passando dois valores: 5 e 3 que correspondem aos parâmetros int a e int b declarados para a 
função addition. 
No momento que a função é chamada em main, o controle é perdido por main e passado para a 
função addition. O valor de ambos os parâmetros passados na chamada (5 e 3) são copiados nas 
variáveis locais int a e int b dentro da função. 
A função addition declara uma nova variável (int r;), e através da expressão r=a+b;, atribui a r 
o resultado de a maisb. Devido ao fato dos parâmetros passados para a e b serem 5 e 3 
respectivamente, o resultado é 8. 
A seguinte linha de código:
return (r);
finaliza a função addition, e devolve o controle para a função que a chamou (main) continuando o 
programa do mesmo ponto que foi interrompido pela chamada a addition. Além disso, return foi 
chamado com o conteúdo da variável r (return (r);), que naquele momento era 8, então esse foi 
o valor retornado pela função. 
 
O valor retornado por uma função é o valor dado para a função quando é avaliada. Sendo assim, z 
irá guardar o valor retornado por addition (5, 3), que é 8. Para explicar isso de outra maneira, 
você pode imaginar que a chamada para a função (addition (5,3)) é substituída literalmente pelo 
valor que retorna (8). 
A seguinte linha de código em main é:
cout << "O resultado e " << z;
que, como você já deve saber, faz a impressão do resultado na tela. 
Escopo de variáveis 
Você precisa considerar que o escopo de variáveis declaradas dentro de uma função ou qualquer 
outro bloco de instruções é somente da própria função ou do próprio bloco de instruções e não 
podem ser usadas fora deles. Por exemplo, no exemplo anterior teria sido impossível usar as 
variáveis a, b ou r diretamente na função main, pois eram variáveis locais da função addition. E 
também teria sido impossível usar a variável z diretamente dentro da função addition, pois era 
uma variável local da função main. 
 
Sendo assim, o escopo de variáveis locais é limitado ao mesmo nível de aninhamento no qual elas 
são declaradas. Mesmo assim você também pode declarar variáveis globais que são visíveis em 
qualquer parte do código, dentro ou fora de qualquer função. Para declarar variáveis globais, você 
precisa fazê-lo fora de qualquer função ou bloco de instruções, ou seja, diretamente no corpo do 
programa. 
E aqui está outro exemplo sobre funções: 
// exemplo de função
#include <iostream>
using namespace std;
 
int subtraction (int a, int b)
{
 int r;
O primeiro 
resultado e 5
O segundo 
resultado e 5
O terceiro 
resultado e 2
O quarto 
resultado e 6
 r=a-b;
 return (r);
}
 
int main ()
{
 int x=5, y=3, z;
 z = subtraction (7,2);
 cout << "O primeiro resultado e " << z << '\n';
 cout << "O segundo resultado e " << subtraction (7,2) << '\n';
 cout << "O terceiro resultado e " << subtraction (x,y) << '\n';
 z= 4 + subtraction (x,y);
 cout << "O quarto resultado e " << z << '\n';
 return 0;
}
Nesse caso nós criamos a função subtraction. A única coisa que essa função faz é subtrair ambos 
os parâmetros passados e retornar o resultado. 
Mesmo assim, se analisarmos a função main, veremos que fizemos algumas chamadas à função 
subtraction. Nós usamos alguns métodos de chamada diferentes para que você veja outra maneira 
ou momentos que uma função pode ser chamada. 
Para entender bem esses exemplos, você precisa considerar novamente que uma chamada à uma 
função poderia ser substituído perfeitamente por seu valor de retorno. Por exemplo, o primeiro caso 
(que você já deve saber porque é o mesmo padrão que usamos em exemplo anteriores):
z = subtraction (7,2);
cout << "O primeiro resultado e " << z;
Se substituirmos a chamada da função por seu resultado (que é 5), teríamos:
z = 5;
cout << "O primeiro resultado e " << z;
Assim como 
cout << "O segundo resultado e " << subtraction (7,2);
tem o mesmo resultado que a chamada anterior, mas nesse caso, fizemos a chamado à subtraction 
diretamente como um parâmetro de cout. Simplesmente imagine que escrevemos:
cout << "O Segundo resultado e " << 5;
pois 5 é o resultado de subtraction (7,2). 
No caso de cout << "O terceiro resultado e " << subtraction (x,y);
A única nova coisa que foi introduzida é que os parâmetros de subtraction são variáveis ao invés 
de constantes. Isso é perfeitamente válido. Nesse caso os valores passados para a função 
subtraction são os valores de x e y, que são 5 e 3 respectivamente, dando 2 como resultado. 
O quarto caso é quase o mesmo. Simplesmente note que ao invés de:
z = 4 + subtraction (x,y);
poderíamos ter colocado:
z = subtraction (x,y) + 4;
com exatamente o mesmo resultado. Note que o sinal de ponto-e-vírgula (;) vai ao final de toda a 
expressão. Não vai necessariamente logo após a chamada da função. A explicação pode ser mais 
uma vez que você imagina que a função pode ser substituída por seu resultado:
z = 4 + 2;
z = 2 + 4;
Funções sem tipos. O uso do void.
Se você lembra da sintaxe de uma declaração de função:
tipo nome ( argumento1, argumento2 ...) conteúdo
você verá que é obrigatório que a declaração comece com um tipo, que é o tipo de dados que será 
retornado pela função com a instrução return. Mas e se não quisermos retornar nenhum valor? 
Imagine que queiramos fazer uma função somente para exibir uma mensagem na tela. Nós não 
precisamos que retorne nenhum valor, e mais ainda, não precisamos receber nenhum parâmetro. 
Para casos assim, o tipo void foi baseado na linguagem C. Dê uma olhada: 
// exemplo de função void
#include <iostream>
using namespace std;
 
void dummyfunction (void)
{
 cout << "Eu sou uma função!";
}
 
int main ()
{
 dummyfunction ();
 return 0;
}
Eu sou uma função! 
Embora em C++ não seja necessário especificar void, seu uso é recomendado para significar que é 
uma função que é uma função sem parâmetros ou argumentos e não algo diferente. 
O que você sempre precisa saber é que o formato da chamada da função inclui a especificação do 
nome colocando os argumentos entre parênteses. A não-existência de argumentos não nos retira a 
obrigação do uso de parênteses. Por esse motivo, a chamada de dummyfunction é:
dummyfunction ();
Isso indica claramente que é uma chamada de uma função e não o nome de uma variável ou 
qualquer outra coisa.
Strings de Caracteres. 
Em todos os programas vistos até agora, nós usamos somente variáveis numéricas, usadas para 
expressar números exclusivamente. Mas além de variáveis numéricas também existem strings de 
caracteres, que nos permitem representar sucessões de caracteres, como palavras, frases, nomes, 
texto, etc. Até agora nós somente as usamos como constantes, mas nunca consideramos variáveis 
capazes de contê-las. 
Em C++ não há um tipo de variável elementar específico que guarde strings de caracteres. Para 
satisfazer essa necessidade, precisamos usar matrizes do tipo char, que são sucessões de elementos 
char. Lembre que o tipo de dados (char) é o tipo usado para guardar um único caractere, e por esse 
motivo, matrizes dele são geralmente usadas para fazer strings de caracteres únicos. 
Por exemplo, a seguinte matriz (ou string de caracteres): 
char jenny [20];
pode guardar uma string com até 20 caracteres de comprimento. Você pode imaginar isso assim: 
 
O tamanho máximo de 20 caracteres não é preciso ser sempre usado completamente. Por exemplo, 
jenny poderia guardar em algum momento do programa ou a string de caracteres "Hello" ou a 
string "Merry christmas". Sendo assim, como a matriz de caracteres pode guardar strings mais 
curtas que seu tamanho total, uma convenção foi feita para terminar o conteúdo válido de uma 
string com um caractere nulo, no qual a constante pode se escrita como 0 ou como '\0'. 
Nós poderíamos representar jenny (uma matriz de 20 elementos do tipo char) guardando as strings 
de caracteres "Hello" e "Merry Christmas" da seguinte maneira: 
 
Note como depois do conteúdo válido um caractere nulo ('\0') é incluso para que possa indica o 
final da string. Os painéis em cor cinza representam valores indeterminados. 
Inicialização de strings
Devido ao fato de as strings de caracteres serem matrizes ordinárias, elas possuem todas as mesmas 
regras. Por exemplo, se quisermos inicializar uma string de caracteres com valores pré-determinados, podemos fazer simplesmente como qualquer outra matriz: 
char mystring[] = { 'H', 'e', 'l', 'l', 'o', '\0' }; 
Nesse caso, nós declaramos uma string de caracteres (matriz) com 6 elementos do tipo char 
inicializada com os caracteres que compõem Hello mais um caractere nulo '\0'. 
De qualquer maneira, strings de caracteres possuem uma maneira adicional para inicializar seus 
valores: usando strings constantes. 
Nas expressões que usamos em exemplos nos capítulos anteriores, constantes que representam 
strings de caracteres inteiras já apareceram algumas vezes. Essas constantes são especificadas entre 
aspas duplas ("), por exemplo:
"o resultado e: "
é uma string constante que provavelmente já usamos em alguma ocasião. 
Diferentemente de aspas simples (') que especificam constantes com um único caractere, as aspas 
duplas (") são constantes que especificam uma sucessão de caracteres. Strings colocadas entre aspas 
duplas possuem sempre um caractere nulo ('\0') que é colocado automaticamente no final. 
Sendo assim, poderíamos inicializar a string mystring com valores de qualquer uma dessas 
maneiras: 
char mystring [] = { 'H', 'e', 'l', 'l', 'o', '\0' };
char mystring [] = "Hello"; 
Em ambos os casos, a matriz ou string de caracteres mystring é declarada com um tamanho de 6 
caracteres (elementos do tipo char): os 5 caracteres que compõem Hello mais um caractere nulo no 
final ('\0') que especifica o fim da string e que, no segundo caso, ao usar aspas duplas (") é 
colocado automaticamente. 
Antes de continuarmos, note que a atribuição de constantes múltiplas como constantes com aspas 
duplas (") para matrizes somente é válida na inicialização da matriz, que é no momento em que é 
declarada. Expressões dentro do código como:
mystring = "Hello";
mystring[] = "Hello"; 
não são válidas para matrizes, como também não seria válido:
mystring = { 'H', 'e', 'l', 'l', 'o', '\0' };
Então lembre-se: Podemos "atribuir" uma constante múltipla para uma matriz somente no momento 
de sua inicialização. A razão disso será mais compreensível quando você souber um pouco mais 
sobre ponteiros, pois será explicado que uma matriz é simplesmente um ponteiro constante 
apontando para um bloco de memória alocado. E devido ao fato de ser constante, a matriz não pode 
se atribuir qualquer valor, mas podemos atribuir valores para cada um dos elementos da matriz. 
O momento de inicialização de uma matriz é um caso especial, pois não é uma atribuição, embora o 
mesmo sinal de igual (=) seja usado. De qualquer maneira, tenha sempre presente a regra sublinhada 
anteriormente. 
Atribuindo valores para strings
Como o lvalue de uma atribuição só pode um elemento de uma matriz e não a matriz inteira, seria 
válido atribuir uma string de caracteres para uma matriz de char usando um método como esse:
mystring[0] = 'H';
mystring[1] = 'e';
mystring[2] = 'l';
mystring[3] = 'l';
mystring[4] = 'o';
mystring[5] = '\0';
Mas como você pode imaginar, esse não parece ser um método muito prático. Em geral, para 
atribuir valores para uma matriz, e mais especificamente para uma string de caracteres, uma série de 
funções como strcpy são usadas. strcpy (string copy – cópia de string) é definida na biblioteca 
cstring (string.h) e pode ser chamada da seguinte maneira:
strcpy (string1, string2);
Isso copia o conteúdo da string2 para a string1. string2 pode ser tanto uma matriz, um 
ponteiro, ou uma string constante, então a seguinte linha seria uma maneira válida de se atribuir 
uma string constante "Hello" para mystring:
strcpy (mystring, "Hello");
Por exemplo: 
// atribuindo valor a string
#include <iostream>
#include <string.h>
using namespace std;
 
int main ()
{
 char szMyName [20];
 strcpy (szMyName,"J. Soulie");
 cout << szMyName;
 return 0;
}
J. Soulie 
Note que precisamos incluir o cabeçalho <string.h> para podermos usar a função strcpy. 
Mesmo assim, sempre podemos escrever uma simples função como a seguinte setstring com a 
mesma operação que a strcpy de cstring:
// setting value to string
#include <iostream>
using namespace std;
 
void setstring (char szOut [], char szIn [])
{
 int n=0;
 do {
 szOut[n] = szIn[n];
 } while (szIn[n++] != '\0');
}
 
int main ()
{
 char szMyName [20];
 setstring (szMyName,"J. Soulie");
 cout << szMyName;
 return 0;
}
J. Soulie 
Outro método usado frequentemente para atribuir valores a matrizes é usar o comando de entrada 
(cin) diretamente. Nesse caso, o valor da string é atribuído pelo usuário durante a execução do 
programa. 
Quando o cin é usado com strings de caracteres, geralmente é usado com seu método getline, que 
pode ser chamado de acordo com esse protótipo: 
cin.getline ( char buffer[], int tamanho, char delimitador = ' \n'); 
no qual buffer é o endereço de onde guardar a entrada (como uma matriz, por exemplo), tamanho 
é o tamanho máximo do buffer (o tamanho da matriz) e delimitador é o caractere usado para 
determinar o final da entrada do usuário, que por padrão – se não incluírmos esse parâmetro – será o 
caractere de nova linha ('\n'). 
O seguinte exemplo repete qualquer coisa que você digite em seu teclado. É simples, mas serve 
como um exemplo de como você pode usar cin.getline com strings: 
// cin com strings
#include <iostream>
using namespace std;
 
int main ()
{
 char mybuffer [100];
 cout << "Qual o seu nome? ";
 cin.getline (mybuffer,100);
 cout << "Ola " << mybuffer << ".\n";
 cout << "Qual o seu time favorito? ";
 cin.getline (mybuffer,100);
 cout << "Eu gosto do " << mybuffer << " também.\n";
 return 0;
}
Qual o seu nome? Juan
Ola Juan.
Qual o seu time favorito? 
Inter Milan
Eu gosto do Inter Milan 
também. 
Note como em ambas as chamadas a cin.getline nós usamos o mesmo identificador de string 
(mybuffer). O que o programa faz na segunda chamada é simplesmente sobrescrever o conteúdo 
prévio de buffer com o nome que é introduzido. 
Se você se lembrar da seção sobre comunicação pelo console, você se lembrará que usamos o 
operador de extração (>>) para receber dados diretamente da entrada padrão. Esse método também 
pode ser usado ao invés de cin.getline com strings de caracteres. Por exemplo, em nosso 
programa, quando requisitamos uma entrada de usuário, poderíamos ter escrito: 
cin >> mybuffer;
isso funcionaria, mas esse método tem as seguintes limitações que o cin.getline não tem: 
 Só pode receber palavras únicas (sem frases completas) pois esse método usa como 
delimitador qualquer ocorrência de caractere vazio, incluindo espaços, tabulações, novas 
linhas e retornos de carro. 
Não é permitido especificar um tamanho para o buffer. Isso deixa seu programa instável em 
caso da entrada do usuário ser maior que a matriz que irá guardá-la. 
Por essas razões, é recomendado que sempre que você requerer strings de caracteres vindos de cin, 
você use cin.getline ao invés de cin >>. 
Converção de strings para outros tipos
Devido ao fato de uma string poder conter representações de outros tipos de dados como números, 
pode ser útil traduzir o conteúdo para uma variável de tipo numérico. Por exemplo, uma string pode 
conter "1977", mas essa é uma sequência de 5 caracteres que não são convertidos facilmente para 
um único tipo de dado inteiro. A biblioteca cstdlib (stdlib.h) provê três funções úteis para isso: 
 atoi: converte string para o tipo int. 
 atol: converte string para o tipo long. 
 atof: converte string para o tipo float. 
Todas essas funções admitem um parâmetro e retornam um valor do tipo requisitado (int, long ou 
float). Essas funções combinadas com o método getline de cin são uma maneira mais confiável 
de pegar a entrada do usuário ao requisitar um número que o clássico método cin>> : 
// cin and ato* functions#include <iostream>
#include <stdlib.h>
using namespace std;
 
int main ()
{
 char mybuffer [100];
 float price;
 int quantity;
 cout << "Entre com o preco: ";
 cin.getline (mybuffer,100);
 price = atof (mybuffer);
 cout << "Entre com a quantidade: ";
 cin.getline (mybuffer,100);
 quantity = atoi (mybuffer);
 cout << "Preco total: " << price*quantity;
 return 0;
}
Entre com o preco: 2.75
Entre com a quantidade: 21
Preco total: 57.75 
Funções para manipular strings
A biblioteca cstring (string.h) define muitas funções para manipular operações com strings tipo-
C (como a strcpy que já foi explicada). Aqui você tem uma breve descrição das mais usuais: 
strcat: char* strcat (char* dest, const char* src); 
Adiciona a string src no final da string dest. Retorna dest. 
strcmp: int strcmp (const char* string1, const char* string2); 
Compara as strings string1 e string2. Retorna 0 se ambas as strings forem iguais. 
strcpy: char* strcpy (char* dest, const char* src); 
Copia o conteúdo de src para dest. Retorna dest. 
strlen: size_t strlen (const char* string); 
Retorna o tamanho da string. 
NOTA: char* é o mesmo que char[] 
Matrizes 
Matriz é uma série de elementos (variáveis) do mesmo tipo alocadas consecutivamente na memória 
que podem ser referenciados individualmente adicionando-se um índice a um nome único. 
Isso significa que, por exemplo, podemos guardar 5 valores do tipo int sem ter que declarar 5 
variáveis diferentes cada uma com um identificado diferente. Ao invés disso, usando uma matriz, 
podemos guardar cinco valores diferentes do mesmo tipo, int, por exemplo, com um identificador 
único. 
Por exemplo, uma matriz que contém 5 valores inteiros do tipo int chamada billy poderia ser 
representada dessa maneira:
 
onde cada painel em branco representa um elemento da matriz, que nessa caso são valores inteiros 
do tipo int. Esses são numerados de 0 até 4, pois em matrizes o primeiro índice é sempre 0, 
independentemente de seu tamanho. 
Como qualquer outra variável, uma matriz precisa ser declarada antes de ser usada. Uma declaração 
típica de uma matriz em C++ é:
tipo nome [elementos];
onde tipo é um tipo de objeto válido (int, float...), nome é um identificador de variável válido e o 
campo elementos, que está entre colchetes [], especifica quantos desses elementos a matriz 
contém. 
Sendo assim, para declarar billy como mostrado acima, é tão simples quanto o comando a seguir:
int billy [5]; 
NOTA: O campo elementos dentro de colchetes [] ao declarar uma matriz precisa ser um valor 
constante, pois matrizes são blocos de memória estática de um dado tamanho e o compilador 
precisa ser capaz de determinar exatamente quanta memória precisa atribuir para a matriz antes que 
qualquer instrução seja considerada. 
Inicialização de matrizes.
Ao declarar uma matriz de escopo local (dentro de uma função), se não especificarmos nada, não 
será inicializada, então seu conteúdo será indeterminado até que guardemos alguns valores nela. 
Se declararmos uma matriz global (fora de qualquer função) seu conteúdo será inicializado com 
todos seus elementos preenchidos com zeros. Assim, se declararmos em um escopo global:
int billy [5];
todos os elementos de billy serão preenchidos inicialmente com 0. 
Mas, além disso, quando declaramos uma matriz, temos a possibilidade de atribuir valores iniciais 
para cada um de seus elementos usando chaves { }. Por exemplo:
int billy [5] = { 16, 2, 77, 40, 12071 }; 
essa declaração teria criado uma matriz como a seguinte: 
 
O número de elementos em uma matriz que inicializamos dentro das chaves { } precisa estar de 
acordo com o tamanho de elementos que declaramos para a matriz dentro dos colchetes [ ]. Por 
exemplo, no exemplo da matriz billy, nós declaramos que tinha 5 elementos e na lista de valores 
iniciais dentro das chaves { } nós preenchemos com 5 valores diferentes, um para cada elemento. 
Devido ao fato disso ser considerado uma repetição inútil, o C++ inclui a possibilidade de deixar os 
colchetes vazios [ ] e o tamanho da matriz será definido pelo número de valores inclusos entre 
chaves { }:
int billy [] = { 16, 2, 77, 40, 12071 };
Acesso aos valores de uma Matriz.
Em qualquer parte do programa no qual a matriz é visível, podemos acessar qualquer de seus 
valores individualmente para leitura ou modificação como se fosse uma variável normal. O formato 
é o seguinte: 
nome[índice]
De acordo com os exemplos anteriores no qual billy tinha 5 elementos e cada um desses elementos 
eram do tipo int, os nomes que podemos usar para nos referenciar a cada elemento são os 
seguintes: 
 
Por exemplo, para guardar o valor 75 no terceiro elemento de billy, um comando aceitável seria 
esse:
billy[2] = 75;
e, por exemplo, para passar o valor do terceiro elemento de billy para uma variável a, poderíamos 
digitar: 
a = billy[2];
Sendo assim, para todos os propósitos, a expressão billy[2] é como qualquer outra variável de 
tipo int. 
Note que o terceiro elemento de billy é especificado como billy[2], pois o primeiro elemento é 
billy[0], o segundo é billy[1], e sendo assim, o terceiro é billy[2]. Pela mesma razão, seu 
último elemento é billy[4]. Pois se escrevêssemos billy[5], estaríamos nos referenciando ao 
sexto elemento de billy e então excedendo o tamanho da matriz. 
Em C++ é perfeitamente válido exceder o limite válido de índices para uma matriz, o que pode 
causar problemas pois eles não causam erros de compilação, mas podem causar resultados 
inesperados ou erros sérios durante a execução. A razão pela qual isso é permitido será vista mais a 
frente quando começarmos a usar ponteiros. 
Até aqui é importante ser capaz de distinguir claramente entre os dois usos que os colchetes [ ] 
tem relacionados às matrizes. Eles desempenham duas tarefas diferentes: uma é configurar o 
tamanho das matrizes ao declará-las; e a segunda é especificar índices para um elemento concreto 
da matriz ao se referenciar a ele. Precisamos simplesmente tomar cuidado para não confundir esses 
dois possíveis usos de colchetes [ ] com matrizes: 
 
int billy[5]; // declaração de uma nova matriz (começa com um 
tipo nome)
billy[2] = 75; // acesso a um elemento da matriz.
Outros operadores válidos com matrizes:
billy[0] = a;
billy[a] = 75;
b = billy [a+2];
billy[billy[a]] = billy[2] + 5;
// exemplo de matrizes
#include <iostream>
using namespace std;
 
int billy [] = {16, 2, 77, 40, 12071};
int n, result=0;
 
int main ()
{
 for ( n=0 ; n<5 ; n++ )
 {
 result += billy[n];
 }
 cout << result;
 return 0;
}
12206 
Matrizes multidimensionais
Matrizes multidimensionais podem ser descritas como matrizes de matrizes. Por exemplo, uma 
matriz bidimensional pode ser imaginada como uma tabela bidimensional de um tipo de dados 
concreto uniforme:
 
jimmy representa uma matriz bidimensional de 3 por 5 valores do tipo int. O maneira de se 
declarar essa matriz seria: 
int jimmy [3][5];
e, por exemplo, a maneira de referenciar o segundo elemento verticalmente e o quarto 
horizontalmente em uma expressão seria: 
jimmy[1][3]
 
(lembre-se que índices de matriz sempre começam por 0). 
Matrizes multidimensionais não são limitadas a dois índices (duas dimensões). Elas podem conter 
quantos índices forem necessários, embora seja raro ter que representar mais que 3 dimensões. 
Apenas considere a quantidade de memória que uma matriz com muitos índices pode precisar. Por 
exemplo:
char century [100][365][24][60][60];
atribui um char para cada segundo contido em um século, que é mais que 3 bilhões de chars! Isso 
consumiria algo em torno de 3000 megabytes de memória RAM se pudéssemos declarar. 
Matrizes multidimensionais não são nada mais que uma abstração, pois que podemos