apêndice D

Palavras Reservadas ISO/ANSI C++

1
2   Programação em C++: Algoritmos, estruturas de dados e objetos

asm
Utiliza-se para incluir diretamente código montador em seu programa C++. O uso correto de asm depende da im-
plementação.

Sintaxe
asm <instrução em montador>;
asm <instrução –1>; asm <instrução-2>;...
asm {
seqüência de instruções em montador
}

Exemplos
asm push ds;
asm {
pop ax
inc ax
push ax
}

auto
É um especificador de armazenamento de classes para variáveis temporárias. Essas variáveis são criadas ao intro-
duzir-se em um bloco de sentenças e se destroem ao sair dele. As variáveis locais de uma função têm classe de
armazenamento auto por default (omissão).

bool
Tipo lógico (boolean) que toma valores verdadeiro (true) ou falso (false) que podem conter os literais true ou false.
Substitui o sistema tradicional de C que considera o valor zero como falso e diferente de zero como verdadeiro.

break
break permite sair do laço do, while ou for mais interno. Também pode-se usar para sair de uma sentença switch.
Um exemplo de break em um laço é:
while (Z < 10) {
cin >> Z;
if (Z < 0) break; // sair se Z for negativo
cout << “Olá mundo, eu continuo”;
}

case
Serve para etiquetar os diferentes casos da sentença switch.

Sintaxe
case <valor> : < sentença>;
...
break;

Exemplo
switch(número)
{
case 2 + 5: cout << ”É 7”;
break;
case 9 : cout << “É 9”;
break;
default : cout << “N: 7 nem 9”;
}
 Palavras Reservadas ISO/ANSI C++   3

catch
Utiliza-se como mecanismo de tratamento de exceções. Sua finalidade é interceptar uma exceção gerada pelo
throw. Dado seu caráter experimental, não está implementada em alguns compiladores.

