Programação Orientada A Objetos

1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Exemplo 1
// Exemplo 01: exemplo01 . cpp

// Programa de impresso de texto .
# include < iostream > // permite que o programa gere entrada / sada de dados
// a funo main inicia a execuo do programa
int main ()
{
std :: cout << " Hello World !\ n " ; // exibe a mensagem
system ( " pause " ) ; // pausa o programa
return 0; // indica que o programa terminou com sucesso
} // fim da funo main
exemplo01.cpp
1.1 #include
#include instrui o pr-processador a incluir no programa o contedo do arquivo de cabealho (biblioteca).
1.2 int main()

A funo main inicia a execuo do programa. A palavra-chave a esquerda de main indica que a funo main
retorna um valor do tipo inteiro.
1 int main ()
2 {
3
// corpo da funo
4
return 0 // indica que o programa terminou com sucesso
5 } // fim da funo main
1.3 namespace
O namespace utilizado para evitar conitos de atribuies de nomes.
1
2
3
4
5
6
7
8
9
namespace Example
{
int integer = 5;
}
int main ()
{
int integer = Example :: integer ;
}
1.4 std::cout
O objeto de uxo de sada padro, std::cout, realiza a sada de dados na tela. A notao std::cout especica
que o nome cout, pertence ao namespace std.
1.5 Operador de insero de uxo (<<)

O operador de insero de uxo utilizado para inserir no uxo de sada o valor direita do operador.
1 std :: cout << " Hello World !\ n " ; // exibe a mensagem
2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
Exemplo 2

// Programa de adio que exibe a soma de dois nmeros .
# include < iostream > // permite que o programa gere entrada / sada de dados
int main ()
{
// declarao de variveis
int number1 ; // primeiro inteiro a adicionar
int number2 ; // segundo inteiro a adicionar
int sum ; // soma de number1 e number2
std :: cout << " Entre com o primeiro inteiro : " ; // solicita dados ao usurio
std :: cin >> number1 ; // l primeiro inteiro pelo usurio em number1
std :: cout << " Entre com o segundo inteiro : " ; // solicita dados ao usurio
std :: cin >> number2 ; // l segundo inteiro pelo usurio em number2
sum = number1 + number2 ; // adiciona os nmeros e armazena o resultado em sum
std :: cout << " A soma e " << sum << std :: endl ; // exibe sum e termina a linha
system ( " pause " ) ; // pausa o programa
return 0; // indica que o programa terminou com sucesso
} // fim da funo main
exemplo02.cpp
2.1 std::cin
O objeto de uxo de entrada padro, std::cin, realiza a entrada de dados a partir do teclado. A notao
std::cin especica que o nome cin, pertence ao namespace std.
2.2 Operador de extrao de uxo (>>)

O operador de extrao de uxo utilizado para extrair do uxo de entrada um valor do teclado.
1 int number ;
2
3 std :: cin >> number ; // l um inteiro inserido pelo usurio
2.3 std::endl
O manipulador de uxo std::endl gera sada de um caractere de nova linha e, depois, esvazia o buer de
sada. O nome endl uma abreviao de "end line"e pertence ao namespace std.
2
3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
Exemplo 3
// Exemplo03 : exemplo03 . cpp

// Define a classe GradeBook que contm membro de dados e funes membro
// Cria e manipula um objeto GradeBook
# include < iostream >
using std :: cout ;
using std :: cin ;
using std :: endl ;
# include < string > // o programa utiliza classe de string padro C ++
using std :: string ;
using std :: getline ;
// Definio da classe GradeBook

class GradeBook
{
public :
// funo que configura o nome do curso
void setCourseName ( string name )
{
courseName = name ; // armazena o nome do curso
} // fim da funo setCurseName
// funo que obtm o nome do curso
string getCourseName ()
{
return courseName ; // retorna o nome do curso
} // fim da funo getCourseName
// funo que exibe uma mensagem de boas vindas ao usurio do GradeBook
void displayMessage ()
{
cout << " Bem vindo ao Livro de Notas de \ n " << getCourseName () << " ! " << endl ;
} // fim da funo displayMessage
private :
string courseName ; // nome do curso
}; // fim da classe GradeBook
int main ()
{
string nameOfCourse ; // varivel para armazenar o nome do curso
GradeBook myGradeBook ; // cria um objeto GradeBook chamado myGradeBook
cout << " Insira o nome do curso : " << endl ; // l o nome de um curso com espaos em brando
getline ( cin , nameOfCourse ) ; // configura o nome do curso
myGradeBook . setCourseName ( " Informatica Industrial " ) ; // configura o nome do curso
myGradeBook . displayMessage () ; // chama a funo displayMassage do objeto
system ( " pause " ) ;
return 0; // indica terminao bem - sucedida
} // fim de main
exemplo03.cpp
3.1 using std::cout

A declarao using elimina a necessidade de repetir o prexo std::. Inserindo a declarao using, pode-se
escrever cout em vez de std::cout.
3.2 Especicador de acesso public:

Uma funo, dentro de uma classe, que aparece depois do especicador de acesso public indica que a funo
est "disponvel ao pblico", isto , pode ser chamada por outras funes no programa. Os especicadores
de acesso so sempre seguidos por dois pontos (:).
1
2
3
4
5
6
7
8
class Example
{
public :
void myFunction ()
{
// corpo da funo membro
}
};
3.3 Especicador de acesso private:

Funes ou variveis declaradas depois do especicador de acesso private so acessveis somente a funes
membro da classe para a qual elas so declaradas.
3.4 std::getline
A chamada da funo getline l caracteres (incluindo espao em branco) do objeto de uxo de entrada
padro cin at o caractere nova linha ser encontrado.
3.5 Operador ponto (.)

O operador ponto utilizado para chamar uma funo membro. O nome do objeto seguido pelo operador
ponto e o nome da funo membro realizam a chamada de funo.
4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Exemplo 4

// Instanciando mltiplos objetos da classe GradeBook e utilizando
// o construtor GradeBook para especificar o nome do curso
using std :: cout ;
using std :: endl ;
# include < string > // o programa utiliza classe de string padro C ++