Sintaxe
catch (<exceção> {
// código que manipula exceções
}

cdecl
A palavra reservada cdecl não faz parte do C++ padrão. Força o compilador a compilar uma função de modo que
a passagem de parâmetro siga a notação-padrão do C. Costuma-se encontrar compiladores que permitem a espe-
cificação de notações de Pascal. Utiliza-se quando se está compilando um arquivo completo usando a opção Pas-
cal e quando se deseja que uma função específica seja compatível com C/C++.

extern cdect printf();

void ponernums (int i, int j, int k);
cdecl main()
{
ponernums (1, 5, 9);
}
void ponernums (int i, int j, int k)
{
printf (“e as respostas são: %d, %d, %d ´n”, i, j, k);
}

char
Tipo de dado incorporado em C++. Pode-se utilizar char para declarar variáveis caractere (tem um intervalo de 0
a 255 em código ASCII).

class
Palavra que representa a definição de uma classe. Uma classe contém variáveis membros dados e funções-membro
que operam sobre essas variáveis; do mesmo modo, uma classe tem um conjunto de especificadores que controlam
o acesso dos membros da classe (private, public e protected)

Sintaxe
class nome_classe: (especificadores de acesso) classe_base
{
// membros privados por default
protected:
// membros privados podem ser herdados
public:
// membros públicos
} [lista de objetos];
nome_classe classe_1, classe_2,...;

Se não se estipula nenhum especificador de acesso, o acesso por omissão (por default) é private. A lis-
ta_de_objetos é opcional, de modo que, se não for especificada, a declaração de uma classe não cria objetos
dessa classe e é preciso definir o objeto como se se criasse determinada variável.

const
É um qualificador do tipo utilizado para indicar que a variável que lhe segue não pode ser modificada pelo pro-
grama. Isso significa que não se pode atribuir um valor a essa variável, incrementá-la ou decrementá-la; contudo,
pode-se inicializar com um valor dado, quando é declarada.
4   Programação em C++: Algoritmos, estruturas de dados e objetos

Sintaxe
const <nome> = <valor>;

Exemplo
const int idade = 46;
const in *p = 3025;

const_cast
O operador const_cast<T>(e) permite acessar um objeto com o atributo const ou volatile anexado.
O tipo T deve ser do mesmo tipo que o operando e, exceto para os modificadores const e volatile e o
resultado retornado por const_cast() é o mesmo que e, mas do tipo T.

void func (char* cp)

{}
func(const_cast <char*>(vc));

continue
Utiliza-se continue na execução de um laço. É equivalente a executar uma sentença goto no final do laço. Essa
sentença afeta o laço mais internamente do qual parece.

Sintaxe
continue;

Exemplo
for (j = 0, j < 100; j++)
{
if (j == 10) continue;
soma += j;
}

default
Utiliza-se na sentença switch para marcar o código que vai ser executado quando nenhuma das etiquetas de case
corresponde à expressão switch.

Sintaxe
default:<sentença>;...

delete
O operador de atribuição dinâmica delete utiliza-se para liberar a memória apontada pelo seu argumento
(atribuída usando new)

Sintaxe
delete <ponteiro>;
delete <[elementos]> <expressão de conversão de tipo>

Exemplo
delete objeto_prova;
delete[100] indicadores; // apaga cada um dos 100 elementos
// indicadores

do
Utiliza-se um while para construir laços iterativos nos quais as instruções do corpo do laço são executadas até
que a condição seja 0 (falso).
 Palavras Reservadas ISO/ANSI C++   5

Sintaxe
do {
<sentenças>
} while (condição);

Como a condição é avaliada no final do laço, as sentenças são executadas pelo menos uma vez.

Exemplo
do {
soma += j;
j++;
} while (j <= 100);

double
Especificador do tipo de dado double que declara variáveis e arrays de ponto flutuante de dupla precisão.

Sintaxe
double <nome_ variável>;

dynamic_cast
Pode-se utilizar esse operador para moldar (converter explicitamente) um ponteiro ou um tipo referência.

Sintaxe
dynamic_cast <T*>(p)
void vp = dynamic_cast <void*> (bp);

else
Utiliza-se com if para controlar o fluxo de execução com sentenças if cuja sintaxe é:

if (expressão) sentença_1; else sentença_2;

onde sentença_1 é executada, se expressão for diferente de 0 (verdadeiro), e sentença_2 é executada,

se expressão for igual a 0 (falso).

enum
Tipo de dados de valor inteiro que pode tomar seus valores de uma lista de constantes enumeradas.

explicit
Declara um construtor explícito.

Exemplo
class Ponto
{
private:
double x, y, z;
public:
Ponto() : x(0.0), y(0.0), z(0.0) {}
explicit Ponto ( double d) // construtor explícito
: x(d), y(d), z(d) {}
// ...
};
6   Programação em C++: Algoritmos, estruturas de dados e objetos

extern
Especificador de classe de armazenamento usado para indicar ao compilador que uma variável é declarada em
outra parte do programa. Se uma declaração de variável começa com a palavra reservada extern não é uma de-
finição, isto é, especifica o tipo e nome da variável e implica que uma definição dessa variável se encontra em
outra parte do programa. Sem essa palavra reservada, é uma definição; cada definição de variável é, ao mesmo
tempo, declaração de variável.

extern int n; // declaração de n (não definição)

Costuma-se utilizar esse especificador separadamente em arquivos compilados que compartilham os mesmos
dados globais e se enlaçam juntos. Assim, por exemplo, se test é declarado em outro arquivo, como inteiro, a
declaração seguinte será utilizada em outros arquivos:

extern int test;

Não use extern com freqüência. Existem outros métodos para passar informação entre funções. Em geral,
use extern só para referir-se a variáveis globais que são definidas em outra parte. Pelo fato de que essa caracte-
rística cria espaço permanente para as variáveis, a maioria das variáveis locais não é extern.

extern “c”
O prefixo extern “C” permite que um programa C++ possa chamar expressamente a uma função C. Se declara-
se uma função externa, um compilador C++ suporá que é uma função C e não produzirá erros de compilação.
A solução é especificar o enlace como “C” quando se declara a função:

// função C
extern “C” void Mensagem(void)

Se existem diferentes funções pode-se declarar em uma única declaração entre chaves:

extern “C” {
void Mensagem(void);
void Pronto(void);
}

Essas definições serão agrupadas em um arquivo de cabeçalho, mas não poderão ser declaradas em outra parte
dentro do arquivo de cabeçalho com enlace “C”.

extern “C” {
// cabeçalhos de bibliotecas C
#include “desenhar.h”
#include “impressora.h”
}

false
Literal boolean de valor zero.

Exemplo
bool b1;
bool b2 = false;
bool b3 (true);
int i1 = true
bool function()
{
// ...
}
 Palavras Reservadas ISO/ANSI C++   7

far
O modificador de tipos far não é parte do C++ padrão. É empregado por compiladores projetados para utilizar
na família de processadores 8086, que forçam uma variável ponteiro a usar um direcionamento de 32 bits no lugar
de 16 bits.

float
float é um especificador de tipos de dados usados para declarar variáveis de ponto flutuante.

for
O laço for permite inicializar e incrementar variáveis contadores.

Sintaxe
for (inicialização; condição; incremento) {
< sentenças>
}

Se o bloco de sentenças só contém uma, não são necessárias as chaves ({,}). Se a condição for falsa, ao co-
meçar o laço, este não se executará nenhuma vez.
Pode-se omitir qualquer das três expressões de for, mas devem ser deixados os ponto-e-vírgulas (;). Caso
omita condição, esta se considerará a verdadeira.
O laço infinito é for (;;) e equivale a while(1).
Pode-se utilizar o operador vírgula (,) para colocar várias expressões no interior das diferentes partes de for.

Exemplo
for(i = 0, j = n-1; i < n; i++, j--)
a[i] = a[j];

friend
A palavra reservada friend é utilizada para garantir o acesso a uma parte privada (private) de uma classe, por
uma função que não é membro dela e às partes protegidas (protected) de uma classe da qual não se derivam.
As funções amigas podem ser amigas de mais de uma classe.

Exemplo
class Pessoa {
// ...
public:
// ...
friend void funçamiga(int x, float y);
};

goto
É produzido um salto na execução do programa a uma etiqueta da função atual. Seu uso não é recomendado,
exceto em situações excepcionais, tais como a saída direta do laço mais interno pertencente a uma série de
laços agrupados.

Sintaxe
goto <etiqueta>;
...
etiqueta:

huge
O modificador de tipos huge não faz parte de C++ padrão. Utiliza-se em compiladores construídos com base na
família de microprocessadores 8086. Borland/Turbo C++ normalmente limitam o tamanho de todos os dados está-
ticos a 64 k; o modelo de memória huge transborda esse limite, permitindo que os dados ocupem mais de 64 k.
8   Programação em C++: Algoritmos, estruturas de dados e objetos

if

A palavra reservada if só é utilizada para executar código em certas condições. Pode-se utilizar if sozinha ou
com else. Se há somente uma sentença, não é preciso as chaves.

Sintaxe
if (condição) if (condição) {
< sentença;...> <sentenças1>
else }
< sentença_esp;...> else {
sentenças2>
}

Se a condição (expressão) for avaliada a qualquer valor distinto de 0, então serão executadas sentenças_1
e, se não, serão executadas sentenças_2.

Exemplo
if(a==x) if(x > 1)
aux = 3; if(y == 2)
aux = 5; z == 5;

if(x > 1) {
if(y == 2)
z == 5;
} else
z = 10;

inline

O especificador inline instrui o compilador para substituir as chamadas a funções com o código do corpo da
função. Essa substituição é denominada expansão em linha. O uso das funções em linha incrementa o tamanho
do programa objeto, mas pode aumentar a velocidade de execução, eliminando-se as operações auxiliares impli-
cadas em chamadas a funções. As funções inline são similares às macros, ainda que uma função inline seja
muito mais segura.

Sintaxe
1. Função em linha autônoma:
inline <tipo> <nome_função> (<arg1>,...) {definição função;}

2. Função em linha definida de uma classe:

<tipo> <nome_função> {definição função;}

Existem dois métodos para utilizar funções em linha:

1.  Declarar uma função independente precedendo à declaração com a palavra reservada inline. Deve-se declarar
e definir antes de se fazer qualquer chamada a função.
2.  Declarar uma função-membro de uma classe como implicitamente em linha.

Exemplo
inline double Conta::Balance()
{
return positivo;
}
inline int triple(int Z) {return Z * 3;}
 Palavras Reservadas ISO/ANSI C++   9

int
Especificador de tipo para variáveis e arrays de inteiros. Os qualificadores short e long podem ser utilizados
para declarar um inteiro do tamanho desejado.

Sintaxe
int <nome_variável>;

Exemplo
int j, x[100];

interrupt
Palavra reservada que não se encontra no C++ padrão. Essa palavra significa que uma rotina (função) de inter-
rupção do sistema pode ser utilizada como administrador de interrupções.

long
Especificador do tipo de dados para declarar variáveis inteiros, que ocupa duas vezes mais bytes que os inteiros
do tipo short.

mutable

Permite que um membro de um objeto anule uma constante (const); ou seja, possibilita que os membros dado de
variáveis de classe que foram declarados constantes permaneçam modificáveis.

class pessoa {
public
pessoa(const char* pnome, int pag, unsigned long noss);
void dinam() {++idade;}
...
private:
const char * nome;
mutable int idade; // modificável sempre
...
};
...
const pessoa prova (“Carchelejo”, 45, 1110111);
...
prova.diam(); // correto prova.idade é mutável

namespace

Define um escopo (intervalo).

namespace []Acarc {
class mus {...};
class poker {...};
...
}

near

O modificador near não está definido em C++ padrão. Utiliza-se em compiladores baseados na família de micro-
processadores 8086 que permitem utilizar direcionamentos de 16 bits em vez de 32 bits.

new

O operador new aloca memória dinâmica e devolve um ponteiro do tipo apropriado ao mesmo.
10   Programação em C++: Algoritmos, estruturas de dados e objetos

Sintaxe
var_p = new tipo;

var_p é uma variável ponteiro que receberá a descrição da memória alocada e tipo é o tipo de dado que a me-
mória contém. O operador new aloca automaticamente memória para conter um elemento de dados do tipo espe-
cificado. Se a atribuição solicitada falha, new devolve um ponteiro nulo.

Exemplo
double * q; // aloca memória suficiente para conter
q = new double; // um double

var_p = new tipo(inicializador);

Se inicializa a memória alocada especificando um inicializador (valor atribuído).

var_p = new tipo[tamanho];

Atribui um array de uma dimensão.

var_p = new tipo[tamanho1][tamanho2]...

Atribui arrays multidimensionais.

operator

Em C++, pode-se sobrecarregar as funções e os operadores. A palavra reservada operator é utilizada para criar
funções de operadores sobrecarregados. Pode-se sobrecarregar os operadores com relação a uma classe.

Sintaxe
nome_classe::operator opr(lista_parâmetros)

A lista de parâmetros contém um parâmetro quando se sobrecarrega um operador unitário, e dois parâmetros
quando se sobrecarrega um operador binário (nesse caso, o operando da esquerda se detém no primeiro parâmetro,
e o operando da direita se detém no segundo parâmetro). Por exemplo, uma classe string pode definir o operador
== como se segue:

class string
{
public:
// ...
int operator == (const string & s) const;
// ...
};

pascal

Essa palavra reservada não está definida em C++ padrão. O modificador pascal é específico para Turbo/Borland
C++; está concebido para funções (e ponteiros a funções) que utilizam a seqüência de passagem de parâmetros
Pascal. As funções declaradas do tipo pascal podem ser chamadas de rotinas C, sempre que a rotina C veja que
essa função é do tipo pascal.

private

O especificador de acesso private é utilizado para declarar elementos privados de uma classe; esses membros
não são acessíveis a nenhuma função diferente das funções-membro dessa classe.
 Palavras Reservadas ISO/ANSI C++   11

Sintaxe
class nome {
// ...
private:
// ... membros privados
};

Os membros de uma classe são privados por default.

class consumidor {
char nome[30], // privado por omissão
rua[40],
cidade[20],
estado[30];
public:
void ver_dados(void);
void ler_dados(void);
private:
int idade, salário; // também são privados
};

Em declaração de classes derivadas também se utiliza private class tipo_classe_derivada:public

|private|protected... tipo_classe_base{...}
Nesse caso, private faz que todos os membros públicos e protegidos da classe base se tornem membros
privados da classe derivada, e todos os membros da classe base privados permanecem nela.

protected
O especificador de acesso protected marca o começo dos membros da classe aos quais somente é possível ser
acessada pelos próprios membros da classe e pelas funções-membro de todas as classes derivadas.
Sintaxe
class nome {
// ...
protected:
// membros protegidos (só disponíveis em classes derivadas)
};

Exemplo
class dados_act {
char nome[40]
...
protected:
long num_ss;
...
}; // num_ss é protegido
class dados_novos:protected dados_act {
...
}; // dados_novos pode acessar a num_ss

public
O especificador de acesso public especifica aqueles membros que são acessíveis publicamente, qualquer função
pode acessar esses membros.
Sintaxe
class <nome_classe> {
...
public:
//membros públicos, disponíveis para todas as funções
//interiores ou exteriores à classe
};
12   Programação em C++: Algoritmos, estruturas de dados e objetos

Quando se inclui o especificador public em uma classe derivada, todos os membros públicos da classe-base
se convertem em membros públicos da classe derivada, e todos os membros protegidos da classe-base se con­
vertem em membros protegidos da classe derivada. Em todos os casos, os membros privados da classe-base per-
manecem privados, isto é, não são herdados.

register

register é um especificador de armazenamento para tipos de dados inteiros, utilizados para informar ao compi-
lador que o acesso aos dados deve ser tão rápido quanto possível. O compilador armazenará os dados inteiros em
um registro da CPU, em vez de situá-los na memória.

Sintaxe
register <tipo> <nome_variável>

Exemplo
register int j;

reinterpret_cast

O operador reinterpret_cast<T>(e) permite ao programador executar conversões explícitas de tipos que são
geralmente inseguros e dependentes da implementação.

Derivadax dp1 = reinterpret_cast <Derivada*> (ip);

return

Utiliza-se a sentença return para deter a execução da função atual e devolver o controle ao chamador. Se a fun-
ção devolve um valor utiliza uma sentença

return expressão;

para devolver o valor representado pela expressão.

Exemplo
int máx(int a, int b)
{
if(a >= b)
return a;
else
return b;
}

short

short é um qualificador de tamanho para variáveis inteiras com e sem sinal; ocupa pelo menos dois bytes, short
significa na realidade signed short int.

signed

O modificador de tipo signed é utilizado para indicar que os dados armazenados em um tipo inteiro (int ou char
têm sinal). Os valores int, long e short, por omissão, têm sinal.

Exemplo
signed char; // pode ter valores de –127 a +127
unsigned char; // pode ter valores de 0 a 255
 Palavras Reservadas ISO/ANSI C++   13

sizeof

O operador sizeof determina o número de bytes utilizados para armazenar uma variável particular ou tipo de
dados. Assim, quando se aplica a uma variável, sizeof devolve o tamanho do objeto referenciado e quando se
aplica a uma classe, sizeof devolve o tamanho total de um objeto dessa classe.

int j;
comprimento = sizeof(int); // valor 2
cout << sizeof j; // visualiza 2

static

static é um modificador de tipo de dados que instrui o compilador para criar armazenamento permanente para
a variável local que a precede. Se se declara uma variável do tipo static, terá armazenamento permanente
e retém seu valor ao longo de toda a vida do programa (e, por conseguinte, entre chamadas a funções). static é
também utilizada para ocultar dados e funções de outros módulos ou arquivos.

Sintaxe
static <tipo> <nome_variável>

Exemplo
static int indice = 0;

static_cast

A sintaxe do operador static_cast <>() é:

static_cast <T>(e)

onde T pode ser um tipo definido pelo usuário ou integral, ponteiro, referência ou enum. Só faz verificações de
tipo estático.

struct

Utiliza-se a palavra reservada struct para representar o tipo de dados estrutura que reagrupa variáveis e/ou fun-
ções. Em C++, uma estrutura tem sintaxe idêntica a uma classe, com a única diferença que, no acesso por default,
os membros de uma estrutura têm acesso público; enquanto o acesso por default de uma classe é privado.

Sintaxe
struct nome_estrutura {
// membros públicos por default
especificador_de_acesso_1:
tipo elemento1;
tipo elemento2;
...
especificador_de_acesso_2:
tipo elemento3;
tipo elemento4;
...
};
nome_estrutura estruct_1, estruct_2;

struct funcionário {
int id;
char nome[40];
void ler_infor(int i, char *n);
}
funcionário e; // declara objeto funcionário e
14   Programação em C++: Algoritmos, estruturas de dados e objetos

switch

Utiliza-se a sentença switch para realizar uma bifurcação múltipla, dependendo do valor de uma expressão.

Sintaxe
switch (expressão)
{
case <valor> : sentença;...
...
default : sentença;...
};

Deve-se utilizar break para separar o código de uma etiqueta de case de outra. Uma etiqueta default mar-
ca o código que será executado se nenhuma das etiquetas de case corresponder ao valor da expressão.

Exemplo
switch(x) {
case ´A´:
cout << “caso A\n”;
break;
case ´B´:
case ´C´:
cout << “caso C\n”;
break;
default:
cout << “fim\n”;
break;
};

template (modelo)

A palavra reservada template (modelo) é utilizada para criar funções e classes genéricas. Naqueles compila-
dores em que template (modelo) é implementado, uma forma geral de modelo definirá uma família de classes
ou funções. Por exemplo, forma geral de modelo de classes para uma classe Pilha permitirá criar pilhas de tipos
de dados, tais como int, float ou char*. Em essência, para criar uma forma geral de modelo de funções ou
classes, será definida uma classe ou função com parâmetro. Por essa razão, as formas gerais de modelos são tam-
bém conhecidas como parametrizados ou tipos genéricos.
Uma função forma geral de modelo adota o formato:

template <class tipo de dado>

tipo nome_função(lista de parâmetros)
{
// corpo da função
}

O programa a seguir cria uma função genérica que intercambia os valores de duas variáveis com independên-
cia de seus tipos.
#include <iostream.h>

template <class Z> // forma geral de

modelo void intercâmbio (Z &a, Z &b)
{
Z aux;

aux = a;
a = b;
b = aux;
}
 Palavras Reservadas ISO/ANSI C++   15

main()
{
int i = 50, j = 30;
float x = 34.25, y = 16.45;

intercâmbio(i, j); // se intercambiam inteiros

intercâmbio(x, y); // se intercambiam reais

cout << “valores de i, j atuais” << i << “” << J << endl;

cout << “valores de x, y atuais” << x << “” << y << endl;

return 0;
}

Uma declaração de classe genérica ou classe forma geral de modelo é:

template <class tipo_de_dado>
class nome_classe {
// ...
};

Uma instância de uma classe genérica se instanciará com:

nome_classe <tipo> objeto;

O exemplo seguinte é o de uma classe genérica Pilha:

template <class Tipo>
class Pilha {
public:
Pilha();
Boolean incluir(const Tipo); // por um elemento na pilha
Boolean extrair(Tipo&); // extrair um elemento da pilha
private:
tipo Elementos[MaxElementos]; // elementos da pilha
int o_topo; // topo da pilha
};

Instâncias do tipo Pilha são:

Pilha <int> pilha_ent; // pilha de inteiros
Pilha <char> pilha_car; // pilha de caracteres

A seção de implementação da pilha é especificada de um modo similar utilizando a construção template.

Esta é utilizada para especificar qual é o nome que atua como um parâmetro tipo antes de especificar a declaração
de cada função-membro.
template <class Tipo>
Pilha <Tipo> :: Pilha()
{

o_topo = -1;
}

template <class Tipo>

Boolean Pilha <Tipo> :: incluir(const Tipo item)
{
if(o_topo <MaxElementos-1) {
Elementos[++ o_topo]-item;
return TRUE;
} else {
return FALSE;
}
}
16   Programação em C++: Algoritmos, estruturas de dados e objetos

template <class Tipo>

Boolean Pilha <Tipo>:: tirar(Tipo& item)
{
if(o_topo < 0) {
return FALSE;
} else {
item = Elementos[o_topo --];
return TRUE;
}
}

Uma classe parametrizada pode ter muitos tipos como parâmetros. Por exemplo, uma classe Pilha pode ter
dois tipos parametrizados usando

template <class Tipo1, class Tipo2> class Pilha {

...
...
}

this

this é um ponteiro ao objeto atual que significa «a direção do objeto para o qual essa função foi chamada».

Sintaxe
this

Exemplo
return this;
return *this;

Quando se deseja devolver o próprio objeto, em vez de um ponteiro para o objeto, deve-se usar *this.

throw

Utiliza-se a função throw para chamar o mecanismo de tratamento de exceções.

try
{
throw MinhaExceção ();
}

try

Indica o começo de um bloco de manipuladores de exceções. Um bloco try tem o formato:

try
sentença composta
lista de manipuladores

void test()
{
try {
...
throw i;
}
 Palavras Reservadas ISO/ANSI C++   17

catch(int n)
{
if (i > 0) // manipula valores positivos
...
return;
}
else { // manipula parcialmente i <= 0
...
throw; // rethrow
}
}

true

Valor verdadeiro (certo). Um dos dois valores enumerados do tipo bool. O literal true(1) se representa por um
valor diferente de zero (normalmente 1).

enum Boolean { FALSE, TRUE };

bool boolean;
int i1 = true;
bool b3 (true);

typedef

typedef utiliza-se para dar um novo nome a um tipo de dado existente. Essa característica melhora a legibilidade
de um programa.

Sintaxe
typedef tipo_existente novo_nome;
typedef float real;
typedef struct {
float x, y;
{ ponto;

typename

Uma declaração class pode se aninhar dentro de outra declaração template class. Caso, contudo, utilize um
nome dentro de uma declaração template class, que não foi explicitamente declarada como um tipo ou classe,
supõe-se que não nomeie um tipo, a menos que o nome seja modificado pela palavra reservada typename.

template <class T>

class A
{
private:
T dados;
public:
A (): dados () {}
class X // classe local X
{};
Xx; // correto, T::X é um nome de tipo
Yy; // erro: E não é um nome de tipo
T::Zz // erro: T::Z não é um nome de tipo
typename T::I i; // correto, T::J é um nome de tipo
typename T::J * ip; // correto, ponteiro a T::I
};
18   Programação em C++: Algoritmos, estruturas de dados e objetos

união

Tipo de dado que se utiliza para atribuir armazenamento de diferentes elementos de dados na mesma posição.
A declaração de união é a mesma que a de struct, com a diferença que em uma união todos os elementos de
dados da declaração compartilham a mesma posição de armazenamento.

Sintaxe
união <nome_união>
{
<tipo> <nome_membro>
...
}

C++ dispõe também de uma união anônima cujo formato é:

união {lista_de_membros};

unsigned

O qualificador de tipos unsigned é utilizado para tipos de dados inteiros (char, int, short, int e long
int) que informam ao compilador que a variável será utilizada para armazenar somente valores não negativos.
Esse qualificador duplica o valor máximo que se possa armazenar nessa variável.

Sintaxe
unsigned <tipo inteiro> <nome_variável>

Exemplo
unsigned char lista[1000];
unsigned t; // equivale a unsigned int t

using

Declaração using e diretiva using. Uma declaração using permite a um cliente ter acesso a todos os nomes do
espaço de nomes.

using namespace mcd;

using namespace LJAabc;
jogos primeiro;

virtual

Especificador de uma função que declara uma função-membro de uma classe que se redefinirá por uma classe
derivada

class B {
public:
int i;
virtual void imprimir_t() const
{ cout << i << “interior a B” << endl; }
};

void

void é um tipo de dado que se utiliza para indicar a não existência de um valor de retorno ou argumentos em uma
declaração e definição de uma função. Para declarar um ponteiro a qualquer tipo de objeto dado, pode-se utilizar
também void*.
 Palavras Reservadas ISO/ANSI C++   19

Sintaxe
void func(void);

Exemplo
void uma_função(void *ptr);

volatile

O qualificador de tipo volatile é utilizado para indicar que a variável que vem depois de volatile pode ser
modificada por fatores externos ao controle do programa. Por exemplo, as variáveis que se trocam por hardware,
tais como relógio de tempo real, interrupções ou outras entradas, serão declaradas volatile.

wchar_t

Tipo caractere largo (wide). Utiliza-se para representar conjuntos de caracteres que requerem mais que os 255
caracteres-padrão. É concebido para jogos de caracteres que requerem caracteres não representáveis por char, tais
como o alfabeto japonês kana.

while

A sentença while permite construir um laço cujas sentenças interiores se executam até que uma condição ou
expressão se torne falsa (zero).

Sintaxe
while (condição) {
< sentenças;...>
}

Um laço while com uma só sentença em seu corpo se escreve assim:

while (condição) sentença;

Exemplo
// soma de 100 números
soma = 0;
while(j <= 10)
{
soma += j;
j++;
}
j = 0;