class GradeBook
{
public :
// construtor
GradeBook ( string name )
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
{
setCourseName ( name ) ;
} // fim do construtor GradeBook
// funo que configura o nome do curso
{
} // fim da funo setCurseName
// funo que obtm o nome do curso
{
return courseName ; // retorna o nome do curso
// funo que exibe uma mensagem de boas vindas ao usurio do GradeBook
{
cout << " Bem vindo ao Livro de Notas de \ n " << getCourseName () << " ! " << endl ;
private :
int main ()
{
// cria dois objetos GradeBook
GradeBook gradeBook1 ( " Informatica Industrial " ) ;
GradeBook gradeBook2 ( " Automacao e Controle " ) ;
// exibe valor inicial de courseName para cada GradeBook
cout << " gradeBook1 criado para o curso : " << gradeBook1 . getCourseName ()
<< " \ ngradeBook2 criado para o curso : " << gradeBook2 . getCourseName ()
<< endl ;
} // fim de main
exemplo04.cpp
4.1 Construtor
Cada classe declarada pode fornecer um construtor que pode ser utilizado para inicializar um objeto de uma
classe quando o objeto criado. Um construtor uma funo-membro especial que deve ser denida com o
mesmo nome da classe. Os construtores no podem retornar valores, ento eles no podem especicar um
tipo de retorno.
5
1
2
3
4
5
6
7
8
9
10
Exemplo 5
// Exemplo 05: GradeBook . h

// Definio da classe GradeBook em um arquivo separado
using std :: cout ;
using std :: endl ;
# include < string > // a classe GradeBook utiliza a classe de string padro C ++
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

// definio da classe GradeBook
class GradeBook
{
public :
// contrutor
GradeBook ( string name )
{
setCourseName ( name ) ; // chama a funo set para inicializar courseName
// funo para configurar o nome do curso
{
courseName = name ; // armazena o nome do curso no objeto
} // fim da funo serCourseName
// funo para obter o nome do curso
{
return courseName ; // retorna nome do objeto
// exibe uma mensagem de boas - vindas para o usurio GradeBook
{
// chama getCourseName para obter o courseName
cout << " Bem vindo ao livro de notas de \ n " << getCourseName () << " ! " << endl ;
private :
Exemplo05/GradeBook.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

// Incluindo a classe GradeBook a partir do arquivo GradeBook . h
using std :: cout ;
using std :: endl ;
# include " GradeBook . h " // inclui a definio de classe GradeBook

int main ()
{
<< endl ;
} // fim de main
Exemplo05/exemplo05.cpp
6
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//
//
//
//
Exemplo 6
Exemplo 06: GradeBook . h
Definio da classe GradeBook . Esse arquivo apresenta a interface pblica de
GradeBook sem revelar as implementaes de funes - membro de GradeBook
que so definidas em GradeBook . cpp
class GradeBook
{
public :
GradeBook ( string ) ; // construtor
void setCourseName ( string ) ; // funo para configurar o nome do curso
string getCourseName () ; // funo para obter o nome do curso
void displayMessage () ; // exibe uma mensagem de boas - vindas
private :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// Exemplo 06: GradeBook . cpp

// Definies de funo - membro de GradeBook . Esse arquivo contm
// implementaes das funes - membro prototipadas em GradeBook . h
using std :: cout ;
using std :: endl ;
# include " GradeBook . h " // inclui a definio da classe GradeBook
// contrutor
GradeBook :: GradeBook ( string name )
{
void GradeBook :: setCourseName ( string name )
{
string GradeBook :: getCourseName ()
{
void GradeBook :: displayMessage ()
{
Exemplo06/GradeBook.cpp
1 // Exemplo 06: exemplo06 . cpp
2 // Demonstrando a classe GradeBook depois de separar
3 // sua interface de sua implementao
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

using std :: cout ;
using std :: endl ;

int main ()
{
<< endl ;
} // fim de main
6.1 Prottipo de Funo

Um prottipo de funo uma declarao de funo que informa ao compilador o nome da funo, seu tipo
de retorno e os tipos de seus parmetros, mas no implementa a funo.
1 void nomeFuncao ( int , int ) ;
7
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Exemplo 7

// Definio da classe GradeBook que determina a mdia de uma classe .
// As funes - membro so definidas no GradeBook . cpp
class GradeBook
{
public :
GradeBook ( string ) ; // construtor
string getCourseName () ; // funo para obter o nome do curso
void determineClassAverage () ; // calcula a mdia das notas inseridas pelo usurio
private :
1 // Exemplo 07: GradeBook . cpp
2 // Definies de funo - membro de GradeBook . Esse arquivo contm
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
// implementaes das funes - membro prototipadas em GradeBook . h

using
using
using
using
std :: cout ;
std :: cin ;
std :: endl ;
std :: fixed ;
# include < iomanip > // manipuladores de fluxo parametrizados

using std :: setprecision ; // configura a preciso da ssada numrica
# include " GradeBook . h " // inclui a definio da classe GradeBook
// contrutor
GradeBook :: GradeBook ( string name )
{
{
{
{
// determina a mdia da classe com base em notas inseridas pelo usurio
void GradeBook :: determineClassAverage ()
{
int total = 0; // soma das notas inseridas
int gradeCounter = 0; // nmero de notas inseridas
int grade ; // valor da nota
double average ; // valor da mdia
// solicita entrada e l a nota do usurio
cout << " Insira a nota ou -1 para sair : " ;
cin >> grade ; // insere nota ou valor de sentinela
// faz um loop at ler o valor de sentinela
while ( grade != -1) // enquanto a nota no -1
{
total += grade ; // adiciona grade a total
gradeCounter ++; // incrementa contador
// solicita entrada e l a prxima nota
cout << " Insira a nota ou -1 para sair : " ;
cin >> grade ; // insere nota ou valor de sentinela
} // fim do while
if ( gradeCounter != 0) // se usurio inseriu pelo menos uma nota
{
// calcula mdia de todas as notas inseridas
average = static_cast < double >( total ) / gradeCounter ;
71
// exibe o total e a mdia
72
cout << " \ nO total de todas as " << gradeCounter << " notas inseridas e "
73
<< total << endl ;
74
cout << " A media da classe e " << setprecision (2) << fixed << average
75
<< endl ;
76
} // fim do if
77
else
78
cout << " Nenhuma nota foi inserida " << endl ;
79 } // fim da funo determineClassAverage
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// Cria o objeto da classe GradeBook e chama sua funo membro

int main ()
{
// cria um objeto GradeBook
GradeBook mygradeBook ( " Informatica Industrial " ) ;
mygradeBook . displayMessage () ; // exibe a mensagem de voas vindas
mygradeBook . determineClassAverage () ; // calcula a mdia
} // fim de main
7.1 std::setprecision
std::setprecision dene o nmero de dgitos de preciso.
7.2 std::fixed
std::fixed utilizada para forar um nmero de ponto utuante a exibir um nmero especco de dgitos.
7.3 static_cast<tipo>
Utilizado para converter entre tipos numricos fundamentais.
8
1
2
3
4
5
6
7
8
9
10
11
12
13
Exemplo 8

// Lana um dado de seis lados 6.000.000 vezes
using std :: cout ;
using std :: endl ;
# include < iomanip >
using std :: setw ;
# include < cstdlib > // contm o prottipo de funo para rand e srand
10
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
using std :: rand ;

using std :: srand ;
# include < ctime > // contm o prottipo de funo para time
using std :: time ;
int main ()
{
int frequency1
int frequency2
int frequency3
int frequency4
int frequency5
int frequency6
=
=
=
=
=
=
0;
0;
0;
0;
0;
0;
//
//
//
//
//
//
contagem
contagem
contagem
contagem
contagem
contagem
de
de
de
de
de
de
1s
2s
3s
4s
5s
6s
lanados
lanados
lanados
lanados
lanados
lanados
int face ; // armazena o valor lanado mais recente

srand ( time (0) ) ;
// resume os resuldados dos lanamentos de um dado
for ( int roll = 0; roll < 6000000; roll ++)
{
face = 1 + rand () % 6; // nmero aleatrio de 1 a 6
// determina valor de lanamento de 1 a 6 e incrementa o contador apropriado
switch ( face )
{
case 1:
frequency1 ++; // incrementa o contador de 1 s
break ;
case 2:
break ;
case 3:
break ;
case 4:
break ;
case 5:
break ;
case 6:
break ;
default : // valor invlido
cout << " O programa nunca deve chegar aqui ! " ;
break ;
} // fim de switch
} // fim do for
cout << " Face " << setw (13) << " Frequencia " << endl ; // cabealho de sada
cout << "
1 " << setw (13) << frequency1
<< " \ n
<< " \ n
<< " \ n
<< " \ n
<< " \ n
6 " << setw (13) << frequency6 << endl ;
return 0;
}
11
8.1 std::setw
std::setw especica que a prxima sada de valor deve aparecer em uma largura denida entre parnteses.
8.2 std::rand
A funo rand gera um inteiro sem sinal entre 0 e RAND_MAX.
8.3 std::srand
A funo srand aceita um argumento do tipo inteiro e semeia a funo srand para produzir uma sequncia
diferente de nmeros aleatrios.
8.4 std::time
A funo time (com o argumento 0) retorna a hora atual como o nmero de segundos desde 1 de janeiro de
1970 meia noite.
9
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
Exemplo 9

// Funes sobrecarregadas .
using std :: cout ;
using std :: endl ;
// funo square para valores int
int square ( int x )
{
cout << " O quadrado de um inteiro " << x << " e " ;
return x * x ;
} // fim da funo square com argumento int
double square ( double y )
{
cout << " O quadrado de um double " << y << " e " ;
return y * y ;
} // fim da funo square com argumento double
int main ()
{
cout <<
cout <<
cout <<
cout <<
square (7) ; // chama verso int

endl ;
square (7.5) ; // chama verso double
endl ;

return 0; // indica terminao bem sucedida
} // fim de main
9.1 Sobrecarga de funes

O C++ permite que vrias funes do mesmo nome sejam denidas, contanto que essas funes tenha
conjuntos diferentes de parmetros (tipos de parmetros ou nmero de parmetros ou a ordem dos tipos de
parmetros).
12
10
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
Exemplo 10
// Exemplo 10: Time . h

// Definio da classe Time
// Funes membro definidas em Time . cpp
# ifndef TIME_H
# define TIME_H
class Time
{
public :
Time ( int = 0 , int = 0 , int = 0) ; // construtor - padro
// funes set
void setTime ( int , int , int ) ; // configura time
void setHour ( int ) ; // configura hour
void setMinute ( int ) ; // configura minute
void setSecond ( int ) ; // configura second
// funes get ( normalmente declaradas const )
int getHour () const ; // retorna hour
int getMinute () const ; // retorna minute
int getSecond () const ; // retorna second
// funes print ( normalmente declaradas const )
void printUniversal () const ; // imprime hora universal
void printStandard () const ; // imprime hora padro
private :
int hour ; // 0
int minute ; //
int second ; //
}; // fim da classe
- 23
0 - 59
0 - 59
Time
# endif
Exemplo10/Time.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// Exemplo 10: Time . cpp

// Definies de funo membro para a classe Time
using std :: cout ;
using std :: setfill ;
using std :: setw ;
# include " Time . h " // inclui definio da classe Time
// construtor
Time :: Time ( int hour , int minute , int second )
{
setTime ( hour , minute , second ) ;
} // fim do construtor de Time
// configura valores de hour , minute e second
void Time :: setTime ( int hour , int minute , int second )
{
setHour ( hour ) ;
setMinute ( minute ) ;
setSecond ( second ) ;
} // fim da funo setTime
13
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
// configura valor de hour

void Time :: setHour ( int h )
{
hour = ( h >= 0 && h < 24) ? h : 0; // valida horas
} // fim da funo setHour
// configura valor de minute
void Time :: setMinute ( int m )
{
minute = ( m >= 0 && m < 60) ? m : 0; // valida minutos
} // fim da funo setMinute
// configura valor de second
void Time :: setSecond ( int s )
{
second = ( s >= 0 && s < 60) ? s : 0; // valida minutos
} // fim da funo setSecond
// retorna valor de hour
int Time :: getHour () const
{
return hour ;
} // fim da funo getHour
// retorna valor de minute
int Time :: getMinute () const
{
return minute ;
} // fim da funo getMinute
// retorna valor de second
int Time :: getSecond () const
{
return second ;
} // fim da funo getSecond
// imprime a hora no formato universal de data / hora ( HH : MM : SS )
void Time :: printUniversal () const
{
cout << setfill ( 0 ) << setw (2) << hour << " : "
<< setw (2) << minute << " : " << setw (2) << second << " \ n " ;
} // fim da funo printUniversal
// imprime a hora no formato padro de data / hora ( HH : MM : SS AM ou PM )
void Time :: printStandard () const
{
cout << (( hour == 0 || hour == 12) ? 12 : hour % 12)
<< " : " << setfill ( 0 ) << setw (2) << minute
<< " : " << setw (2) << second << ( hour < 12 ? " AM " : " PM " ) << " \ n " ;
} // fim da funo printStandard
Exemplo10/Time.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// Testendo a classe Time
using std :: cout ;
# include " Time . h " // inclui definies da classe Time
int main ()
{
Time t1 ; //
Time t2 (2) ;
Time t3 (21 ,
Time t4 (12 ,
todos os argumentos convertidos para sua configurao padro

// hora especificada , minutos e segundos convertidos para o padro
34) ; // hora e minutos especificados , segundos convertido para o padro
25 , 42) ; // hora , minutos e segundos especificados
14
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47 }
Time t5 (27 , 74 , 99) ; // valores invlidos especificados

const Time noon (12 , 0 , 0) ; // objeto constante
cout << " t1 : todos argumentos padrao \ n " ;
t1 . printUniversal () ;
t1 . printStandard () ;
cout << " t2 : hora especificada , minutos e segundos padrao \ n " ;
cout << " t3 : hora e minutos especificados , segundos padrao \ n " ;
cout << " t4 : hora , minutos e segundos especificados \ n " ;
cout << " t5 : valores invalidos \ n " ;
cout << " noom : objeto constante \ n " ;
noon . printUniversal () ; // objetos constantes s podem chamar funes membro constantes
noon . printStandard () ;
return 0;
10.1 std::fill
A funo std::fill especica o caractere de preenchimento a ser utilizado.
10.2 Empacotador de pr-processador

O empacotador de pr-processador impede que o cdigo entre #ifndef (que quer dizer "se no denido")
e #endif seja includo se o nome, por exemplo TIME_H, tiver sido denido. Se o cabealho no foi includo
anteriormente em um arquivo, o nome TIME_H ser denido pela diretiva #define e as instrues de arquivo
de cabealho sero includas. Se o cabealho tiver sido includo, TIME_H j estar denido e o arquivo de
cabealho no ser novamente includo.
10.3 Construtores com argumentos-padro

Os argumentos-padro para o construtor asseguram que, mesmo se nenhum valor for fornecido em uma
chamada de construtor, o construtor ainda inicializar os membros de dados para manter o objeto em estado
consistente.
10.4 Variveis Constantes

Variveis constantes so declaradas utilizando o qualicador const e devem ser inicializadas com uma expresso constante quando so declaradas e no podem ser modicadas.
1 const int size = 10;
15
10.5 Objetos Constantes

O programador pode utilizar o qualicador const para especicar que um objeto no modicvel.
Os compiladores C++ no permitem chamadas de funo membro para objetos const a menos que as
prprias funes membro sejam declaradas const.
10.6 Funes Membro Constantes

Funes membro declaradas const no podem modicar o objeto.
1 int print () const ; // prottipo de funo membro constante
11
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Exemplo 11
// Exemplo 11: Increment . h

// Definio da classe Increment .
# ifndef INCREMENT_H
# define INCREMENT_H
class Increment
{
public :
Increment ( int c = 0 , int i = 1) ; // construtor padro
void addIncrement () ;
void print () const ;
private :
int count ;
const int increment ; // membro de dados const
}; // fim da classe Increment
# endif
Exemplo11/Increment.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// Exemplo 11: Increment . cpp

// Demonstrao do uso do inicializador de membro para inicializar uma constante
using std :: cout ;
using std :: endl ;
# include " Increment . h "
// construtor
Increment :: Increment ( int c , int i )
: count ( c ) , // inicializador para membro no - const
increment ( i ) // inicializador requerido para membro const
{
// corpo vazio
} // fim do construtor Increment
// definio da funo addIncrement
void Increment :: addIncrement ()
{
count += increment ;
} // fim da funo addIncrement
// imprime valores de count e increment
void Increment :: print () const
{
16
28
cout << " count = " << count << " , increment = " << increment << endl ;
29 } // fim da funo print
Exemplo11/Increment.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

// Programa para testar a classe Increment
using std :: cout ;
# include " Increment . h " // inclui a definio da classe Increment
int main ()
{
Increment value (10 ,5) ;
cout << " Antes de incrementar : " ;
value . print () ;
for ( int j = 1; j <= 3; j ++)
{
value . addIncrement () ;
cout << " Depois do incremento " << j << " : " ;
value . print () ;
} // fim do for
return 0;
} // fim de main
11.1 Inicializador de membro

Todos os membros de dados podem ser inicializados utilizando inicializadores de membros, mas os membros
de dados const e os membros de dados que so referncias devem ser inicializados com inicializadores de
membros.
Os inicializadores de membros aparecem entre a lista de parmetros de um construtor e a chave esquerda
que inicia o corpo do construtor. A lista de inicializadores de membros separada da lista de parmetros por
dois pontos (:). Cada inicializador de membro consiste no nome do membro de dados seguido por parnteses
contendo o valor inicial do membro.
12
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Exemplo 12

// Definio da classe Employee
# ifndef EMPLOYEE_H
# define EMPLOYEE_H
# include < string >
class Employee
{
public :
Employee ( string , string ) ; // contrutor
string getFirstName () const ; // retorna nome
17
16
string getLastName () const ; // retorna sobrenome
17
void printSalary () const ; // imprime salrio
18
static int getCount () ; // retorna nmero de objetos instanciados
19 private :
20
string firstName ;
21
string lastName ;
22
static int count ;
23 };
24
25 # endif
Exemplo12/Employee.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
// Exemplo 12: Employee . cpp

// Defies de funes membro da classe Employee .
using std :: cout ;
using std :: endl ;
# include " Employee . h "
// define e inicializa o membro de dados static no arquivo de cdigo
int Employee :: count = 0;
// define a funo membro static que retorna o nmero de objetos Employee
int Employee :: getCount ()
{
return count ;
} // fim da funo static getCount
Employee :: Employee ( string first , string last )
{
firstName = first ;
lastName = last ;
count ++;
cout << " Construtor Employee chamado para " << firstName << " " << lastName << endl ;
} // fim do construtor Employee
// retorna nome
string Employee :: getFirstName () const
{
return firstName ;
} // fim da funo getFirstName
// retorna sobrenome
string Employee :: getLastName () const
{
return lastName ;
} // fim da funo getLastName
void Employee :: printSalary () const
{
static int salary = 100; // inicializada na primeira vez em que printSalary chamada
cout << " O salario de " << firstName << " e " << salary << endl ;
salary += 100;
} // fim da funo printSalary
Exemplo12/Employee.cpp
2 // Programa para testar a classe Employee
18
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

using std :: cout ;
using std :: endl ;
int main ()
{
// Acessa o nmero de empregados quando no existe nenhum objeto
cout << " O numero de empregados antes de instanciar um objeto e "
<< Employee :: getCount () << endl ;
// Cria dois objetos
Employee employee1 ( " Joao " ," Silva " ) ;
Employee employee2 ( " Maria " ," Pereira " ) ;
// chama getCount no primeiro objeto
cout << " O numero de empregados depois de instanciar objetos e "
<< employee1 . getCount () << endl ;
cout <<
<<
cout <<
<<
" Empregado 1: " << employee1 . getFirstName ()

" " << employee1 . getLastName () << endl ;
" Empregado 2: " << employee2 . getFirstName ()
" " << employee2 . getLastName () << endl ;
employee1 . printSalary () ;
employee1 . printSalary () ;
return 0;
}
12.1 Variveis locais static

As variveis locais declaradas com a palavra-chave static so conhecidas apenas na funo em que so
declaradas, mas as variveis locais static retm seus valores quando a funo retorna para seu chamador.
A prxima vez que a funo chamada, as variveis locais static contm os valores que tinham quando a
funo completou pela ltima vez a execuo.
12.2 Membros de classe static

Um membro de dados static compartilhado por todos os objetos de uma classe. Um membro de dados
static do tipo fundamental inicializado por padro como 0. Se quiser um valor inicial diferente, um membro
de dados static pode ser inicializado um vez. Os membros de dados static devem ser denidos no arquivo
de cdigo (.cpp).
Para acessar um membro de classe public static quando no existe nenhum objeto da classe, simplesmente prexe o nome da classe e o operador (::) com o nome do membro de dados. Para acessar um membro
da classe private static quando no houver nenhum objeto da classe, fornea uma funo membro public
static e chame a funo prexando seu nome com o nome da classe e o operador (::).
13
Exemplo 13

2 // Calcula a soma dos elementos do array .
3
4 # include < iostream >
19
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
using std :: cout ;

using std :: endl ;
int main ()
{
const int arraySize = 10; // varivel constante indicando o tamanho do array
int a [ arraySize ] = {87 , 68 , 94 , 100 , 83 , 78 , 85 , 91 , 76 , 87};
int total = 0;
// soma o cantedo do array a
for ( int i = 0; i < arraySize ; i ++)
total += a [ i ];
cout << " Total da soma dos elementos do array : " << total << endl ;
getchar () ; // pausa o programa
} // fim de main
13.1 Arrays
Um array um grupo consecutivo de posies na memria em que todas elas so do mesmo tipo. Para
referir-se a uma particular localizao ou elemento no array, especica-se o nome do array e o nmero de
posio do elemento particular do array.
13.2 Declarando arrays

O programador deve especicar o tipo do elemento e o nmero de elementos requeridos por um array:
1 tipo nomeDoArray [ tamanhoDoArray ];
1 int c [12]; // c um array de 12 inteiros

2
3 int n [10] = {0}; // inicializa elementos do array n com 0
Se o tamanho do array for omitido de uma declarao com uma lista inicializadora, o compilador determina
o nmero de elementos no array contendo o nmero de elementos na lista inicializadora.
1 int n [] = {1 , 2 , 3 , 4 , 5};
14
1
2
3
4
5
6
7
8
9
10
Exemplo 14

// Joga um dado de seis lados 6.000.000 vezes .
using std :: cout ;
using std :: endl ;
20
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
using std :: setw ;

# include < cstdlib >
using std :: rand ;
# include < ctime >
using std :: time ;
int main ()
{
const int arraySize = 7; // ignora o elemento zero
int frequency [ arraySize ] = {0};
srand ( time (0) ) ; // semeia o gerador de nmero aleatrio
// lana o dado 6.000.000 vezes
for ( int roll = 1; roll < 6000000; roll ++)
frequency [1 + rand () % 6]++;
cout << " Face " << setw (13) << " Frequencia " << endl ;
// gera a sada do valor de cada elemento do array
for ( int face = 1; face < arraySize ; face ++)
cout << setw (4) << face << setw (13) << frequency [ face ] << endl ;
} // fim de main
15
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
Exemplo 15

// Passando arrays e elementos de arrays individuais a funes
using std :: cout ;
using std :: endl ;
using std :: setw ;
void modifyArray ( int [] , int ) ;
void modifyElement ( int ) ;
int main ()
{
const int arraySize = 5; // tamanho do array a
int a [ arraySize ] = {0 , 1 , 2 , 3 , 4}; // inicializa o array a
cout << " Efeitos de passar um array por referencia : "
<< " \ n \ nOs valores do array original sao :\ n " ;
// gera sada de elementos do array original
for ( int i = 0; i < arraySize ; i ++)
cout << setw (3) << a [ i ];
cout << endl ;
21
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
// passa o array a para modifyArray por referncia

modifyArray (a , arraySize ) ;
cout << " Os valores do array modificado sao :\ n " ;
// gera sada de elementos do array modificado
for ( int j = 0; j < arraySize ; j ++)
cout << setw (3) << a [ j ];
cout << " \ n \ n \ nEfeitos de passar um elemento do array por valor : "
<< " \ n \ na [3] antes de modifyElement : " << a [3] << endl ;
modifyElement ( a [3]) ; // passa elemento do array a [3] por valor
cout << " a [3] depois de modifyElement : " << a [3] << endl ;
getchar () ; // pausa o programa ;
} // fim de main
// na funo modifyArray , " b " aponta para o array original " a " na memria
void modifyArray ( int b [] , int sizeOfArray )
{
// multiplica cada elemento do array por 2
for ( int k = 0; k < sizeOfArray ; k ++)
b [ k ] *= 2;
} // fim da funo modifyArray
void modifyElement ( int e )
{
// multiplica parmetro por 2
cout << " Valor do elemento em modifyElement : " << ( e *=2) << endl ;
} // fim da funo modifyElement
15.1 Passando arrays para funes

Para uma funo receber um array, a lista de parmetros da funo deve especicar que a funo espera
receber um array.
1 void modifyArray ( int b [] , int arraySize )
Para passar um argumento array a uma funo, especique o nome do array sem colchetes.
1 int array [10];
2
3 modifyArray ( array , 10) ;
16
1
2
3
4
5
6
7
8
9
Exemplo 16

// Inicializao de arrays multidimensionais
using std :: cout ;
using std :: endl ;
void printArray ( const int [][ 3 ] ) ; // prottipo
22
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
int main ()
{
int array1 [ 2 ][ 3 ] = { { 1 , 2 , 3 } , { 4 , 5 , 6 } };
int array2 [ 2 ][ 3 ] = { 1 , 2 , 3 , 4 , 5 };
int array3 [ 2 ][ 3 ] = { { 1 , 2 } , { 4 } };
cout << " Valores por linha no array1 sao : " << endl ;
printArray ( array1 ) ;
cout << " \ nValores por linha no array2 sao : " << endl ;
cout << " \ nValores por linha no array3 sao : " << endl ;
} // fim de main
// gera sada do array com duas linhas e trs colunas
void printArray ( const int a [][ 3 ] )
{
// faz um loop pelas linhas do array
for ( int i = 0; i < 2; i ++ )
{
// faz um loop pelas colunas da linha atual
for ( int j = 0; j < 3; j ++ )
cout << a [ i ][ j ] << ;
cout << endl ; // inicia nova linha de sada
} // fim do for externo
} // fim da funo printArray
17
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
Exemplo 17

// Definio da classe GradeBook que usa um array para armazenar notas de teste .
// As funes membro so definidas no Gradebook . cpp
# include < string > // o programa utiliza a classe string da C ++ Standard Library
class GradeBook
{
public :
// constante -- nmero de alunos que fez o teste
const static int students = 10; // note os dados pblicos
// construtor inicializa o nome do curso e o array de notas
GradeBook ( string , const int [] ) ;
string getCourseName () ; // funo para recuperar o nome do curso
void processGrades () ; // realiza vrias operaes nos dados
int getMinimum () ; // localiza a nota mnima para o teste
int getMaximum () ; // localiza a nota mxima para o teste
double getAverage () ; // determina a nota mdia para o teste
void outputGrades () ; // gera a sada do contedo do array de notas
private :
23
27
string courseName ; // nome do curso para esse livro de notas
28
int grades [ students ]; // array de notas de aluno
29 }; // fim da classe GradeBook
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
// Exemplo 17: GradeBook . cpp

// Definies de funo membro para a classe GradeBook que
// utiliza um array para armazenar notas de teste .
using std :: cout ;
using std :: cin ;
using std :: endl ;
using std :: fixed ;
using std :: setprecision ;
using std :: setw ;
# include " GradeBook . h " // Definio da classe GradeBook
// o construtor inicializa courseName e o array grades
GradeBook :: GradeBook ( string name , const int gradesArray [] )
{
setCourseName ( name ) ; // inicializa courseName
// copia notas de gradeArray para membro de dados grades
for ( int grade = 0; grade < students ; grade ++ )
grades [ grade ] = gradesArray [ grade ];
{
} // fim da funo setCourseName
// funo para recuperar o nome do curso
{
return courseName ;
// exibe uma mensagem de boas - vindas para o usurio de GradeBook
{
// essa instruo chama getCourseName para obter o
// nome do curso que esse GradeBook representa
cout << " Bem vindo ao livro de notas de \ n " << getCourseName () << " ! "
<< endl ;
// realiza vrias operaes nos dados
void GradeBook :: processGrades ()
{
// gera sada de array de notas
outputGrades () ;
// chama funo getAverage para calcular a nota mdia
cout << " \ nA media da classe e " << setprecision ( 2 ) << fixed <<
getAverage () << endl ;
// chama funes getMinimum e getMaximum
cout << " A menor nota e " << getMinimum () << " \ nA maior nota e "
<< getMaximum () << endl ;
} // fim da funo processGrades
24
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
// localiza nota mnima

int GradeBook :: getMinimum ()
{
int lowGrade = 100; // supe que a nota mais baixa 100
// faz um loop pelo array de notas
{
// se nota for mais baixa que lowGrade , atribui - a a lowGrade
if ( grades [ grade ] < lowGrade )
lowGrade = grades [ grade ]; // nova nota mais baixa
} // fim do for
return lowGrade ; // retorna nota mais baixa
} // fim da funo getMinimum
// localiza nota mxima
int GradeBook :: getMaximum ()
{
int highGrade = 0; // supe que a nota mais alta 0
// faz um loop pelo array de notas
{
// se a nota atual for mais alta que highGrade , ela atribuda a highGrade
if ( grades [ grade ] > highGrade )
highGrade = grades [ grade ]; // nova nota mais alta
} // fim do for
return highGrade ; // retorna nota mais alta
} // fim da funo getMaximum
// determina mdia para o teste
double GradeBook :: getAverage ()
{
int total = 0; // inicializa o total
// soma notas no array
total += grades [ grade ];
// retorna mdia de notas
return static_cast < double >( total ) / students ;
} // fim da funo getAverage
// gera a sada do contedo do array de notas
void GradeBook :: outputGrades ()
{
cout << " \ nAs notas sao :\ n \ n " ;
// gera a sada da nota de cada aluno
for ( int student = 0; student < students ; student ++ )
cout << " Estudante " << setw ( 2 ) << student + 1 << " : " << setw ( 3 )
<< grades [ student ] << endl ;
} // fim da funo outputGrades
1
2
3
4
5
6
7
8
9
10

// Cria objeto GradeBook utilizando um array de notas .
# include " GradeBook . h " // Definio da classe GradeBook
int main ()
{
// array de notas de aluno
int gradesArray [ GradeBook :: students ] =
25
11
{ 87 , 68 , 94 , 100 , 83 , 78 , 85 , 91 , 76 , 87 };
12
13
GradeBook myGradeBook (
14
" Informatica Industrial " , gradesArray ) ;
15
myGradeBook . displayMessage () ;
16
myGradeBook . processGrades () ;
17
18
getchar () ;
19
20
return 0;
21
22 } // fim de main
18
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
Exemplo 18

// Utilizando os operadores & e *.
using std :: cout ;
using std :: endl ;
int main ()
{
int a ; // a um inteiro
int * aPtr ; // aPtr um ponteiro int * -- para um inteiro
a = 7; // atribuiu 7 a a
aPtr = & a ; // atribui o endereo de a ao aPtr
cout << " O endereco de a e " << & a
<< " \ nO valor de aPtr e " << aPtr ;
cout << " \ n \ nO valor de a e " << a
<< " \ nO valor de * aPtr e " << * aPtr ;
cout << " \ n \ Mostrando que * e & sao o oposto um do outro . "
<< " \ n &* aPtr = " << &* aPtr
<< " \ n *& aPtr = " << *& aPtr << endl ;
} // fim de main
18.1 Declarao de varivel ponteiro

As variveis ponteiro contm endereos de memria como seus valores. Normalmente, uma varivel contm
diretamente um valor especco. Mas um ponteiro contm o endereo de memria de uma varivel que, por
sua vez, contm um valor especco. Nesse sentido, o nome de uma varivel referencia um valor diretamente
e um ponteiro referencia um valor indiretamente. Toda varivel sendo declarada como um ponteiro deve ser
precedida por um asterisco (*).
1 int * xPtr ; // declara varivel ponteiro xPtr
26
18.2 Operadores de ponteiro

O operador de endereo (&) um operador que retorna o endereo de memria de seu operando.
1 int y = 5; // declara varivel y
2 int * yPtr ; // declara varivel ponteiro yPtr
3
4 yPtr = & y ; // atribui o endereo ponteiro yPtr
O operador de desreferncia *, retorna o valor da varivel para o qual o ponteiro aponta.

1
2
3
4
5
6
int y = 5; // declara varivel y

int * yPtr ; // declara varivel ponteiro yPtr
yPtr = & y ; // atribui o endereo ponteiro yPtr
cout << * yPtr ; // imprime o valor 5
Quando * aparece em uma declarao, ele no um operador, em vez disso, indica que a varivel sendo
declarada um ponteiro.
19
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
Exemplo 19

// Eleva uma varivel ao cubo utilizando passagem por valor e
// eleva uma varivel ao cubo usando passagem por referncia com um argumento nPtr .
using std :: cout ;
using std :: endl ;
int cubeByValue ( int ) ; // prottipo
void cubeByReference ( int * ) ; // prottipo
int main ()
{
int number1 = 5;
int number2 = 6;
cout << " O valor original de number1 e " << number1 ;
cout << " \ n \ nO valor original de number2 e " << number2 ;
number1 = cubeByValue ( number1 ) ; // passa number por valor ao cubeByValue
cout << " \ n \ nO novo valor de number1 e " << number1 << endl ;
cubeByReference ( & number2 ) ; // passa endereo de number para cubeByReference
cout << " \ nO novo valor de number2 e " << number2 << endl ;
} // fim de main
// calcula e retorna o cubo do argumento inteiro
int cubeByValue ( int n )
{
return n * n * n ; // eleva a varivel local n ao cubo e retorna o resultado
} // fim da funo cubeByValue
// calcula o cubo de * nPtr ; modifica a varivel number em main
void cubeByReference ( int * nPtr )
{
27
40
* nPtr = * nPtr * * nPtr * * nPtr ; // eleva * nPtr ao cubo
41 } // fim da funo cubeByReference
19.1 Passando argumentos para funes por referncia com ponteiros

Uma funo que recebe um endereo como um argumento deve denir um parmetro de ponteiro para receber
o endereo.
1
2
3
4
5
6
7
8
void cubeByReference ( int *) ; // prottipo

int ain ()
{
int number = 5;
cubeByReference (& number ) ; // passa endereo de number para cubeByReference
}
20
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
Exemplo 20

// Convertendo minsculas em maisculas
// utilizando um ponteiro no - constante para dados no - constantes .
using std :: cout ;
using std :: endl ;
# include < cctype > // prottipos para islower e toupper
using std :: islower ;
using std :: toupper ;
void convertToUppercase ( char * ) ;
int main ()
{
char phrase [] = " caracteres e $32 .98 " ;
cout << " A frase antes da conversao e : " << phrase ;
convertToUppercase ( phrase ) ;
cout << " \ nA frase depois da conversao e : " << phrase << endl ;
} // fim de main
// converte string em letras maisculas
void convertToUppercase ( char * sPtr )
{
while ( * sPtr != \0 ) // faz loop enquanto caractere atual no \0
{
if ( islower ( * sPtr ) ) // se o caractere estiver em minsculas ,
* sPtr = toupper ( * sPtr ) ; // converte em maisculas
sPtr ++; // move sPtr para o prximo caractere na string
} // fim do while
} // fim da funo convertToUppercase
28
20.1 Ponteiro no constante para dados no constantes

Os dados podem ser modicados pelo ponteiro desreferenciado e o ponteiro pode ser modicado para apontar
para outros dados.
1 int * aPtr ; // ponteiro no constante para dados no constantes
21
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
Exemplo 21

// Imprimindo uma string , um caractere por vez , utilizando
// um ponteiro no - constante para dados constantes .
using std :: cout ;
using std :: endl ;
void printCharacters ( const char * ) ; // imprime usando ponteiro para dados const
int main ()
{
const char phrase [] = " imprime caracteres de uma string " ;
cout << " A string e :\ n " ;
printCharacters ( phrase ) ; // imprime caracteres em phrase
cout << endl ;
} // fim de main
// sPtr pode ser modificado , mas no pode modificar o caractere para o qual
// ele aponta , isto , sPtr um ponteiro " de leitura "
void printCharacters ( const char * sPtr )
{
for ( ; * sPtr != \0 ; sPtr ++ ) // nenhuma inicializao
cout << * sPtr ; // exibe caractere sem modificao
} // fim da funo printCharacters
21.1 Ponteiro no constante para dados constantes

O ponteiro pode ser modicado para apontar para outros dados, mas os dados para os quais ele aponta no
podem ser modicados por esse ponteiro.
1 const int * aPtr ; // ponteiro no constante para dados constantes
22
Exemplo 22

2 // Tentar modificar um ponteiro constante para dados no - constantes .
3
4 # include < iostream >
5
29
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
using std :: cout ;

int main ()
{
int x , y ;
// ptr um ponteiro constante para um inteiro que pode
// ser modificado por ptr , mas ptr sempre aponta para a
// mesma posio da memria .
int * const ptr = & x ; // ponteiro const deve ser inicializado
* ptr = 7; // permitido : * ptr no const
ptr = & y ; // erro : ptr constante ; no possvel atribu - lo a um novo endereo
cout << " O valor de x e " << x ;
} // fim de main
22.1 Ponteiro constante para dados no constantes

O ponteiro sempre aponta para a mesma posio da memria, mas os dados nessa posio podem ser modicados pelo ponteiro.
1 int * const aPtr ; // ponteiro constante para dados no constantes
23
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
Exemplo 23

// Tentando modificar um ponteiro constante para dados constantes .
using std :: cout ;
using std :: endl ;
int main ()
{
int x = 5 , y ;
// ptr um ponteiro
// ptr sempre aponta
// nessa posio no
const int * const ptr
constante para um inteiro constante .

para a mesma posio ; o inteiro
pode ser modificado .
= &x;
cout << * ptr << endl ;

* ptr = 7; // erro : * ptr const ; no possvel atribuir novo valor
ptr = & y ; // error : ptr const ; no possvel atribuir endereo
} // fim de main
30
23.1 Ponteiro constante para dados constantes

O ponteiro sempre aponta para a mesma posio da memria e os dados nessa posio no podem ser
modicados pelo ponteiro.
1 const int * const aPtr ; // ponteiro constante para dados constantes
24
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
Exemplo 24

// Esse programa coloca valores em um array , classifica os valores em
// ordem crescente e imprime o array resultante .
using std :: cout ;
using std :: endl ;
using std :: setw ;
void selectionSort ( int * const , const int ) ; // prottipo
void swap ( int * const , int * const ) ; // prottipo
int main ()
{
const int arraySize = 10;
int a [ arraySize ] = { 2 , 6 , 4 , 8 , 10 , 12 , 89 , 68 , 45 , 37 };
cout << " Dados na ordem original :\ n " ;
for ( int i = 0; i < arraySize ; i ++ )
cout << setw ( 4 ) << a [ i ];
selectionSort ( a , arraySize ) ; // classifica o array
cout << " \ nDados na ordem crescente :\ n " ;
for ( int j = 0; j < arraySize ; j ++ )
cout << setw ( 4 ) << a [ j ];
cout << endl ;
} // fim de main
// funo para classificar um array
void selectionSort ( int * const array , const int size )
{
int smallest ; // ndice do menor elemento
// itera sobre size - 1 elementos
for ( int i = 0; i < size - 1; i ++ )
{
smallest = i ; // primeiro ndice do array remanescente
// faz um loop para localizar o ndice do menor elemento
for ( int index = i + 1; index < size ; index ++ )
if ( array [ index ] < array [ smallest ] )
smallest = index ;
31
55
56
57
58
59
60
61
62
63
64
65
66
swap ( & array [ i ] , & array [ smallest ] ) ;

} // fim do for
} // fim da funo selectionSort
// troca os valores nas posies da memria para as quais
// element1Ptr e element2Ptr apontem
void swap ( int * const element1Ptr , int * const element2Ptr )
{
int hold = * element1Ptr ;
* element1Ptr = * element2Ptr ;
* element2Ptr = hold ;
} // fim da funo swap
25
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
Exemplo 25

// Utilizando notaes de subscrito e de ponteiro com arrays .
using std :: cout ;
using std :: endl ;
int main ()
{
int b [] = { 10 , 20 , 30 , 40 }; // cria o array b de 4 elementos
int * bPtr = b ; // configura bPtr para apontar para o array b
// gera sada do array b utilizando notao de subscrito de array
cout << " Array b impresso com :\ n \ nNotacao de subscrito de array \ n " ;
for ( int i = 0; i < 4; i ++ )
cout << " b [ " << i << " ] = " << b [ i ] << \ n ;
// gera sada do array b utilizando a notao de nome de array e a de ponteiro / deslocamento
cout << " \ nNotacao de ponteiro / deslocamento onde "
<< " o ponteiro e o nome de array \ n " ;
for ( int offset1 = 0; offset1 < 4; offset1 ++ )
cout << " *( b + " << offset1 << " ) = " << *( b + offset1 ) << \ n ;
// gera sada do array b utilizando bPtr e notao de subscrito de array
cout << " \ nNotacao de subscrito de array \ n " ;
for ( int j = 0; j < 4; j ++ )
cout << " bPtr [ " << j << " ] = " << bPtr [ j ] << \ n ;
cout << " \ nNotacao de ponteiro / deslocamento \ n " ;
// gera sada do array b utilizando bPtr e notao de ponteiro / deslocamento
for ( int offset2 = 0; offset2 < 4; offset2 ++ )
cout << " *( bPtr + " << offset2 << " ) = "
<< *( bPtr + offset2 ) << \ n ;
} // fim de main
26
Exemplo 26
32
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Exemplo 26: DeckOfCards . h

// Definio da classe DeckOfCards que
// representa um baralho .
// Definio da classe DeckOfCards
class DeckOfCards
{
public :
DeckOfCards () ; // construtor inicializa deck
void shuffle () ; // embaralha as cartas do baralho
void deal () ; // distribui as cartas do baralho
private :
int deck [ 4 ][ 13 ]; // representa o baralho de cartas
}; // fim da classe DeckOfCards
Exemplo26/DeckOfCards.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
// Exemplo 26: DeckOfCards . cpp

// Definies de funo membro para a classe DeckOfCards que simula
// o embaralhamento e distribuio de um baralho .
using std :: cout ;
using std :: left ;
using std :: right ;
using std :: setw ;
# include < cstdlib > // prottipos para rand e srand
using std :: rand ;
# include < ctime > // prottipo para time
using std :: time ;
# include " DeckOfCards . h " // Definio da classe DeckOfCards
// construtor padro DeckOfCards inicializa deck
DeckOfCards :: DeckOfCards ()
{
// itera pelas linhas do baralho
for ( int row = 0; row <= 3; row ++ )
{
// itera pelas colunas do baralho para linha atual
for ( int column = 0; column <= 12; column ++ )
{
deck [ row ][ column ] = 0; // inicializa slot de deck como 0
} // fim do for interno
srand ( time ( 0 ) ) ; // semeia o gerador de nmero aleatrio
} // fim do construtor padro DeckOfCards
// embaralha as cartas do baralho
void DeckOfCards :: shuffle ()
{
int row ; // representa o valor do naipe da carta
int column ; // representa o valor da face da carta
// para cada uma das 52 cartas , escolhe um slot aleatoriamente
for ( int card = 1; card <= 52; card ++ )
{
do // escolhe uma nova localizao aleatria at um slot vazio ser encontrado
{
row = rand () % 4; // seleciona a linha aleatoriamente
column = rand () % 13; // seleciona a coluna aleatoriamente
} while ( deck [ row ][ column ] != 0 ) ; // fim da instruo do ... while
33
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
// coloca o nmero de carta no slot escolhido

deck [ row ][ column ] = card ;
} // fim do for
} // fim da funo shuffle
// distribui as cartas do baralho
void DeckOfCards :: deal ()
{
// inicializa o array suit
static const char * suit [ 4 ] =
{ " Copas " , " Ouros " , " Paus " , " Espadas " };
// inicializa o array face
static const char * face [ 13 ] =
{ " As " , " Dois " , " Tres " , " Quatro " , " Cinco " , " Seis " , " Sete " ,
" Oito " , " Nove " , " Dez " , " Valete " , " Dama " , " Rei " };
// para cada uma das 52 cartas
for ( int card = 1; card <= 52; card ++ )
{
// itera pelas linhas do baralho
for ( int row = 0; row <= 3; row ++ )
{
// itera pelas colunas de baralho para linha atual
for ( int column = 0; column <= 12; column ++ )
{
// se o slot contiver a carta atual , exibe a carta
if ( deck [ row ][ column ] == card )
{
cout << setw ( 6 ) << right << face [ column ]
<< " de " << setw ( 8 ) << left << suit [ row ]
<< ( card % 2 == 0 ? \ n : \ t ) ;
} // fim do if
} // fim do for mais interno
} // fim do for interno
} // fim da funo deal
Exemplo26/DeckOfCards.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14

// Programa de embaralhamento e distribuio de cartas .
# include " DeckOfCards . h " // Definio da classe DeckOfCards
int main ()
{
DeckOfCards deckOfCards ; // cria objeto DeckOfCards
deckOfCards . shuffle () ; // embaralha as cartas
deckOfCards . deal () ; // distribui as cartas
} // fim de main
27
1
2
3
4
5
Exemplo 27
// Exemplo 27: CommissionEmployee . h

// Definio da classe CommissionEmployee com dados protected .
# ifndef COMMISSION_H
# define COMMISSION_H
34
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
# include < string > // classe string padro C ++

class CommissionEmployee
{
public :
CommissionEmployee ( const string , const string , const string ,
double = 0.0 , double = 0.0 ) ;
void setFirstName ( const string ) ; // configura o nome
string getFirstName () const ; // retorna o nome
void setLastName ( const string ) ; // configura o sobrenome
string getLastName () const ; // retorna o sobrenome
void setSocialSecurityNumber ( const string ) ; // configura SSN
string getSocialSecurityNumber () const ; // retorna SSN
void setGrossSales ( double ) ; // configura a quantidade de vendas brutas
double getGrossSales () const ; // retorna a quantidade de vendas brutas
void setCommissionRate ( double ) ; // configura a taxa de comisso
double getCommissionRate () const ; // retorna a taxa de comisso
double earnings () const ; // calcula os rendimentos
void print () const ; // imprime o objeto CommissionEmployee
protected :
string firstName ;
string lastName ;
string socialSecurityNumber ;
double grossSales ; // vendas brutas semanais
double commissionRate ; // porcentagem da comisso
}; // fim da classe CommissionEmployee
# endif
Exemplo27/CommissionEmployee.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// Exemplo 27: CommissionEmployee . cpp

// Definies de funo membro da classe CommissionEmployee .
using std :: cout ;
# include " CommissionEmployee . h " // Definio da classe CommissionEmployee
// construtor
CommissionEmployee :: CommissionEmployee (
const string first , const string last , const string ssn ,
double sales , double rate )
{
firstName = first ; // deve validar
lastName = last ; // deve validar
socialSecurityNumber = ssn ; // deve validar
setGrossSales ( sales ) ; // valida e armazena as vendas brutas
setCommissionRate ( rate ) ; // valida e armazena a taxa de comisso
} // fim do construtor CommissionEmployee
// configura o nome
void CommissionEmployee :: setFirstName ( const string first )
{
} // fim da funo setFirstName
// retorna o nome
string CommissionEmployee :: getFirstName () const
{
return firstName ;
35
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
// configura o sobrenome
void CommissionEmployee :: setLastName ( const string last )
{
} // fim da funo setLastName
// retorna o sobrenome
string CommissionEmployee :: getLastName () const
{
return lastName ;
// configura o SSN
void CommissionEmployee :: setSocialSecurityNumber ( const string ssn )
{
} // fim da funo setSocialSecurityNumber
// retorna o SSN
string CommissionEmployee :: getSocialSecurityNumber () const
{
return socialSecurityNumber ;
} // fim da funo getSocialSecurityNumber
// configura a quantidade de vendas brutas
void CommissionEmployee :: setGrossSales ( double sales )
{
grossSales = ( sales < 0.0 ) ? 0.0 : sales ;
} // fim da funo setGrossSales
// retorna a quantidade de vendas brutas
double CommissionEmployee :: getGrossSales () const
{
return grossSales ;
} // fim da funo getGrossSales
// configura a taxa de comisso
void CommissionEmployee :: setCommissionRate ( double rate )
{
commissionRate = ( rate > 0.0 && rate < 1.0 ) ? rate : 0.0;
} // fim da funo setCommissionRate
// retorna a taxa de comisso
double CommissionEmployee :: getCommissionRate () const
{
return commissionRate ;
} // fim da funo getCommissionRate
// calcula os rendimentos
double CommissionEmployee :: earnings () const
{
return commissionRate * grossSales ;
} // fim da funo earnings
// imprime o objeto CommissionEmployee
void CommissionEmployee :: print () const
{
cout << " Empregado comissionado : " << firstName << << lastName
<< " \ nNumero do seguro social : " << socialSecurityNumber
<< " \ nQuantidade de vendas : " << grossSales
<< " \ nTaxa de comissao : " << commissionRate ;
} // fim da funo print
Exemplo27/CommissionEmployee.cpp
1 // Exemplo 27: BasePlusCommissionEmployee . h
2 // Classe BasePlusCommissionEmployee derivada da classe
36
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// CommissionEmployee .
# ifndef BASEPLUS_H
# define BASEPLUS_H
# include " CommissionEmployee . h " // Declarao da classe CommissionEmployee
class BasePlusCommissionEmployee : public CommissionEmployee
{
public :
BasePlusCommissionEmployee ( const string , const string ,
const string , double = 0.0 , double = 0.0 , double = 0.0 ) ;
void setBaseSalary ( double ) ; // configura o salrio - base
double getBaseSalary () const ; // retorna o salrio - base
void print () const ; // imprime o objeto BasePlusCommissionEmployee
private :
double baseSalary ; // salrio - base
}; // fim da classe BasePlusCommissionEmployee
# endif
Exemplo27/BasePlusCommissionEmployee.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
// Exemplo 27: BasePlusCommissionEmployee . cpp

// Definies de funo membro da classe BasePlusCommissionEmployee .
using std :: cout ;
// Definio da classe BasePlusCommissionEmployee
# include " BasePlusCommissionEmployee . h "
// construtor
BasePlusCommissionEmployee :: BasePlusCommissionEmployee (
double sales , double rate , double salary )
// chama explicitamente o construtor da classe bsica
: CommissionEmployee ( first , last , ssn , sales , rate )
{
setBaseSalary ( salary ) ; // valida e armazena o salrio - base
} // fim do construtor BasePlusCommissionEmployee
// configura o salrio - base
void BasePlusCommissionEmployee :: setBaseSalary ( double salary )
{
baseSalary = ( salary < 0.0 ) ? 0.0 : salary ;
} // fim da funo setBaseSalary
// retorna o salrio - base
double BasePlusCommissionEmployee :: getBaseSalary () const
{
return baseSalary ;
} // fim da funo getBaseSalary
double BasePlusCommissionEmployee :: earnings () const
{
// pode acessar dados protected da classe bsica
return baseSalary + ( commissionRate * grossSales ) ;
// imprime o objeto BasePlusCommissionEmployee
void BasePlusCommissionEmployee :: print () const
{
37
41
// pode acessar dados protected da classe bsica
42
cout << " Empregado comissionado com salario base : " << firstName <<
43
<< lastName << " \ nNumero do seguro social : " << socialSecurityNumber
44
<< " \ nQuantidade de vendas : " << grossSales
45
<< " \ nTaxa de comissao : " << commissionRate
46
<< " \ nSalario base : " << baseSalary ;
Exemplo27/BasePlusCommissionEmployee.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
// Fig . 12.16: fig12_16 . cpp

// Testando a classe BasePlusCommissionEmployee .
using std :: cout ;
using std :: endl ;
int main ()
{
// instancia o objeto BasePlusCommissionEmployee
BasePlusCommissionEmployee
employee ( " Bob " , " Lewis " , " 333 -33 -3333 " , 5000 , .04 , 300 ) ;
// configura a formatao de sada de ponto flutuante
cout << fixed << setprecision ( 2 ) ;
// obtm os dados de empregado comissionado
cout << " Informacoes do empregado obtidas pelas funcoes get : \ n "
<< " \ nO nome e " << employee . getFirstName ()
<< " \ nO sobrenome e " << employee . getLastName ()
<< " \ nO numero do seguro social e "
<< employee . getSocialSecurityNumber ()
<< " \ nA quantidade de vendas e " << employee . getGrossSales ()
<< " \ nA taxa de comissao e " << employee . getCommissionRate ()
<< " \ nO salario base e " << employee . getBaseSalary () << endl ;
employee . setBaseSalary ( 1000 ) ; // configura o salrio - base
cout << " \ nInformacoes atualizadas do empregado utilizando a funcao print : \ n "
<< endl ;
employee . print () ; // exibe as novas informaes do empregado
cout << " \ n \ nSalario do empregado : $ " << employee . earnings () << endl ;
return 0;
} // fim de main
27.1 Herana
A herana uma forma de reutilizao de software em que o programador cria uma classe que absorve dados
e comportamentos de uma classe existente e os aprimora com novas capacidades. Ao criar uma classe, em vez
de escrever membros de dados e funes membro completamente novos, o programador pode designar que a
nova classe deve herdar membros de uma classe existente. Essa classe existente chamada classe bsica e a
nova classe referida como classe derivada.
38
27.2 Especicador de acesso protected:

Os membros protected de uma classe bsica podem ser acessados de dentro do corpo dessa classe bsica e
por membros de qualquer classe derivada dessa classe bsica. As funes membro de classe derivada podem
referenciar os membros public e protected da classe bsica simplesmente utilizando os nomes de membro.
27.3 Sintaxe inicializadora da classe bsica

O construtor introduz a sintaxe inicializadora da classe bsica, que utiliza um inicializador de membro para
argumentos passados ao construtor da classe bsica. O C++ requer que o construtor da classe derivada
chame seu construtor de classe bsica para inicializar os membros de dados da classe bsica que so herdados
na classe derivada.
28
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
Exemplo 28

// Definio da classe CommissionEmployee com boa engenharia de software .
{
public :
double = 0.0 , double = 0.0 ) ;
void setSocialSecurityNumber ( const string ) ; // configura o SSN
string getSocialSecurityNumber () const ; // retorna o SSN
private :
string firstName ;
string lastName ;
# endif
1
2
3
4
5

using std :: cout ;
39
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

// construtor
: firstName ( first ) , lastName ( last ) , socialSecurityNumber ( ssn )
{
// configura o nome
{
// retorna o nome
{
return firstName ;
{
{
return lastName ;
// configura o SSN
{
// retorna o SSN
{
{
{
return grossSales ;
{
40
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
{
{
return getCommissionRate () * getGrossSales () ;
{
cout << " Empregado comissionado : "
<< getFirstName () << << getLastName ()
<< " \ nNumero do seguro social : " << getSocialSecurityNumber ()
<< " \ nQuantidade de vendas : " << getGrossSales ()
<< " \ nTaxa de comissao : " << getCommissionRate () ;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// Exemplo 28: BasePlusCommissionEmployee . h

// Classe BasePlusCommissionEmployee derivada da classe
# ifndef BASEPLUS_H
# define BASEPLUS_H
{
public :
private :
# endif
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

using std :: cout ;
// construtor
{
41
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
setBaseSalary ( salary ) ; // valida e armazena salrio - base

{
{
return baseSalary ;
{
return getBaseSalary () + CommissionEmployee :: earnings () ;
{
cout << " Empregado comissionado com salario base \ n " ;
// invoca a funo print de CommissionEmployee
CommissionEmployee :: print () ;
cout << " \ nSalario base : " << getBaseSalary () ;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// Testando a classe BasePlusCommissionEmployee .
using std :: cout ;
using std :: endl ;
int main ()
{
// instancia o objeto BasePlusCommissionEmployee
BasePlusCommissionEmployee
employee ( " Bob " , " Lewis " , " 333 -33 -3333 " , 5000 , .04 , 300 ) ;
// obtm os dados do empregado comissionado
cout << " Informacoes do empregado obtidas pelas funcoes get : \ n "
<< " \ nO nome e " << employee . getFirstName ()
<< " \ nO sobrenome e " << employee . getLastName ()
<< " \ nO numero do seguro social e "
<< employee . getSocialSecurityNumber ()
<< " \ nA quantidade de vendas e " << employee . getGrossSales ()
<< " \ nA taxa de comissao e " << employee . getCommissionRate ()
<< " \ nO salario base e " << employee . getBaseSalary () << endl ;
employee . setBaseSalary ( 1000 ) ; // configura o salrio - base
42
35
cout << " \ nInformacoes atualizadas do empregado utilizando a funcao print : \ n "
36
<< endl ;
37
employee . print () ; // exibe as novas informaes do empregado
38
39
// exibe os rendimentos do empregado
40
cout << " \ n \ nSalario do empregado : $ " << employee . earnings () << endl ;
41
42
43
44
return 0;
45 } // fim de main
28.1 Redenio de funo membro

Quando uma funo membro de classe derivada redene uma funo membro de uma classe bsica, o membro
de classe bsica pode ser acessado a partir da classe derivada precedendo o nome do membro da classe bsica
com o nome da classe bsica e o operador (::).
29
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
Exemplo 29

// Classe CommissionEmployee representa um empregado comissionado .
{
public :
double = 0.0 , double = 0.0 ) ;
private :
string firstName ;
string lastName ;
# endif
43
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

using std :: cout ;
// construtor
{
// configura o nome
{
// retorna o nome
{
return firstName ;
{
{
return lastName ;
// configura o SSN
{
// retorna o SSN
{
{
{
return grossSales ;
44
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
{
{
{
{
cout << " empregado comissionado : "
<< " \ nnumero do seguro social : " << getSocialSecurityNumber ()
<< " \ nquantidade de vendas : " << getGrossSales ()
<< " \ ntaxa de comissao : " << getCommissionRate () ;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# ifndef BASEPLUS_H
# define BASEPLUS_H
{
public :
private :
# endif
1
2
3
4
5
6
7
8
9

using std :: cout ;
// construtor
45
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
{
{
{
return baseSalary ;
{
{
cout << " empregado comissionado com salario base \ n " ;
cout << " \ nsalario base : " << getBaseSalary () ;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// Apontando ponteiros de classe bsica e classe derivada para objetos de classe
// bsica e classe derivada , respectivamente .
using std :: cout ;
using std :: endl ;
// inclui definies de classe
# include " CommissionEmployee . h "
int main ()
{
// cria objeto de classe bsica
CommissionEmployee commissionEmployee (
" Sue " , " Jones " , " 222 -22 -2222 " , 10000 , .06 ) ;
// cria ponteiro de classe bsica
CommissionEmployee * commissionEmployeePtr = 0;
// cria objeto de classe derivada
BasePlusCommissionEmployee basePlusCommissionEmployee (
" Bob " , " Lewis " , " 333 -33 -3333 " , 5000 , .04 , 300 ) ;
46
29
// cria ponteiro de classe derivada
30
BasePlusCommissionEmployee * basePlusCommissionEmployeePtr = 0;
31
32
33
34
35
// gera sada dos objetos commissionEmployee e basePlusCommissionEmployee
36
cout << " Imprime objetos da classe basica e da classe derivada :\ n \ n " ;
37
commissionEmployee . print () ; // invoca print da classe bsica
38
cout << " \ n \ n " ;
39
basePlusCommissionEmployee . print () ; // invoca print da classe derivada
40
41
// aponta o ponteiro de classe bsica para o objeto de classe bsica e imprime
42
commissionEmployeePtr = & commissionEmployee ; // perfeitamente natural
43
cout << " \ n \ n \ nInvocando a funcao print da classe basica com ponteiro da classe "
44
<< " \ nbasica apontando para um objeto da classe basica :\ n \ n " ;
45
commissionEmployeePtr - > print () ; // invoca print da classe bsica
46
47
// aponta o ponteiro de classe derivada p / o objeto de classe derivada e imprime
48
basePlusCommissionEmployeePtr = & basePlusCommissionEmployee ; // natural
49
cout << " \ n \ n \ nInvocando a funcao print da classe derivada com ponteiro da classe "
50
<< " \ nderivada apontando para um objeto da classe derivada :\ n \ n " ;
51
basePlusCommissionEmployeePtr - > print () ; // invoca print da classe derivada
52
53
// aponta ponteiro de classe bsica para o objeto de classe derivada e imprime
54
commissionEmployeePtr = & basePlusCommissionEmployee ;
55
56
<< " \ nbasica apontando para um objeto da classe derivada :\ n \ n " ;
57
58
cout << endl ;
59
60
return 0;
61 } // fim de main
29.1 Polimorsmo
O polimorsmo ocorre quando um programa invoca uma funo virtual por meio de um ponteiro da classe
bsica. O C++ escolhe dinamicamente a funo correta para a classe a partir da qual o objeto foi instanciado.
29.2 Funes Virtuais

Quando uma funo declarada como virtual, o tipo do objeto apontado, determina qual verso de um
funo virtual invocar.
29.3 Operador ->

O operador de seleo de membro seta (->) precedido por um ponteiro para um objeto para acessar os
membros do objeto.
30
1
2
3
4
5
6
7
8
9
Exemplo 30

// Classe CommissionEmployee representa um empregado comissionado .
47
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
{
public :
double = 0.0 , double = 0.0 ) ;
virtual double earnings () const ; // calcula os rendimentos
virtual void print () const ; // imprime o objeto CommissionEmployee
private :
string firstName ;
string lastName ;
# endif
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

using std :: cout ;
// construtor
{
// configura o nome
{
// retorna o nome
{
return firstName ;
{
48
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
{
return lastName ;
// configura o SSN
{
// retorna o SSN
{
{
{
return grossSales ;
{
{
{
{
cout << " empregado comissionado : "
<< " \ nnumero do seguro social : " << getSocialSecurityNumber ()
<< " \ nquantidade de vendas : " << getGrossSales ()
<< " \ ntaxa de comissao : " << getCommissionRate () ;
1
2
3
4
5
6
7

# ifndef BASEPLUS_H
# define BASEPLUS_H
49
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

{
public :
virtual void print () const ; // imprime o objeto BasePlusCommissionEmployee
private :
# endif
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

using std :: cout ;
// construtor
{
{
{
return baseSalary ;
{
{
cout << " empregado comissionado com salario base \ n " ;
cout << " \ nsalario base : " << getBaseSalary () ;
50
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

// Introduzindo polimorfismo , funes virtual e vinculao dinmica .
using std :: cout ;
using std :: endl ;
// inclui definies de classe
int main ()
{
// cria objeto de classe bsica
" Sue " , " Jones " , " 222 -22 -2222 " , 10000 , .06 ) ;
// cria ponteiro de classe bsica
CommissionEmployee * commissionEmployeePtr = 0;
// cria objeto de classe derivada
" Bob " , " Lewis " , " 333 -33 -3333 " , 5000 , .04 , 300 ) ;
// cria ponteiro de classe derivada
BasePlusCommissionEmployee * basePlusCommissionEmployeePtr = 0;
// gera sada de objetos utilizando vinculao esttica
cout << " Invoca a funcao print dos objetos da classe basica e "
<< " \ nda classe derivada com vinculacao estatica \ n \ n " ;
commissionEmployee . print () ; // vinculao esttica
cout << " \ n \ n " ;
basePlusCommissionEmployee . print () ; // vinculao esttica
// gera sada de objetos utilizando vinculao dinmica
cout << " \ n \ n \ nInvoca a funcao print dos objetos da classe basica e "
<< " \ nda classe derivada com vinculacao dinamica " ;
// aponta o ponteiro de classe bsica para o objeto de classe bsica e imprime
commissionEmployeePtr = & commissionEmployee ;
<< " \ nbasica apontando para um objeto da classe basica :\ n \ n " ;
// aponta o ponteiro de classe derivada p / o objeto de classe derivada e imprime
basePlusCommissionEmployeePtr = & basePlusCommissionEmployee ;
cout << " \ n \ n \ nInvocando a funcao print da classe derivada com ponteiro da classe "
<< " \ nderivada apontando para um objeto da classe derivada :\ n \ n " ;
basePlusCommissionEmployeePtr - > print () ; // invoca print da classe derivada
// aponta o ponteiro de classe bsica para o objeto de classe derivada e imprime
commissionEmployeePtr = & basePlusCommissionEmployee ;
cout << " \ n \ n \ nInvocando a funcao virtual print da classe derivada com ponteiro da classe "
<< " \ nbasica apontando para um objeto da classe derivada :\ n \ n " ;
// polimorfismo ; invoca print de BasePlusCommissionEmployee ;
// ponteiro de classe bsica para objeto de classe derivada
commissionEmployeePtr - > print () ;
51
65
cout << endl ;
66
67
return 0;
68 } // fim de main
31
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
Exemplo 31
// Exemplo 31: Employee . h

// Classe bsica abstrata Employee .
# ifndef EMPLOYEE_H
# define EMPLOYEE_H
class Employee
{
public :
Employee ( const string , const string , const string ) ;
// a funo virtual pura cria a classe bsica abstrata Employee
virtual double earnings () const = 0; // virtual pura
virtual void print () const ; // virtual
private :
string firstName ;
string lastName ;
}; // fim da classe Employee
# endif // EMPLOYEE_H
Exemplo31/Employee.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// Exemplo 31: Employee . cpp

// definies de funo membro da classe bsica abstrata Employee .
// Nota : Nenhuma definio recebe funes virtuais puras .
using std :: cout ;
# include " Employee . h " // Definio da classe Employee
// construtor
Employee :: Employee ( const string first , const string last ,
const string ssn )
{
// corpo vazio
} // fim do construtor Employee
// configura o nome
void Employee :: setFirstName ( const string first )
{
firstName = first ;
52
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
// retorna o nome
string Employee :: getFirstName () const
{
return firstName ;
void Employee :: setLastName ( const string last )
{
lastName = last ;
string Employee :: getLastName () const
{
return lastName ;
// configura o SSN
void Employee :: setSocialSecurityNumber ( const string ssn )
{
// retorna o SSN
string Employee :: getSocialSecurityNumber () const
{
// imprime informaes de Employee ( virtual , mas no virtual pura )
void Employee :: print () const
{
cout << getFirstName () << << getLastName ()
<< " \ nNumero do seguro social : " << getSocialSecurityNumber () ;
Exemplo31/Employee.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Exemplo 31: SalariedEmployee . h

// Classe SalariedEmployee derivada de Employee .
# ifndef SALARIED_H
# define SALARIED_H
class SalariedEmployee : public Employee
{
public :
SalariedEmployee ( const string , const string ,
const string , double = 0.0 ) ;
void setWeeklySalary ( double ) ; // configura o salrio semanal
double getWeeklySalary () const ; // retorna o salrio semanal
// palavra - chave virtual assinala inteno de sobrescrever
virtual void print () const ; // imprime objeto SalariedEmployee
private :
double weeklySalary ; // salrio por semana
}; // fim da classe SalariedEmployee
# endif // SALARIED_H
Exemplo31/SalariedEmployee.h
53
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
// Exemplo 31: SalariedEmployee . cpp

// Definies de funo membro da classe SalariedEmployee .
using std :: cout ;
# include " SalariedEmployee . h " // Definio da classe SalariedEmployee
// construtor
SalariedEmployee :: SalariedEmployee ( const string first ,
const string last , const string ssn , double salary )
: Employee ( first , last , ssn )
{
setWeeklySalary ( salary ) ;
} // fim do construtor SalariedEmployee
// configura o salrio
void SalariedEmployee :: setWeeklySalary ( double salary )
{
weeklySalary = ( salary < 0.0 ) ? 0.0 : salary ;
} // fim da funo setWeeklySalary
// retorna o salrio
double SalariedEmployee :: getWeeklySalary () const
{
return weeklySalary ;
} // fim da funo getWeeklySalary
// calcula os rendimentos ;
// sobrescreve a funo virtual pura earnings em Employee
double SalariedEmployee :: earnings () const
{
return getWeeklySalary () ;
// imprime informaes de SalariedEmployee
void SalariedEmployee :: print () const
{
cout << " Empregado assalariado : " ;
Employee :: print () ; // reutiliza funo print da classe bsica abstrata
cout << " \ Salario por semana : " << getWeeklySalary () ;
Exemplo31/SalariedEmployee.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Exemplo 31: HourlyEmployee . h

// Definio da classe HourlyEmployee .
# ifndef HOURLY_H
# define HOURLY_H
class HourlyEmployee : public Employee
{
public :
HourlyEmployee ( const string , const string ,
const string , double = 0.0 , double = 0.0 ) ;
void setWage ( double ) ; // configura o salrio por hora
double getWage () const ; // retorna o salrio por hora
void setHours ( double ) ; // configura as horas trabalhadas
double getHours () const ; // retorna as horas trabalhadas
virtual void print () const ; // imprime o objeto HourlyEmployee
private :
double wage ; // salrio por hora
54
25
double hours ; // horas trabalhadas durante a semana
26 }; // fim da classe HourlyEmployee
27
28 # endif // HOURLY_H
Exemplo31/HourlyEmployee.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
// Exemplo 31: HourlyEmployee . cpp

// Definies de funo membro da classe HourlyEmployee .
using std :: cout ;
# include " HourlyEmployee . h " // Definio da classe HourlyEmployee
// construtor
HourlyEmployee :: HourlyEmployee ( const string first , const string last ,
const string ssn , double hourlyWage , double hoursWorked )
{
setWage ( hourlyWage ) ; // valida a remunerao por hora
setHours ( hoursWorked ) ; // valida as horas trabalhadas
} // fim do construtor HourlyEmployee
// configura a remunerao
void HourlyEmployee :: setWage ( double hourlyWage )
{
wage = ( hourlyWage < 0.0 ? 0.0 : hourlyWage ) ;
} // fim da funo setWage
// retorna a remunerao
double HourlyEmployee :: getWage () const
{
return wage ;
} // fim da funo getWage
// configura as horas trabalhadas
void HourlyEmployee :: setHours ( double hoursWorked )
{
hours = ( ( ( hoursWorked >= 0.0 ) && ( hoursWorked <= 168.0 ) ) ?
hoursWorked : 0.0 ) ;
} // fim da funo setHours
// retorna as horas trabalhadas
double HourlyEmployee :: getHours () const
{
return hours ;
} // fim da funo getHours
double HourlyEmployee :: earnings () const
{
if ( getHours () <= 40 ) // nenhuma hora extra
return getWage () * getHours () ;
else
return 40 * getWage () + ( ( getHours () - 40 ) * getWage () * 1.5 ) ;
// imprime informaes do HourlyEmployee
void HourlyEmployee :: print () const
{
cout << " Empregado com salario por hora trabalhada : " ;
Employee :: print () ; // reutilizao de cdigo
cout << " \ nSalario por hora : " << getWage () <<
" ; Horas trabalhadas : " << getHours () ;
Exemplo31/HourlyEmployee.cpp
55
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// Classe CommissionEmployee derivada de Employee .
class CommissionEmployee : public Employee
{
public :
CommissionEmployee ( const string , const string ,
const string , double = 0.0 , double = 0.0 ) ;
virtual void print () const ; // imprime o objeto CommissionEmployee
private :
# endif // COMMISSION_H
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

using std :: cout ;
// construtor
CommissionEmployee :: CommissionEmployee ( const string first ,
const string last , const string ssn , double sales , double rate )
{
setGrossSales ( sales ) ;
setCommissionRate ( rate ) ;
{
commissionRate = ( ( rate > 0.0 && rate < 1.0 ) ? rate : 0.0 ) ;
{
{
grossSales = ( ( sales < 0.0 ) ? 0.0 : sales ) ;
56
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
{
return grossSales ;
{
// imprime informaes do CommissionEmployee
{
cout << " Empregado comissionado : " ;
Employee :: print () ; // reutilizao de cdigo
cout << " \ nQuantidade de vendas : " << getGrossSales ()
<< " ; Taxa de comissao : " << getCommissionRate () ;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// Classe BasePlusCommissionEmployee derivada de Employee .
# ifndef BASEPLUS_H
# define BASEPLUS_H
{
public :
virtual void print () const ; // imprime o objeto BasePlusCommissionEmployee
private :
double baseSalary ; // salrio - base por semana
# endif // BASEPLUS_H
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// Definies de funo membro BasePlusCommissionEmployee .
using std :: cout ;
// construtor
{
57
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

{
baseSalary = ( ( salary < 0.0 ) ? 0.0 : salary ) ;
{
return baseSalary ;
{
// imprime informaes de BasePlusCommissionEmployee
{
cout << " com salario base " ;
CommissionEmployee :: print () ; // reutilizao de cdigo
cout << " ; Salario base : " << getBaseSalary () ;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

// Processando objetos da classe derivada Employee individualmente
// e polimorficamente utilizando vinculao dinmica .
using std :: cout ;
using std :: endl ;
// inclui definies de classes na hierarquia Employee
# include " SalariedEmployee . h "
# include " HourlyEmployee . h "
void virtualViaPointer ( const Employee * const ) ; // prottipo
int main ()
{
// cria objetos da classe derivada
SalariedEmployee salariedEmployee (
" John " , " Smith " , " 111 -11 -1111 " , 800 ) ;
HourlyEmployee hourlyEmployee (
" Karen " , " Price " , " 222 -22 -2222 " , 16.75 , 40 ) ;
" Sue " , " Jones " , " 333 -33 -3333 " , 10000 , .06 ) ;
" Bob " , " Lewis " , " 444 -44 -4444 " , 5000 , .04 , 300 ) ;
cout << " Empregados processados individualmente usando vinculacao estatica :\ n \ n " ;
// gera sada de informaes e rendimentos dos Employees com vinculao esttica
salariedEmployee . print () ;
cout << " \ nSalario $ " << salariedEmployee . earnings () << " \ n \ n " ;
58
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
hourlyEmployee . print () ;
cout << " \ nSalario $ " << hourlyEmployee . earnings () << " \ n \ n " ;
commissionEmployee . print () ;
cout << " \ nSalario $ " << commissionEmployee . earnings () << " \ n \ n " ;
basePlusCommissionEmployee . print () ;
cout << " \ nSalario $ " << basePlusCommissionEmployee . earnings ()
<< " \ n \ n " ;
// cria um array com quatro ponteiros da classe bsica
Employee * employees [4];
// inicializa o vector com Employees
employees [ 0 ] = & salariedEmployee ;
employees [ 1 ] = & hourlyEmployee ;
employees [ 2 ] = & commissionEmployee ;
employees [ 3 ] = & basePlusCommissionEmployee ;
cout << " Empregados processados polimorficamente usando vinculacao dinamica :\ n \ n " ;
// chama virtualViaPointer para imprimir informaes e rendimentos
// de cada Employee utilizando vinculao dinmica
cout << " Funcao virtual chamada por ponteiros da classe basica :\ n \ n " ;
for ( size_t i = 0; i < 4; i ++ )
virtualViaPointer ( employees [ i ] ) ;
return 0;
} // fim de main
// chama funes print e earnings virtual de Employee a partir de um
// ponteiro de classe bsica utilizando vinculao dinmica
void virtualViaPointer ( const Employee * const baseClassPtr )
{
baseClassPtr - > print () ;
cout << " \ nSalario $ " << baseClassPtr - > earnings () << " \ n \ n " ;
} // fim da funo virtualViaPointer
31.1 Classe abstrata e classe concreta

Classes abstratas no podem ser utilizadas para instanciar objetos, porque as classes abstratas so incompletas, as classes derivadas devem denir as partes ausentes. Como essas classes so normalmente utilizadas
como classes bsicas em hierarquias de herana, elas so referidas como classes bsicas abstratas.
O propsito de uma classe abstrata fornecer uma classe bsica apropriada a partir da qual outras classes
podem herdar. As classes que podem ser utilizadas para instanciar objetos so chamadas classes concretas.
31.2 Funo virtual pura

Uma classe torna-se abstrata declarando uma ou mais de suas funes virtual como "puras". As funes
virtual puras no fornecem implementaes. Toda classe derivada concreta deve sobrescrever todas as
funes virtual puras da classe bsica com implementaes concretas dessas funes.
A diferena entre uma funo virtual e uma funo virtual pura que a funo virtual tem uma
implementao e d classe derivada a opo de sobrescrever a funo. Em contraste, uma funo virtual
pura no fornece uma implementao e requer que a classe derivada sobrescreva a funo.
1 virtual void draw () const = 0; // funo virtual pura
59
Referncias
[1]
Deitel, H., and Deitel, P.
C++: Como Programar, 5 ed. Pearson Prentice Hall, 2006.
60

Programação Orientada A Objetos

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Programação Orientada A Objetos

Uploaded by

Copyright:

Available Formats

1

// Exemplo 01: exemplo01 . cpp

1.2 int main()

1.5 Operador de insero de uxo (<<)

// Exemplo 02: exemplo02 . cpp

2.2 Operador de extrao de uxo (>>)

// Exemplo03 : exemplo03 . cpp

// Definio da classe GradeBook

3.1 using std::cout

3.2 Especicador de acesso public:

3.3 Especicador de acesso private:

3.5 Operador ponto (.)

// Exemplo04 : exemplo04 . cpp

// Definio da classe GradeBook

// Exemplo 05: GradeBook . h

using std :: string ;

// Exemplo 05: exemplo05 . cpp

// a funo main inicia a execuo do programa

// Exemplo 06: GradeBook . cpp

# include < iostream >

// a funo main inicia a execuo do programa

6.1 Prottipo de Funo

// Exemplo 07: GradeBook . h

// implementaes das funes - membro prototipadas em GradeBook . h

# include < iomanip > // manipuladores de fluxo parametrizados

// Exemplo 07: exemplo07 . cpp

# include " GradeBook . h " // inclui a definio de classe GradeBook

// a funo main inicia a execuo do programa

// Exemplo 08: exemplo08 . cpp

using std :: rand ;

int face ; // armazena o valor lanado mais recente

// Exemplo 09: exemplo09 . cpp

square (7) ; // chama verso int

system ( " pause " ) ;

9.1 Sobrecarga de funes

// Exemplo 10: Time . h

// Exemplo 10: Time . cpp

// configura valor de hour

// Exemplo 10: exemplo10 . cpp

todos os argumentos convertidos para sua configurao padro

Time t5 (27 , 74 , 99) ; // valores invlidos especificados

10.2 Empacotador de pr-processador

10.3 Construtores com argumentos-padro

10.4 Variveis Constantes

10.5 Objetos Constantes

10.6 Funes Membro Constantes

// Exemplo 11: Increment . h

// Exemplo 11: Increment . cpp

// Exemplo 11: exemplo11 . cpp

11.1 Inicializador de membro

// Exemplo 12: exemplo12 . cpp

// Exemplo 12: Employee . cpp

# include < iostream >

" Empregado 1: " << employee1 . getFirstName ()

12.1 Variveis locais static

12.2 Membros de classe static

1 // Exemplo 13: exemplo13 . cpp

using std :: cout ;

13.2 Declarando arrays

1 int c [12]; // c um array de 12 inteiros

// Exemplo 14: exemplo14 . cpp

using std :: setw ;

// Exemplo 15: exemplo15 . cpp

1.5 Operador de insero de uxo (<<)

2.2 Operador de extrao de uxo (>>)

3.2 Especicador de acesso public:

3.3 Especicador de acesso private:

27.2 Especicador de acesso protected:

28.1 Redenio de funo membro