Cursinho Online - C - Desenvolvimento Orientado a Objeto

Prévia do material em texto

C ++ - Desenvolvimento Orientado a Objeto
Módulo 01 – Introdução
Apresentação
	Neste curso, você aprenderá a implementar técnicas de programação orientada a objeto usando o Microsoft Visual C++.
	O C++ é construído sobre as bases do C e suporta conceitos de desenvolvimento de software como classes e objetos.
	O objetivo desta unidade de estudo é lhe proporcionar conhecimentos, competências e habilidades no desenvolvimento de aplicações em C++.
	As aulas foram elaboradas para que você possa compreender, o mais rápido possível, as informações sobre esta ferramenta.
	As atividades propostas foram cuidadosamente desenvolvidas para facilitar a assimilação das explicações. Assim, você constrói, a seu tempo, o conhecimento necessário para desenvolver suas aplicações.
Introdução
Introdução
	O primeiro passo quando vamos iniciar um projeto é identificar e saber o que são Sistemas Orientados a Objetos.
Objetivo
	Neste módulo você conhecerá os recursos do C++ em relação ao C.
	Você também aprenderá a executar operações de E/S e conversões de tipo em um programa C++.
Conteúdo 
· Construindo classes
· Estilos de comentários
· Escopo de variáveis
· Declarando variáveis locais ou globais
· Alocando memória dinamicamente com operadores
· Usando referência para passar valores para funções
· Bibliotecas especiais de classes
· Operador de deslocamento à esquerda para fluxo de saída
· Operador de deslocamento à direito para fluxo de entrada
· Conversão de tipos de dados
Características do C++
Classe
	Um dos aprimoramentos do C++ em relação ao C é a construção class.
	Você usa uma construção class para definir novos tipos de dados.
	A construção class combina membros de dados e funções de membros em uma única unidade.
Entradas de comentários
	Outro aprimoramento do C++ está no método de delimitação de entradas de comentários.
	Além dos comentários no estilo do C, delimitados por /* e */, o C++ fornece o estilo de comentários //.
	Todas as palavras na linha depois de // são ignoradas pelo compilador, como se fizessem parte de um comentário.
Int main ( )
{
...
/ / Esta é uma linha de comentário
}
	Os programas C++ contém uma mistura dos dois tipos de comentários. Explicações em várias linhas são geralmente delimitadas por partes de comentários /* e */, Os comentários em uma única linha são delimitados por barras duplas //.
Operador de resolução de escopo
	O C++ define o operador de resolução de escopo (::) para acessar uma variável oculta em um escopo.
	Cada variável definida em um programa tem um escopo distinto e é visível apenas em seu escopo.
Int a = 1;
void main ( )
{
	int a = 3;
	printf(“local a = ﱡd \d \n”, a) ;
	printf (“global a = ﱡd \n”, : :a) ;
}
local a = 3 // saída
global a = 1
	O exemplo ao lado atribui o valor 1 à variável global a e o valor 3 à variável local a.
	Quando você imprime os valores de a, obtém valores diferentes da variável a.
	O operador de resolução de escopo (::) recupera o valor global de a que está oculto no escopo atual.
	Você também pode usar o operador de resolução de escopo para declarar uma função de uma determinada classe. Por exemplo, a instrução abaixo “numlegs()” implica uma função de membro da classe Animal.
Animal : : numlegs ( )
Uso do marcador Struct
	Outro aprimoramento do C++ está no uso do marcador Struct.
	O fragmento de código C, apresentado abaixo, usa o marcador struct para criar uma instância de eg chamada x.
	Em um programa C++, eg x cria uma instância de eg chamada x.
struct eg
{
int a;
	float b;
 } ; /* C style */
 struct eg x
 struck eg
 {
	int a;
	float b;
 } ; / / C++ style
 egx;
Uso do especificador const
	No C++, você pode usar const para declarar variáveis locais ou globais cujos valores permanecem fixos.
	Abaixo um exemplo de como você pode usar const em um programa C++.
const int SizeOfArray = 20;
/ / linha 1 declara o tamanho de matriz como uma const int
char mesg1 [SizeOfArray];
/ / linha 2 declara uma matriz fazia de tamanho SizeOfArray
	Você pode definir um conjunto de constantes em um arquivo de cabeçalho e incluir esse arquivo de cabeçalho em vários arquivos de programas. Isso equivale a definir todas a constantes separadamente em cada arquivo de programa.
	O C++ trata uma definição const como uma definição estática por padrão. Nos segmentos de programa mostrados abaixo, NumOfDigits vai reter seu valor entre chamadas de funções.
program Segment A
const int NumOfDigits = 50;
int main (void)
{
. . .
}
Program Segment B
static const int NumOfDigits = 50;
int main (void)
{
. . .
}
Alocação dinâmica da memória
	Outro aprimoramento do C++ em relação ao C é a forma como a memória é alocada às variáveis.
	Nos programas C, a alocação dinâmica de memória é tratada por funções de biblioteca, como malloc() e free().
	O C++ usa operadores em vez de funções para alocar dinamicamente memória às variáveis.
	
malloc ()
free ()
	Os operadores new e delete no C++ executam operações similares às funções malloc() e free(), respectivamente.
	Você usa o operador new para alocar memória às variáveis e o operador delete para tirar a memória das variáveis.
void func ()
{
int *i;
i = (int *) ;
malloc(sizeof(int) ) ; /* C style */
		free (i) ;
	}
	void func ()
	{
		int *i = new int; //C++ style
		delete i;
	}
	Definindo a alocação de memória em termos de operadores em vez de funções, o C++ reduz a sobrecarga de chamadas de função e oferece um gerenciamento mais rápido de memória dinâmica.
Uso de referências
	O C++ usa referências para passar valores para funções.
	Uma referência é um nome alternativo de uma variável, definida anteriormente em um programa.
	Uma referência é indicada usando-se o operador &, da mesma forma que um ponteiro é indicado usando-se o operador *. Por exemplo, você pode declarar a variável rodents como uma referência para a variável rats.
int rats;
intﱡ rodents = rats;
 / / Faça da variável rodents uma referência para rats
	O uso principal de uma referência é na passagem de um argumento para uma função.
	Ao usar uma referência como argumento, a função trabalha com os dados originais, em vez de uma cópia. Esse método de passar argumentos para uma função é chamado de passagem por referência.
Características do C++
	O C++ fornece uma biblioteca especial de classes – chamada biblioteca de fluxos – para tratar das operações de entrada e saída em programas C++. Essas classes são definidas no arquivo de cabeçalho iostream.h.
	Quando você inclui o arquivo de cabeçalho iostream.h em um programa, o C++ cria, automaticamente, quatro objetos para tratar das operações de entrada e saída. Os objetos cin, cout, cerr e clog são anexados aos dispositivos padrão de entrada e saída.
	Clique no nome de um objeto para saber mais sobre ele.
	
CIN
O objeto cin corresponde ao fluxo de entrada padrão, que aceita entradas vindas de um teclado.
CERR
	O objeto cerr corresponde ao fluxo de erro padrão. Você usa o objeto cerr para alertar o usuário de alguma condição de exceção que ocorra no programa durante a execução, como, por exemplo, uma tentativa de divisão por 0.
	Por padrão, o fluxo cerr não é colocado em buffer. Em um fluxo não colocado em buffer, a informação é enviada diretamente para a tela, sem esperar que um buffer seja cheio.
COUT
	O objeto cout corresponde ao fluxo padrão de saída, que direciona a saída para a tela.
CLOG
	O objeto clog corresponde ao fluxo padrão de erro que direciona a saída para a tela.
	O C++ fornece os operadores para escrever dados no fluxo de saída e buscar dados no fluxo de entrada. O código lista os operadores que você pode usar para escrever e buscar dados.
<< / / inserir operador
>> / / extrair operador
	O C++ fornece o operador de deslocamento à esquerda (<<) para enviar caracteres para um fluxo de saída. O operador >>, quando usado para direcionar valores para a saída padrão, é conhecido como operador de inserção.
	O exemplo abaixoilustra o uso de << com cout. O operador << aceita uma cadeia como argumento e a armazena no objeto de fluxo cout.
cout << “Hello”;
	Você pode usar o operador de inserção mais de uma vez em uma única instrução, para executar diversas operações de saída.
	No exemplo exibido abaixo, tanto o nome da variável quanto o valor são exibidos usando-se uma única instrução.
void display (char *name, int value)
{
 cout << name << “\n” << value << “\n”;
}
	O processo de busca de dados no fluxo de entrada é chamado de extração do fluxo.
	O C++ fornece o operador de deslocamento à direita (>>), para buscar dados no fluxo de entrada. O operador >>, quando usado para ler valores da entrada padrão, é conhecido como o operador de extração.
	O exemplo ao lado mostra o uso de >> com cin. O operador >> aceita uma cadeia de caracteres do teclado e a armazena na variável name.
Void main (void)
{
 char name [14] ;
 cout << “Enter student name. \n”;
 cin >> name;
}
	Você também pode usar o operador de extração mais de uma vez, em uma única instrução, para executar diversas operações de entrada.
	No exemplo abaixo, >> é usado para ler duas variáveis diferentes, name e age.
Void main (void)
{	
 char name [20] ;
 int age;
 cin >> name >> age;
}
	Você agora vai aprender sobre conversões de tipos em C++.
	A conversão de tipo envolve a conversão de uma variável de um tipo de dado específico para um outro tipo de dado. Por exemplo, em C, você pode atribuir um valor int a uma variável long ou adicionar um valor long a uma variável float.
	Em C++, a inicialização e a atribuição de valores sã verificados no momento da compilação, para garantir que os tipos de dados desses valores coincidam.
	Há duas formas de conversão de tipos no C++:
· implícita
· explícita
As conversões implícitas são implementadas pelo compilador, sem a intervenção do programador.
As conversões explícitas são implementadas, exclusivamente, pelo programador.
Uma conversão implícita ocorre quando tipos de dados diferentes são misturador. Por exemplo, quando você atribui um valor int a uma variável long, o compilador faz uma conversão implícita.
As conversões implícitas também ocorrem ao atribuir valores e a passar esses valores a funções.
	Passar um valor para uma função converte o valor para o tipo de dado do argumento de função. Atribuir um valor a um objeto converte o valor para o tipo do objeto.
	O exemplo abaixo, ilustra a conversão do tipo de dado float para o tipo de dado int.
A saída desse segmento de programa também é mostrada abaixo.
A variável guess foi declarada como um número inteiro. Atribuir um valor float à guess resulta na conversão de float para int.
void main (void)
{
int guess = 3.92666;
count << “guess = ” << guess; ;
}
guess = 3 / / saída
A conversão implícita também é possível nas classes e é obtida definindo-se um construtor de conversão.
Um construtor é uma função usada para inicializar elementos de dados de uma classe com valores padrão.
Quando você usa um construtor de conversão, o tipo do argumento do construtor de conversão é convertido para o tipo do objeto da classe. Por exemplo, o construtor mostrado no código ao lado converte um valor int em um valor do tipo Complex, que é um tipo de dado definido pelo usuário.
Complex: :Complex (int i)
{
real = (double) i;
imag = 0 . 0;
}
Em geral, qualquer construtor que leva um único argumento atua como um modelo para a conversão de um valor daquele tipo de argumento para o tipo da classe. Por exemplo, o construtor Stonew(int Ibs) atua como um modelo de conversão de int para Stonewt. De forma similar, Stonewt (double Ibs) atua como um modelo de conversão de double para Stonewt.
Visualizando o código
class Stonewt
 {
	private :
	 int stone ;
	 double psd_left ;
		 / / parte decimal
	 double pounds ;
		 / / valor total
 public :
	 Stonewt (int lbs) ;
	 / / constrói uma medida int
	 Stonewt (int stn, double lbs) ;
		 / / constrói stone, medida
	 ~ Stonewt ( ) ;
	 / / destruídor
	 . . . .
} ;
	Você não pode usar construtores de conversão para converter objetos de classe em outros tipos de dados. Você pode usá-los apenas em atribuições e inicializações.
	Você agora vai aprender sobre a conversão explícita.
	A conversão explícita é a conversão forçada, pelo programador, de um determinado tipo de dado para outro tipo de dado.
	No exemplo abaixo, você não pode usar a instrução para atribuir o endereço 2 a um ponteiro p. Ocorre falha na instrução de atribuição, porque o lado esquerdo é um ponteiro, ao passo que o lado direito é um número.
int *p = 2; / / type mismatch
	No entanto, você pode converter, explicitamente, o número 2 em um ponteiro para um inteiro. Essa instrução exibida na figura define um ponteiro para o endereço 2, convertendo 2 em um ponteiro para um número inteiro.
int *p = (int *)2; / / nítida conversão
	A conversão explícita também é possível para classes. Uma conversão explícita de classe é conseguida definindo-se uma função de conversão.
Resumo
	Neste módulo abordamos:
· O construtor classe combina membros de dados e funções de membros em uma única unidade.
· Além dos comentários no estilo C, delimitados por /* e */, o C++ oferece o estilo de comentários com //.
· Para acessar uma variável oculta em um escopo, o C++ define o operador de resolução de escopo.
· No C++, você pode usar const para declarar variáveis locais ou globais.
· O C++ usa operadores em vez de funções para alocar memória dinamicamente.
· O C++ usa referências para passar valores para funções.
· O C++ oferece uma biblioteca especial de classes, chamada biblioteca de fluxos, para lidar com operações de entrada e saída.
· O C++ oferece o operador de deslocamento à esquerda (<<), para enviar caracteres para um fluxo de saída.
· O C++ fornece o operador de deslocamento à direita (>>), para buscar dados de um fluxo de entrada.
· A conversão de tipo envolve a conversão de uma variável de um determinado tipo de dado em um outro tipo de dado. Há duas formas de conversão de tipos: implícita e explícita.
Módulo 02 – Recursos do C++
Introdução
Introdução
	Identificar objetos e entender a hierarquia no conceito de escopo é um conhecimento imprescindível para desenvolvimento de um Sistema Orientado a Objetos.
Objetos
· Aprender a usar a construção class
· Aprender a usar os construtores e destruidores
· Definir o escopo de uma variável em um programa C++
Conteúdo 
· Construir classes
· Destruir classes
· Escopo de variáveis
Características do C++
A construção class
Uma classe é um tipo de dado definido pelo usuário.
	Uma definição de classe tem duas partes:
· Cabeça da classe
· Corpo da classe
A cabeça da classe consiste na palavra-chave class e o nome do marcador da classe.
O corpo da classe é cercado por um par de chaves seguidas de um ponto e vírgula ou de uma lista de declarações terminada por um ponto e vírgula.
Abaixo, dois exemplos de uma definição de classe.
class Screen { . . . } ;
class Video { . . . } myvideo,
yourvideo ;
O método de definição de uma classe m C++ é diferente de struct em C. Diferente de struct em C, você pode incluir funções na classe.
O código ao lado mostra a diferença entre struct em C, e classe em C++.
	
struct example /* C style */
	{
	 int i, j;
	}
	Class Example / / C++ style
	{
	 int i, j; / /Data Functions
	 void func10
	 {
	 cout << “Hello”;
	int sum (int x, int y)
	 {
	 return x+y;
	};
	Você precisa definir uma classe antes de usá-la. Para definir uma classe, é necessário agrupar os membros de dados e as funções de membro que acessam esses membros de dados em uma unidade.
	Pode haver zero ou mais membros de dados (de qualquer tipo de dado) em uma classe.
	Uma função de membro édefinida em uma classe e descreve um método para manipular membros de dados da classe.
	Pode haver ou mais funções de membros para uma classe.
	A abaixo temos a definição da classe Complex, onde cp_set, cp_print, cp_add e cp_sub são as funções de membros. real e imag são os membros de dados da classe Complex.
class Complex
{
 double real, imag;
 complex cp_set (double r, double i)
 void cp_print (Complex c)
 complex cp_add (Complex c1, Complex c2) ;
 complex cp_sub (Complex c1, Complex c2) ;
};
	Quando um objeto é criado, os membros de dados precisam ser inicializados. O C++ permite que você inicialize membros de dados de uma classe definindo um construtor.
	Um construtor de uma classe é uma função de membro com o mesmo nome que a classe. Considere o construtor para a classe Circle, no código ao lado. Quando você declara um objeto da classe Circle, você fornece três valores para inicializar as coordenadas e o raio do objeto.
class Circle
	{
	private:
	 int ctr_x, ctr_y;
	 double radius;
public:
	 Circle (int x, int y, double r) / /construtor
	 {
	 radius = r;
	 ctr_x = x;
	 ctr_y = Y;
	 }
} ;
	Um construtor é declarado dentro da definição de classe. No entanto, o corpo do construtor pode ocorrer fora da definição de classe.
	Por exemplo, na classe Complex, o construtor Complex inicializa um novo objeto. O corpo do construtor é definido fora da definição de classe.
	class Complex
	{
	private:
	 double real, imag;
	public:
	 Complex (double r, double i) ;
		 / / declara o construtor
 } ;
	Complex (double r, double i)
	 / / define um construtor complexo
	 {
	 real = r;
	 imag = i;
	 }
	Um construtor pode ter parâmetros como qualquer outra função, mas não pode ter um valor de retorno. Essa restrição é imposta porque você usa construtores ao declarar um novo objeto.
	Uma classe pode ter mais de um construtor. Um construtor de classe é chamado quando um programa cria um objeto dessa classe.
	Uma classe derivada pode não ter membros de dados adicionais além dos membros da classe base. Nesse caso, o construtor da classe derivada pode ter um corpo vazio.
	O compilador C++ gera um construtor padrão se não for definido nenhum construtor para a classe. Um construtor padrão é um construtor sem argumentos.
	Você pode declarar um construtor como uma função de membro pública, protegida ou privada de uma classe.
	O C++ fornece duas forma de se inicializar um objeto usando construtores, explícita e implícita. Por exemplo, o código abaixo inicializa um objeto explicitamente. O fragmento de código define 1.0 como a parte real do número complexo e 2.0 como a parte imaginária.
Complex r = complex (1 . 0 , 2 . 0) ;
	No fragmento de código mostrado abaixo, o objeto r é inicializado implicitamente. A parte real do número complexo é definida como 1.0 e a parte imaginária é definida como 2.0.
Complex r (1 . 0 , 2 . 0) ;
	É importante observar que quando você cria um objeto, o armazenamento necessário para conter os membros de dados definidos para sua classe é alocado automaticamente. Os construtores servem apenas para inicializar o armazenamento recém alocado associado a um objeto de classe.
	Para excluir um objeto, você precisa desativar o objeto. Você desativa um objeto definindo uma função especial chamada destruidor.
	Você pode também usar destruidores para executar qualquer operação que o programador desejar executar como o último uso do objeto, como, por exemplo, salvar o conteúdo do objeto no disco.
	Para declarar um destruidor, você atribui o mesmo nome da classe e adiciona um til (~) ao nome. Um destruidor não aceita nenhum argumento porque ele desaloca a memória do objeto inteiro. No exemplo mostrado no código abaixo, ~Piece() é o destruidor de um objeto da classe Piece.
	class Piece
	{
	 private:
	 void *p;
	 public:
	 Piece (insigned int q) / /
	construtor
	 {
	 p = new char [q] ;
	 }
	 ~ Piece ( ) / / destruidor
	 {
	 delete p;
	 }
 } ;
	Você pode também definir um destruidor fora da definição de classe.
	class Piece
	{	
	 private:
	 void *p;
	 public:
	 . . .
	 ~ Piece ( ) / / destruidor
	} ;
	Piece : : ~Piece ( ) ;
 	 {
	 delete p;
	 } ;
	Uma classe pode ter apenas um destruidor. Como um construtor, um destruidor não tem tipo de retorno.
	Quando um objeto é criado na memória, os membros de dados são inicializados pelo construtor. Cada objeto mantém seu próprio conjunto de membros de dados. No entanto, as instâncias de objetos não carregam uma cópia de todas as funções de membro dentro dela. Existe apenas uma cópia das funções de membro na memória.
	Quando uma função de membro é invocada, todos os objetos chamam a mesma cópia da função de membro.
	A função de membro usa o ponteiro this para identificar o objeto que está invocando a função.
	O ponteiro this é criado automaticamente pelo compilador. Você não precisa declarar o ponteiro this explicitamente.
	O código abaixo, declarar os dois objetos eg1 e eg2 do tipo Example. Vamos ver como você pode usar o ponteiro this para distinguir entre a função get() associada aos dois objetos, eg1 e eg2.
	class Example
	{
	 int i;
	 get ( ) ;
	 . . .
	 }eg1, eg2;
	Example : : get ( )
	 {
	 i=28;
	 . . .
	 }
	O ponteiro this ajuda o compilador na identificação do objeto ao qual um membro de dado específico está associado. Quando você cria os objetos de classe eg1 e eg2, um ponteiro this separado fica associado aos membros de ambos os objetos. Quando você atribui um valor à variável i, o ponteiro this transmite para o compilador que esse i é um membro do objeto eg1 (ou eg2) da classe Example.
	O compilador C++ gera automaticamente um ponteiro this para cada função de membro de uma classe. O ponteiro this é declarado implicitamente pata todas as classes.
<class name> *this;
	Você pode tirar a referencia ao ponteiro this para retornar os valores dos membros de dados do objeto. O exemplo do código abaixo mostra como você pode fazer isso usando *this.
	Vector Vector : : add ( )
	 {
	. . .
	return *this; / / retorna o objeto
	chamado
	 }
	Você agora vai aprender sobre especificadores de acesso. Especificadores de acesso controlam o acesso aos membros de dados e às funções de membros de uma classe. Ao lado os três tipos de especificadores de acesso.
· public
· private
· protected
Os membros de dados e as funções de membros listados na seção public de uma classe podem ser acessados por todas as classes do programa. No exemplo abaixo, os membros de dados legs e color são declarados public, podendo ser acessados por todas as classes do programa.
class Bug
{
public:
 int legs, color;
	. . .
} ;
Os membros de dados e as funções de membros listados na seção private de uma classe podem ser acessados apenas pela própria classe. No exemplo abaixo, os membros legs e color não podem ser acessados fora da classe.
class Bug
{
private:
 int legs, color;
 . . .
} ;
Os membros de dados e as funções de membros listadas na seção protected de uma classe podem ser acessados apenas pela classe e por suas classes derivadas. No exemplo ao lado, os membros de dados legs e color são acessíveis para a classe derivada Humbug.
class Bug
{
protected:
 int legs, color;
	. . .
} ;
ClassHumbug : public Bug
{
 / / legendas e cores são acessível 
aqui
}
É uma boa ideia declarar as funções como public. As funções public podem fornecer acesso aos membros de dados privados de uma classe.
Características do C++ - Definição de escopo
	Escopo é a parte de um programa onde uma determinada variável é acessível. Uma variável tem um escopo associado que, juntamente com o nome de variável, identifica a variável de forma única.
	O escopo de uma variável se estende entreo ponto de declaração da variável e a chave de fechamento mais próxima dentro da qual a variável é declarada.
	void main ( )
	{
 int c1;
	 {
	 int c2; / / c1 e c2 são validados
 aqui
	 {
	 int c3; / / c1, c2, c3 são 
 validados aqui 
	 }
	 / / c1, c2 são validados, mas c3 
 não é	 validado aqui
	 }
	 / / somente c1 é validado aqui
	}
Características do C++ - Definição de escopo II
	Você só pode acessar uma variável de dentro de seu escopo. É possível definir três tipos de escopo em C++:
· Local
· Arquivo
· Classe
Variáveis definidas dentro de uma função ou um bloco de {} são acessíveis apenas dentro daquela função ou bloco, e diz-se que têm escopo local.
Características do C++ - Variáveis
	Variáveis que têm escopo local são também chamadas de variáveis automáticas porque são criadas automaticamente dentro do escopo e deixam de existir quando o escopo termina.
Você pode usar um nome de variável local dentro de outros escopos como qualquer bloco de função que contém uma instrução de declaração e mantém seu próprio escopo.
Variáveis locais são armazenamentos alocados no momento em que uma função é invocada. Você não pode passar o endereço de uma variável local fora de seu escopo porque o armazenamento associado às variáveis locais é desalocado após o término da função.
Para reter o valor de uma variável local, você pode definir a variável como estática e dar a ela um valor inicial. Quando você declarar uma variável como estática, os dados são inicializados antes da execução do programa e o valor é retido entre as chamadas de funções.
Características do C++ - Definição de escopo
	O segundo tipo de escopo em C++ é chamado de escopo de arquivo. Você pode acessar variáveis com escopo de arquivo em todo o arquivo do programa. Elas são chamadas de variáveis globais.
	Quando uma variável local tem o mesmo nome que uma variável global, diz-se que a variável global é oculta pela variável local. Para acessar o valor da variável oculta no escopo atual, você usa o operador de resolução de escopo.
	No exemplo mostrado abaixo, o operador de resolução de escopo ajuda a acessar o valor global de r.
	int r = 1; / / file scope
	void main ( )
	{
	 float r = 2 . 0; / /local scope 
	 cout << “global r = “<< : : r<<”\n” ;
	}
	Você não pode usar o mesmo nome de variável para declarar duas variáveis globais. O compilador C++ retornará um erro se o mesmo nome for usado para declarar duas variáveis globais.
	Quando uma variável global é declarada em um arquivo mas é usada em vários arquivos, você precisa declarar a variável como extern nos outros arquivos.
	No exemplo mostrado abaixo, a variável x foi declarada como uma variável global no arquivo f1. Os arquivos f2 e f3 também fazem referência a essa variável declarando a variável x como uma variável extern.
	int x; / /Declaração do arquivo f1
	extern int x; / /Declaração do
 	arquivo f2
	extern int x; / /Declaração do 
arquivo f3
	Você pode também definir variáveis com escopo de classe. As variáveis que têm escopo de classe são visíveis dentro da classe, mas não fora da classe. Você pode usar membros de classe com o mesmo nome em outras classes sem conflito.
	Variáveis definidas em uma classe têm um escopo de classe, a menos que os membros sejam declarados como public. Se uma variável com escopo de arquivo tiver o mesmo nome que um membro de classe, então a variável com escopo de arquivo não será acessível dentro da classe.
	No exemplo mostrado abaixo, a variável de classe height é declarada depois de estar sendo usada. O construtor inicializa a variável height declarada para a classe, e não a variável global height.
	int height; / /file scope 
	class Room
	{
	public:
	 Room ( ) {height = 0; } / /construtor
	private:
	 short height; / /class scope
	} ;
Resumo
	Neste módulo abordamos:
· Um tipo de dado definido pelo usuário é conhecido como uma classe.
· Uma definição de classe tem duas partes:
- cabeça da classe
- corpo da classe
· Uma função de membro é definida em uma classe e descreve um método para manipular membros de dados da classe.
· Um construtor de uma classe é uma função de membro usada para inicializar os membros de dados de um objeto.
· Um destruidor é uma função de membro usada para desativar objetos.
· Escopo é a parte de um programa em que uma determinada variável é acessível.
· Você pode definir três tipos de escopo em C++:
- local
- arquivo
- classe
· Escopo local se refere à parte do código do programa contida dentro da definição de uma função. Variáveis locais são áreas de armazenamento alocadas no momento em que a função é invocada.
· Para reter o valor de uma variável local entre chamadas de funções, você pode definir a variável como estática e atribuir a ela um valor inicial.
· Você não pode usar o mesmo nome de variável para declarar duas variáveis globais.
· As variáveis que têm escopo de classe são visíveis dentro da classe, mas não fora da classe.
· As variáveis que têm escopo de arquivo são acessíveis por todo o arquivo do programa e são chamadas de variáveis globais.
Módulo 03 – Funções especiais e operadores
Introdução
Introdução
	Funções especiais podem auxiliar no desenvolvimento de um programa, torna-o mais funcional e podemos trabalhar com maior flexibilidade. Mas um cuidado especial também deve ser considerando quando trabalhamos com sobrecarga de operadores ou de funções.
Objetivos
	Aprender a usar duas funções especiais, friend, inline e aprender a sobrecarregar operadores e funções em C++.
Conteúdo
· Funções especiais
· Sobrecarga de funções
· Sobrecarga de operadores
Características do C++ - Funções especiais
	Primeiro você vai ver a função friend. Você usa a função friend para acessar todos os membros da classe à qual a função tenha sido declarada como uma amiga.
	Às vezes, uma função pode precisar acessar duas classes separadas. Em C++, uma função pode acessar as duas classes, mesmo que ela não seja membro de nenhuma das classes. Você faz isso ao declarar tal função como uma amiga das classes que ela deseja acessar. A função maxmarks pode acessar todos os membros da classe Student.
	Uma amiga pode ser:
· Uma função que não é de membro.
· Uma função de membro de uma classe definida anteriormente.
· Uma classe inteira.
int maxmarks (Student s)
{ . . .
class Student
{
 friend int maxmarks (Student s) ;
	 / /a função maxmarks não é um 
 membro 		 de Student
 . . .
 } ;
 class Teacher
 {
 public:
 int maxmarks ( ) ;
 . . .
} ;
class Student
{
 friend int marmarks ( ) ;
	 / /maxmarks é um membro da função
 de 		 class Teacher
 . . .
} ;
Características do C++ - Funções especiais II
	Uma função friend tem os mesmos privilégios de acesso que uma função de membro. Ela pode acessar todos os membros de dados da classe da qual ela é amiga.
	No entanto, existem certas diferenças entre uma função friend e uma função de membro. Diferentemente de uma função de membro, uma função friend não pode ser acessada por um objeto da classe. Além disso, você não pode usar o ponteiro this com a função friend.
Características do C++ - Funções especiais III
	O escopo de uma função friend é também diferente de uma função de membro. Uma função de membro tem escopo de classe, ao passo que uma função friend tem escopo de arquivo.
	Você pode também tornar a classe inteira uma amiga de outra classe. No exemplo mostrado no código, cada função de membro da classe Vehicle é uma amiga da classe Bus e pode acessar todos os membros de dados privados da classe Bus.
	ss Vehicle; / /declare a friend 
	class				 existente
	class Bus
	{
	 private:
	 friend class vehicle;
	} ;
 class vehicle
	 {
	 public:
	 . . .
	} ;
Características do C++ - Funções especiais IV
	Quando o programa alcança a instrução dechamada de função, o programa
· Armazena o endereço da instrução que está imediatamente após a chamada de função
· Copia os argumentos para a pilha
· Salta para o local da memória que marca o começo da função
· Executa o código de função
· Coloca um valor de retorno em um registro
· Salta de volta para a instrução cujo endereço foi salvo
A outra função especial fornecida pelo C++ é a função inline. Você usa a função inline para reduzir a sobrecarga das chamadas de funções. Uma chamada de função envolve uma sobrecarga em termos do tempo levado para se executar as etapas adicionais listadas acima.
Quando você declara uma função como inline, o corpo da função é expandido no ponto em que é invocada. Ela não é compilada como um pedaço separado do código. O código da função é inserido sempre que é feita uma chamada dessa função é criada.
Características do C++ - Funções especiais V
	O exemplo abaixo mostra o uso da função inline. Neste programa, addit( ) é declarada como uma função inline que está sendo chamada em main().
	intline int addit (int x, int y)
	 {
	 return x + y;
	 }
	 void main ( )
	 {
	 int a, b, c, d, r, s;
	 r = addit (a, b) ;
	 s = addit (c, d) ;
	}
	O programa main() é interpretado como mostra o código abaixo. Todas as vezes que a função addit() é invocada, o código da função é incluído no programa chamador main().
	void main ( )
	{
	 int a, b, c, d, r, s;
	 r = a + b;
	 s = c + d;
	}
Características do C++ - Sobrecarga
	O C++ permite dois tipos de sobrecarga: de operador e de função.
	A sobrecarga de operador é a atribuição de vários significados a um operador. Por exemplo, o operador + tem a capacidade de adicionar dois valores de quaisquer dos tipos numéricos padrão, como int, float ou double.
	No entanto, o operador + não permite que você adicione dois números complexos porque Complex é um tipo de dado definido pelo usuário. Para adicionar dois números complexos, você sobrecarrega o operador +.
	Quando você usa o mesmo operador para diferentes tipos de dados, então diz-se que esse operador está sobrecarregado.
	O C++ também, permite que você sobrecarregue os operadores para tipos de dados definidos pelo usuário. No entanto, apenas o conjunto predefinido de operadores pode ser sobrecarregado. Você não pode introduzi novos operadores.
	Você define uma função para sobrecarregar um operador.
Sintaxe
	A sintaxe para sobrecarregar um operador é mostrada abaixo.
	Passe o mouse sobre os parâmetros para descobrir mais sobre eles.
Operator oper – symbol
Para declarar uma função de operador, você usa a palavra-chave operator seguida do símbolo de um operador do C++ que você deseja sobrecarregar.
(argument list)
A lista de argumentos representa operandos para o operador.
	Por exemplo, operator +(Complex c1, Complex c2) define uma nova versão do operador + para adicionar dois operandos da classe Complex.
	A definição da classe Complex mostrada abaixo contém declarações para sobrecarregar os operadores + e =.
	class Complex
	{
	private:
	 double real, imag;
	 public:
	 Complex (double r, double i) / /
	construtor
	{
	 real = r ;
	 imag = i ;
	}
	Complex operator – (Complex c2) ;
	Complex operator + (Complex c2) ;
	} ;
	A definição para sobrecarregar os operadores = e + é mostrada no código abaixo. O operador = atribui diretamente os valores de membros de dados real e imag de um número Complex para outro. De forma similar, o operador + adiciona dois números Complex.
	Complex Complex : : operator= (Complex 
c2)
		 / / overloading “=”
	{
	Complex temp;
	temp . real = c2 . real ;
	temp . imag = c2 . imag ;
	return temp ;
	}
	Complex Complex : : operator + 
(Complex c2)
		 / / overloading “+”
	O operador + soma dois números complexos a e b para obter o número Complex c. O operador de atribuição = é sobrecarregado para atribuir o valor de um número Complex a outro número Complex como representa abaixo.
	void main ( )
	{
	 Complex a = Complex (1 . 0 , 2 . 0) ;
		 / /usando o construtor
	 Complex b = Complex (2 . 0 , 3 . 0) ;
	 Complex c = a + b;
	}
	Você pode também sobrecarregar operadores unários como ++ para incremento de vetor dados os componentes x e y de um vetor. O operador ++ incrementa ambos os componentes do vetor em 1. Para fazer isso, você precisa definir uma classe Vector como mostra abaixo.
	class Vector
	{
	 int x;
	 int y;
	 Vector operator ++ ( )
	 {
	 ++x;
	 ++y;
	 }
	} v ;
	Quando você cria o objeto v da classe Vector, um ponteiro this, v *this, é criado implicitamente. Como this é um ponteiro para v, o compilador associa automaticamente o objeto v à classe Vector. Assim sendo, x e y são incrementados.
	class Vector
	{
	 int x;
	 int y;
	 Vector operator ++ ( )
	 {
	 ++x;
	 ++y;
	 }
	} v ;
	Vector : : operator ++ ( )
	 {
	 ++ ( *this) . x;
	 ++ ( *this) .y;
	 }
	Você agora vai ver a sobrecarga de operadores binários. Para sobrecarregar um operador binário, você precisa especificar dois argumentos. O primeiro argumento é apontado implicitamente pelo ponteiro this. O segundo argumento é passado como um parâmetro para a função que sobrecarrega o operador.
	Abaixo a definição da classe Vector. O operador + é sobrecarregado para somar dois objetos da classe Vector.	
	class Vector
	{
	private:
	 int x;
	 int y;
	public:
	 . . .
	 Vector operator + (Vector b) ;
	 } ;
	 Vector Vector : : operator +
 	(Vector b)
	 {
	 Vector temp;
		/ / assume que “=” is overloaded
	 temp . x = x + b.x;
	 temp . y = y + b.y;
	 return temp;
	}
	O código abaixo mostra a interpretação da instrução temp1 = x + b.x. O primeiro argumento x é indicado implicitamente pelo ponteiro this.
temp1 = (*this) . x + 
b.x / / interpretação
	Você usa as funções friend ao sobrecarregar operadores para aceitar um tipo de dado fundamental como primeiro argumento.
	Por exemplo, o código da figura funciona quando você multiplica um Vector por um número, mas falha quando você multiplica um número por um Vector. Isso ocorre porque o operador * sobrecarregado é um membro da classe e assim sendo, o primeiro operando é assumido como sendo o objeto que está invocando.
	class Vector
	{
	public:
	 double x, y;
	 Vector operator * (double p) ;
	 . . .
	} ;
	Vector Vector : : operator * (double
 p)
	 {
	 double mx, my;
	 mx = p * x;
	 my = p * y;
	 Vector mult = Vector (mx, my) ;
	}
	Você pode definir uma função friend para aceitar um tipo de dado fundamental como primeiro argumento e um tipo de dado definido pelo usuário como segundo argumento. O código da figura funciona independentemente do primeiro operando ser um número ou um objeto Vector.
	friend Vector operator* (double n, 
Vector &a) ;
	Vector operator * (double n, Vector
&a)
	{
	 / / friend function definition
	 return a*n; }
	O C++ impõe algumas restrições na sobrecarga do operador definido pelo usuário.
	Uma das restrições imposta pelo C++ é que os operadores não podem ser sobrecarregados para tipos de dados padrão. Você pode sobrecarregar operadores apenas para tipos de dados definidos pelo usuário. Por exemplo, você não pode redefinir o operador + para retornar o produto de duas variáveis do tipo int.
	Outra restrição imposta pelo C++ é que os operadores devem ser definidos de forma que a sintaxe permaneça igual à dos operadores básicos. Por exemplo, o operador de módulo (%) espera dois operandos. Assim sendo, você não pode sobrecarrega-lo usando apenas um operando.
	Sobrecarregar um operador não altera a ordem de execução dos operadores. Por exemplo, se você sobrecarregaro operador de multiplicação para multiplicar dois números complexos, o novo operador terá a mesma precedência do operador comum de multiplicação.
	Você pode sobrecarregar apenas operadores que já existem no C++. Por exemplo, você não pode definir uma combinação de $$ para retornar o produto de um número.
· . operador de membro
· * operador ponteiro-para-membro
· :: operador de resolução de escopo
· ?: operador condicional
Você não pode sobrecarregar todos os operadores em C++. Acima temos uma lista que mostra os operadores que não podem ser sobrecarregados.
	O C++ permite também que você sobrecarregue funções. Você agora vai ver a sobrecarga de funções.
	Sobrecarga de funções é a criação de funções com o mesmo nome, mas com listas de argumentos diferentes. Se você tem funções que executam tarefas similares, é muitas vezes útil atribuir o mesmo nome a elas.
	O tipo mais comum de sobrecarga de função é visto nos construtores de classe. Normalmente, em programas C++, você usa mais de um construtor para lidar com tipos diferentes de inicialização.
	No exemplo abaixo, as funções têm o mesmo nome mas tipos diferentes de argumentos.
	int abs (int i) ; / / construtor
	
	long abs (long 1) ; / / construtor
	
	double abs (double d) ; / / construtor
	
	abs (-10) / / chama int
	
	abs (int i)
	abs (- 100000) / / chama long abs (long
 1)
	abs (-13 . 63) / / chama double abs 
 (double d) ;
	Você pode sobrecarregar funções nas suas listas de argumentos e não no tipo de retorno. No código, a função work() não está sobrecarregada porque a lista de argumentos é do mesmo tipo em ambos os casos, mesmo que os tipos de retorno sejam diferentes. Quando você compilar o fragmento de código mostrado abaixo, o compilador vai retornar um erro.
	int work (int j) ;
	
	void work (int j) ;
Resumo
	Neste módulo abordamos:
· O C++ tem duas funções especiais:
- friend
- inline
· Você usa a função friend para acessar todos os membros da classe à qual a função foi declarada como amiga.
· Uma função friend pode ser:
- uma função que não é de membro.
- uma função de membro de uma classe definida anteriormente.
- uma classe inteira.
· Uma função amiga tem os mesmos privilégios de acesso que uma função de membro.
· Em uma função inline, o corpo da função é expandido no ponto em que ela é invocada.
· O C++ permite dois tipos de sobrecarga, sobrecarga de operador e sobrecarga de função.
· Quando você usa o mesmo operador para diferentes tipos de dados, então diz-se que esse operador está sobrecarregado.
· Você define uma função para sobrecarregar um operador.
· A sobrecarga de função se refere à criação de funções com o mesmo nome, mas com listas de argumentos diferentes.
Módulo 04 – Bibliotecas e fluxos de E/S
Introdução
Introdução
	Considerar o fluxo de entrada e saída de dados e formata-los de maneira amigável faz parte de um sistema eficiente.
Objetivos
	Aprender a implementar funções da biblioteca de E/S em um programa C++ e também a usar funções de formatação para personalizar a E/S antes de sua exibição na tela.
Conteúdo
· Biblioteca de E/S
· Fluxos de E/S
· Formatação de informações
Biblioteca de E/S do C++ - Fluxos
	O C++ oferece as funções mostradas na figura para formatação de E/S. Essas funções são funções de membro dos objetos de fluxo, cin e cout. Para usar essas funções de E/S, você precisa incluir o arquivo de cabeçalho iostream.h em seu programa.
	precision()
	setw()
	fill()
	width()
	Primeiro, você vai examinar a função width(). A função width() é usada para especificar o número de caracteres que uma variável pode conter. A função width() é útil nos programas C++ em que você quer que as variáveis tenham um formato específico.
Biblioteca de E/S do C++
	Você pdoe usar a função width() para definir o número máximo de caracteres armazenados em um buffer. No exemplo mostrado abaixo, a chamada da função width() permite que cin leia apenas 20 caracteres de cada vez para dentro do buffer.
	char buffer [ 20 ] ;
	cin.width ( 20 ) ;
	cin >> buffer ;
	Você também pode usar a função width() para fluxos de saída. No exemplo mostrado abaixo, o valor de x é exibido em um campo com cinco caracteres. Se o comprimento de x for maior que 5, então a configuração da função width() será ignorada e o valor inteiro de x será exibido.
	int x = 1000 ;
	cout . width ( 5 ) ;
	cout << x;
	O valor padrão da função width() para um fluxo é 0. O valor da função width() é redefinido como 0 após cada inserção e extração.
	A instrução abaixo insere x em um campo de cinco caracteres. Após a inserção, o valor da função width() é redefinido como 0. Assim sendo, o caractere de espaço e a variável y não são exibidos em um campo de cinco caracteres, mas no espaço que precisarem.
	int x=1, y=2 ;
	cout.width ( 5 ) ;
	cout << x >> “” << y;
	Agora você vai examinar a função fill(). A função fill() é usada para preencher espaços extras com um caractere especificado.
	Por padrão, a função fill() usa espaços como caractere de preenchimento. A função fill() é invocada somente se o valor definido pela função width() for maior que o tamanho do valor inserido.
	fill()
	O exemplo abaixo preenche com Os as partes não usadas dos campos. A saída do fragmento de código mostrada abaixo será 00010.
	int x;
	cout . fill ( ‘ 0 ’ ) ;
	cout . width ( 5 ) ;
	cout <
	O caractere de preenchimento é redefinido somente quando você usa a função fill() para especificar um novo valor de preenchimento.
	fill()
	Outra função de formatação que você vai examinar é a função setw(). A função setw() é um manipulador que define o comprimento de uma variável. Os manipuladores permitem que você altere as características de um fluxo. A função setw() define o número máximo de caracteres que podem ser inseridos ou extraídos de cada vez.
	setw()
	A função setw() não tem um valor padrão. Ela perde seu valor depois de ser usada uma vez. Para usar esse manipulador, é necessário incluir o arquivo de cabeçalho iomanip.h.
	setw()
	O exemplo abaixo faz com que cout exiba name em um campo de 25 caracteres.
cout << setw (25) << name;
	Outra função de formatação do C++ é a função precision(). A função precision() é usada para definir o número de dígitos a serem exibidos após o ponto decimal em vários tipos de dados double ou float.
	No exemplo mostrado abaixo, a função precision() exibe apenas dois dígitos à direita do ponto decimal. A saída do exemplo mostrado no código será 19.89.
	
	float price;
	cout.precision ( 2 ) ;
	cout << price;
	Por padrão, o número de dígitos exibidos pela função precision() é 6. A função precision() permanece em vigor até ser redefinida para um novo valor dentro de um programa.
	A biblioteca de E/S também oferece funções para ler exibir caracteres. As função de E/S que você pode usar para ler e exibir caracteres estão listadas na figura. Você vai agora examinar cada uma delas detalhadamente.
· Put()
· Get()
· Write()
· Read()
· Getline()
· Peek()
· Putback()
· Ignore()
A primeira função de E/S que você vai examinar é a função put(). A função put() é usada para exibir caracteres. Ela aceita um argumento do tipo de dados char.
put()
	A notação cout.put(char) indica que a função de membro de classe put() está sendo usada com o objeto de classe cout.
cout . put (chair) ;
	No exemplo mostrado abaixo, cout.put(ch) exibe y se o valor de ch for y.
	if (ch ==‘ y ’ ) ;
	cout . put ( ch ) ;
	;
	;
	A função put() não é igual ao operador <<. O comando cout << exibe um valor char como um caractere e um valor int como um número. A função cout.put() exibe ambos os tipos de dados como caracteres, como mostrado abaixo.
	int x=1;
char y=‘A ’;
	cout << x << y;	/ / Saída 1 A
	cout . put (char (x) ) ; / / Saída 1
	 / / Considerado um tipo de 
caracter de dados cout.put
	(y) ;	 / / Saída A
	;
	A próxima função E/S que você vai examinar é a função get(). A função get() extrai e retorna um único valor do fluxo de entrada. Ela não extraio caractere delimitador.
	Você pode usar a função get() de três formas diferentes, como mostrado abaixo. Você agora vai examinar cada uma delas detalhadamente.
	get (ch) ;
	get (char*str,	int len, char
delim=”\n”) ;
	get ( ) ;
	O primeiro método de uso a função get() é get(ch). No código mostrado abaixo, get(ch) extrai um único caractere do fluxo de entrada e o armazena em ch.
	#include (iostream.h) ;
	int main ( ) ;
	{
	char ch;
	while ( cin.get (ch) ) ;
	 / / while there are characters to
 be read
	cout.put ( ch ) ;
	return 0;
	}
	O segundo método de uso da função get() é mostrado abaixo.
Get(char*str, int len, char delim=”\n”)
A função get() para de buscar caracteres se o caractere especificado por delim for encontrado. O caractere novalinha é o caractere delimitador padrão.
	A instrução na figura busca 20 caracteres do fluxo de entrada ou até o caractere novalinha, o que for encontrado primeiro. A instrução lê os caracteres na matriz arr.
cin.gget (arr , 20) ;
	O terceiro método de uso da função get() é mostrado na figura. No exemplo, cin.get() extrai caracteres do arquivo até que fim de arquivo (EOF) seja encontrado.
	#include ;
	int main ( ) ;
	{
	 int ch;
	 while ( ( ch = cin.get ( ) ) ! = EOF ) ;
	 cout.put ( ch ) ; return 0;
	}
	Outra função de E/S que você vai examinar é a função read(). A função read() é usada para ler a partir de um arquivo.
	A sintaxe da função read() é mostrada na animação.
Read(char*addr, int size)
O parâmetro char *addr é o endereço do buffer para o qual o arquivo deve ser lido.
	No exemplo mostrado abaixo, a instrução lê 104 caracteres da entrada padrão e os coloca na matriz total. Depois, lê os 20 caracteres seguintes da entrada padrão e os coloca na matriz marks.
	cin.read ( total, 104) . read
	(marks , 20) ;
	Outra função que você vai examinar é a função write(). A função write() é usada para inserir uma sequência no fluxo de saída.
	write()
	A sintaxe da função write() é mostrada na animação.
Write(char*str, int length)
O parâmetro char *str é o endereço do buffer cujo conteúdo será escrito em um arquivo.
O parâmetro int length é o tamanho do buffer.
	No exemplo mostrado abaixo, a função write() escreve os primeiros 104 caracteres da matriz total na tela.
cout.write ( total , 104) ;
	Outra função de E/S que você vai examinar é a função getline(). A função getline() é usada para extrair um bloco de caracteres do buffer até encontrar o limite numérico especificado ou um caractere navalhinha, o que acontecer primeiro.
	getline()
	A animação exibe a sintaxe da função getline(). A função getline() aceita três parâmetros.
	
Getline(char*buf, int limit, char delim=”\n”);
A função get() busca caracteres do fluxo de entrada e os coloca na matriz de caracteres apontada por str.
A função get() para de buscar caracteres quando len caracteres tiverem sido buscados.
A função get() para de buscar caracteres se o caractere especificado por delim for encontrado. O caractere novalinha é o caractere delimitador padrão.
	A instrução na figura lê até 19 caracteres na matriz arr. O vigésimo caractere é o caractere nulo que é automaticamente acrescentado ao final da matriz.
cin.getlinear (arr , 20) ;
	Ambas as funções get() e getline() são usadas para extrair caracteres do fluxo de entrada. No entanto, há uma diferença entre get() e getline(). A função get() ignora o caractere de terminação novalinha no fluxo de entrada, enquanto a função getline() extrai o caractere novalinha do fluxo de entrada.
		get()						getline()
	A função gcount() retorna o número de caracteres extraídos pela última chamada de get(), getline() ou read(). No exemplo mostrado abaixo, gcount() conta o número de caracteres. Nesse caso, a saída será 20.
	cin getlinear (arr , 20 ) ;
	cin.gcount ( ) ;
	Outra função de E/S que você vai examinar é peek(). A função peek() retorna o próximo caractere da entrada sem extraí-lo do fluxo de entrada.
		get()						getline()
	Às vezes, pdoe ser interessante ler a entrada até o primeiro caractere novalinha ou ponto, o que acontecer primeiro. Você pode usar a função peek() para ver o próximo caractere do fluxo de entrada.
	peek()
	O C++ oferece uma função chamada putback() para inserir um caractere de volta no fluxo de entrada.
	A instrução abaixo empurra o caractere c de volta para o fluxo de entrada.
putback (char c) ;
	Outra função de E/S do C++ é a função ignore(). A função ignore() é usada para pular um número especificado de caracteres de entrada.
	A sintaxe da função ignore() é mostrada na animação. Ela aceita dois parâmetros.
Ignore(int limit = 1, int delim = EOF);
O parâmetro int limit = 1 especifica o número máximo de caracteres a serem ignorados.
O parâmetro int delim = EOF especifica o caractere de terminação para a entrada.
	O exemplo abaixo lê e descarta os próximos 50 caracteres ou até o primeiro caractere novalinha, o que acontecer primeiro.
cin . ignore (50, “\n”) ;
Resumo
	Neste módulo abordamos:
· Você pode executar operações de entrada e saída de arquivos usando as seguintes funções de E/S:
- put()
- get()
- read()
- write()
- getline()
- peek()
- putback()
- ignore()
· Você pode personalizar E/S usando as seguintes funções de formatação:
- width()
- fill()
- precision()
- setw()
Módulo 05 – Funções de E/S
Introdução
Introdução
	Neste módulo, você aprenderá a usar as funções de E/S de arquivo em um programa C++.
Objetivos
	Aprender a usar as funções de E/S de arquivo em um programa C++.
Conteúdo 
	Classes:
· Ifstream
· Ofstream
· Fstream
Biblioteca de E/S do C++
	Para que você possa lidar com entrada e saída de arquivo, o C++ define três classes: ifstream, ofstream e fstream.
Ifstream	ofstream	fstream
A classe ifstream é derivada da classe istream. Ela conecta um arquivo ao programa para entrada.
A classe ofstream é derivada da classe ostream. Ela conecta um arquivo ao programa para saída.
A classe fstream é derivada da classe iostream. Ela conecta um arquivo ao programa para entrada e saída.
	As definições das três classes são armazenadas no arquivo de cabeçalho fstream.h.
	fstream.h
	Você usa funções de E/S de arquivo com uma dessas classes. Você vai examinar agora as funções de entrada e saída de arquivo. A sintaxe para brir um arquivo é mostrada na animação abaixo.
<stream> <stream object>(filename, mode);
O parâmetro stream se refere a uma das três classes: ifstream, ofstream ou fstream.
A função get() para de buscar caracteres quando len caracteres tiverem sido buscados.
A função get() para de buscar caracteres s eo caractere especificado por delim for encontrado. O caractere novalinha é o caractere delimitador padrão.
	Quando você abre um arquivo para entrada e saída, uma conexão é estabelecida entre o arquivo e o fluxo solicitado.
	Para abrir um arquivo no modo de saída, você precisa definir um objeto de classe ofstream.
	oftream outline
	 ( “copy.out” , ios : : out ) ;
	 / /Inicializando o objeto
	ofstream
	para o arquivo copy.out ;
		Você usa funções de E/S de arquivo com uma dessas classes. Você vai examinar agora as funções de entrada e saída de arquivo. A sintaxe para abrir um arquivo é mostrada na animação abaixo.
<stream> <stream object>(filename, mode);
O parâmetro stream se refere a uma das três classes: ifstream, ofstream ou fstream.
A função get() para de buscar caracteres quando len caracteres tiverem sido buscados.
A função get() para de buscar caracteres se o caractere especificado por delim for encontrado. O caractere novalinha é o caractere delimitador padrão.
	Quando você abre um arquivo para entrada e saída, uma conexão é estabelecida entre o arquivo e o fluxo solicitado.
	Para abrir um arquivo no modo de saída, você precisa definir um objeto de classe ofstream.
	Ofstream outline
 	 (“copy.out”, ios : : out) ;
/ / Inicializando o objeto ofstream para o arquivo copy.out;
	Você pode abrir um arquivo ofstream no modo de saída ou no modo de acréscimo. Você usa a constante de enumeração ios::out para abrir o arquivo no modo de saída.Para abrir o arquivo no modo de acréscimo, use o ios::app.
	Quando você abre um arquivo no modo de saída, todos os dados armazenados nesse arquivo são descartados. Caso deseje fazer uma adição a um arquivo existente, você precisa abrir o arquivo no modo de acréscimo. Os dados serão então adicionados ao final do arquivo.
	Para abrir um arquivo no modo de entrada, você precisa definir um objeto da classe ifstream. O exemplo abaixo, inicializa o objeto ifstream infile para o arquivo copy.in. A constante de enumeração ios::in especifica que copy.in é aberto no modo de saída.
	Ifstream infile
 	 (“copy.in”, ios : : in) ;
	 / /Abra “copy.in” como arquivo de
 entrada”
	Você também pode abrir um arquivo nos modos de entrada e saída usando um objeto de classe fstream. Para abrir um arquivo no modo de entrada ou de saída, você precisa definir um objeto de classe fstream.
	O operador bit a bit OR ׀ é usado para abrir um arquivo em mais de um modo. O exemplo da figura abre o arquivo word.out nos modos de entrada e de acréscimo.
	Para conectar um arquivo ao programa para entrada e saída, você precisa incluir o arquivo de cabeçalho fstream.h em seu programa.
	Você agora aprenderá a usar as funções de entrada e saída de arquivo, open() e closed().
	open()
	A função open() é usada para abrir um arquivo em um modo especificado. Você pode então conectar o arquivo ao objeto de classe usando a função open(). A sintaxe da função open() é mostrada na animação.
Open (filename, mode)
O parâmetro filename se refere ao nome do arquivo a ser aberto.
O parâmetro mode se refere a um dos três modos em que o arquivo tem que ser aberto: entrada, saída ou acréscimo.
	 O exemplo abaixo abre o arquivo especificado por filename para entrada.
	ifstream infile;
	infile . open (filename, ios : : in) ;
	A função ifstream open() usa ios::in como valor padrão para o argumento modo, enquanto a função ofstream open() usa ios:out como modo padrão.
	open()
	open()
	 A classe fstream não tem um modo padrão. Você precisa especificar um modo explicitamente ao criar um objeto dessa classe.
	 Você também pode abrir um arquivo para entrada e saída, como mostrado no código abaixo.
	if stream infile;
	infile.open ( “file.dat”, ios : :in ) ;
 / /Ambas as declarações
	infile .open ( “file . dat” )
	 / /Abra file . dat como entrada ;
	ofstream outline;
	outfile . open ( “file . dat”, 
ios : : out ) ;
	 / /Ambas as declarações
	outfile . open ( “ file . dat ” )
	 / /Abra file.dat como saída;
	Você agora vai examinar a função close() no C++. A função close() é usada para desconectar explicitamente um arquivo de um programa. O exemplo abaixo fecha os arquivos de saída e entrada, respectivamente.
	outfile . close ( ) ;
	 / /Feche a conexão para o
 arquivo de saída
	infile . close ( )
	 / /Feche a conexão para o
 arquivo de entrada
	Ao fechar uma conexão, você não elimina o fluxo. Você apenas desconecta o fluxo do arquivo de entrada ou de saída.
	Você também pode acessar um arquivo randomicamente usando as funções de acesso randômico a arquivo em um programa C++. Abaixo a uma lista de funções de acesso randômico a arquivo em C++.
· Seekg()
· Seekp()
· Tellg()
· Tellp()
Você usa a função seekg() para mover o ponteiro do arquivo para um endereço absoluto dentro do arquivo.
	A função seekg() pode ser declarada de duas formas, como mostrado na animação a seguir. O primeiro método localiza uma posição no arquivo medida em bytes a partir do início do arquivo. O segundo método localiza uma posição no arquivo medida em bytes a partir de um local no arquivo especificado pelo segundo argumento.
Open (filename, mode)
O parâmetro filename se refere ao nome do arquivo a ser aberto.
O parâmetro mode se refere a um dos três modos em que o arquivo tem que ser aberto: entrada, saída ou acréscimo.
	 A função seekp() é usada para mover o ponteiro do arquivo para um determinado local no arquivo. A instrução do código abaixo coloca o ponteiro do arquivo 12 bytes antes do fim do arquivo.
seekp (-12 , ios : : end) ;
	O segmento de código mostrado abaixo exibe o uso da função seekg().
	
	infile . seekg ( 16 ) ;
	 / /Vá para o byte 16 no arquivo
	infile . seekg ( 16 , ios : : beg ) ;
	 / /Igual a sentença anterior
	infile . seekg (-1 , ios : : cur ) ;
	 / /Volte um byte
	infile . seekg (0 , ios : : end) ;
	 / /Vá para o fim do arquivo
	infile . seekg ( ) 0 ;
	 / /Vá para o início do arquivo
	infile . seekg (-10 , ios : : end) ;
	 / /Vá 10 bytes até o EOF
	Você agora vai examinar a função tellg(). A função tellg() pode ser usada para verificar a posição atual de um ponteiro de arquivo para fluxo de entrada.
	streampos mark=writefile . tellg ( ) ;
	/ /Você marca a posição atual
 usando o
 tellg ( ) ;
	A função tellp() pode ser usada para verificar a posição atual de um ponteiro de arquivo para fluxo de saída.
	tellp()
	O C++ também oferece algumas funções de verificação de fluxo para verificar erros.
	O objeto de biblioteca iostream mantém um conjunto sinalizadores de condição, através dos quais o progresso do fluxo pode ser monitorado. Para monitorar o status de um fluxo, a biblioteca iostream oferece as funções mostradas abaixo.
· eof()
· bad()
· fail()
· good()
A primeira função de verificação de fluxo que você vai examinar é a função eof(). A função eof() retorna um valor diferente de zero se o fluxo encontrar o fim do arquivo.
if (inout.eof ( ) ) ;
inout . clear ( ) ;	/ /Limpar
indicador eof
else ;
cerr << “Error in reading. \n” ;
A segunda função de verificação de fluxo que você vai examinar é a função bad(). A função bad() retorna um valor diferente de zero se houver tentativa de realizar uma operação inválida, como buscar uma posição além do fim do arquivo.
bad()
O exemplo abaixo mostra que, se a função bad() encontrar uma operação inválida, ela envia uma mensagem de erro à saída padrão.
if (cin . bad ( ) ) ;
cout << “Erros! ” ;
	A terceira função de verificação de fluxo que você vai examinar é a função fail(). A função fail() retorna diferente de zero se uma operação for mal sucedida ou se houver tentativa de realizar uma operação inválida.
	fail()
	O exemplo abaixo mostra que, se o programa não conseguir abrir o arquivo filename, a função fail() envia uma mensagem de erro para a saída padrão.
	ifstream infile (filename,
	ios : : in) ;
	if (infile . fail ( ) ) ;
		Não é possível abrir
	cout << “Error! ” ;
	A quarta função de verificação de fluxo que você vai examinar é a função good(). A função good() retorna verdadeiro se eof(), bad() e fail retornarem falso.
	O exemplo mostrado acima direciona a mensagem ao arquivo inout se o fluxo inout não estiver incorreto, não tiver encontrado o fim de arquivo e se a última operação de E/S tiver sido bem-sucedida.
	good()
	O objeto de biblioteca iostream mantém um conjunto de sinalizadores de condição através dos quais o progresso do fluxo pode ser monitorado. Para monitorar o status de um fluxo, a biblioteca iostream oferece as função mostradas abaixo:
· eof()
· bad()
· fail()
· good()
Você agora vai examinar as funções de buffer do C++.
	Quando um fluxo é armazenado em buffer, as inserções ou extrações não têm uma operações de E/S correspondente para gravar ou ler dados fisicamente em um dispositivo. Todas as inserções e extrações são armazenadas em um buffer de onde os dados são gravados ou lidos em porções.
	O C++ oferece as funções mostradas na figura ao lado para armazenar em buffer um fluxo de saída.
		flush()				clear()
	Você primeiro vai examinar a função flush() no C++. A função flush() permite que você limpe o buffer. Por exemplo, a instrução mostrada abaixo limpa o buffer cout.
cout . flush ( ) ;
	Limpar um buffer de saída faz com que os dados contidos nele sejam gravados em um arquivo. Isso garante que tudo que estiver armazenado em um fluxo de saída seja exibido.
	Você usa a função flush() quando é solicitadauma entrada do usuário. Isso garante que o buffer esteja vazio quando os dados forem inseridos.
	A outra função de buffer que você vai examinar é a função clear(). A função clear() redefine o estado do fluxo e desliga o sinalizador de fim de arquivo.
	clear()
	O segmento de código mostrado abaixo ilustra que se eof() retornar verdadeiro, então clear() redefine o fluxo e desativa o sinalizador de fim de arquivo. O programa pode então acessar o arquivo novamente.
if (infile . eof ( ) ) ;
infile . clear ( ) ;
else ;
cerr << “Error! \n” ;
	A parte else do segmento de código acima exibe uma mensagem de erro quando o programa para de ler o arquivo por outros motivos que não o fim de arquivo, como uma falha de hardware.
Resumo
	Neste módulo, abordamos:
· Você trata a entrada e saída de arquivo usando três classes a seguir:
- ifstream
- ofstream
-fstream
· Você usa a função open() para abrir arquivos e a função close() para fechar arquivos.
· Você pode acessar um arquivo randomicamente usando as seguintes funções de acesso randômico a arquivo em um programa C++:
- seekg()
- seekp()
- tellg()
- tellp()
· O C++ oferece as seguintes funções de verificação de fluxo para verificar erros:
eof()
bad()
fail()
good()
· O operador ! é sobrecarregado na classe ios. Ele retorna um valor diferente de zero se ocorrer um erro no fluxo.
· O C++ oferece as seguintes funções de buffer:
flush()
clear()
Módulo 06 – Herança e polimorfismo
Introdução
Introdução
	Neste módulo você aprenderá a implementar a herança usando o C++. Herança é o processo de criação de uma classe derivada a partir de uma classe-base e também vai aprender a implementar o polimorfismo usando o C++.
Objetivos 
	Aprender a implementar a herança e o polimorfismo usando o C++.
Conteúdo 
	Implementar:
· a herança
· o polimorfismo
POO usando C++ - Herança
	A classe derivada herda membros de dados e funções de membro de sua classe-base. A classe derivada pode também ter seus próprios membros de dados e funções de membro.
	A herança permite a reutilização de código. Quando uma classe é definida, você pode usá-la para criar classes derivadas. A reutilização de classes existentes poupa tempo e trabalho.
POO usando C++
Sintaxe
	Vejamos agora como você pode derivar uma classe de uma classe-base. A sintaxe usada para derivar uma classe é mostrada no código abaixo.
class Derived : Base
	Você pode criar uma classe derivada usando herança única ou múltipla.
							Herança Privada
	Herança Pública
	Quando você deriva uma classe de apenas uma classe-base, a herança é conhecida como herança única. Existem dois tipos de herança única: a pública e a privada.
	Na herança pública, membros e protegidos da classe-base se tornam membros públicos e protegidos da classe derivada.
	No exemplo abaixo, a classe Bug tem dois elementos de dados privados, legs e color, e duas funções de membro públicas, Bug() e draw().
	enum Bugcolor {Red, Blue, Black} ;
	 class Bug
	{
	 private:
	 int legs;
	 Bugcolor color;
	public:
	 Bug (int numlegs, Bugcolor c) ;
	 / / construtor
	 void draw ( ) ;
	} ;
	Para derivar uma classe através de herança pública, você inclui o nome da classe-base na definição da classe derivada. A instrução mostrada abaixo indica que a classe Humbug foi derivada da classe Bug através de herança pública.
	class Humbug: public Bug
	{
	 private:
	 int frequency;
	public:
	 Humbug (int numlegs, Bugcolor c, int
	freq.) ;
	 / / construtor
	 void hum ( ) ;
	} ;
	Uma classe derivada não herda os membros privados na classe-base. Por exemplo, uma classe derivada não herdará os elementos de dados privados legs e color da classe-base Bug.
	
	enum Bugcolor {Red, Blue, Black} ;
	class Bug
	{
	 private:
	 int legs;
	 Bugcolor color;
	public:
	 Bug (int numlegs, Bugcolor c) ;
	 / / construtor
	 void draw ( ) ;
	} ;
	Na herança privada, os membros públicos e protegidos da classe-base se tornam membros privados da classe derivada. Uma classe derivada não herda membros privados da classe-base.
	Na definição de classe mostrada ao lado, o qualificador private indica que a classe Humbug é derivada da classe Bug através de herança privada.
	class Humbug: public Bug
	{
	 private:
	 int frequency;
	public:
	 Humbug (int numlegs, Bugcolor c, int
	freq.) ;
	 / / construtor
	 void hum ( ) ;
	} ;
	Quando você não especifica uma palavra-chave de acesso para a classe-base, o C++ cria a classe derivada através de herança privada. Por exemplo, a classe Bear é derivada da classe-base Animal através de herança privada nas duas declarações mostradas abaixo.
	class Bear : Animal / /equivalente
	class Bear : Private
	Animal / / declarações
	Quando você deriva classes, os construtores e destruidores da classe-base não são herdados por suas classes derivadas. Você precisa definir construtores e destruidores para as classes derivadas.
	Os construtores das classes derivadas contêm informações de parâmetros dos construtores da classe-base.
	O segmento de código mostrado abaixo define Derived como uma classe derivada da classe-base Base. Os argumentos x e y, são passados como parâmetros para os construtores da classe derivada e da classe base.
	Derived : : Derived (type1 x, type2
	y) : Base (x, y)
	 / / construtor
	{
	. . .
	}
	Quando você herda uma classe de sua classe-base, você pode usar os objetos da classe derivada como objetos da classe-base. A classe derivada herda todos os membros de sua classe-base.
	Um objeto da classe-base não pode ser convertido em objeto da classe derivada. Isso acontece porque a classe-base não contêm todos os membros de sua classe derivada.
	A instrução d=b da figura é inválida, porque uma classe-base não contém todos os membros da classe derivada. Entretanto, a instrução b=d é válida, porque uma classe derivada contém todos os membros da classe-base.
	class Base
	 {
	 . . .
	 } ;
	class Derived : public Base
	 {
	 . . .
	 } ;
	void main ( )
	 {
	 Derived d;
	 Base b;
	 b = d; / /converte derivado da 
	class 			 object para abse
	class 
	 d = b;	/ /sentença inválida
	}
	Agora você vai examinar um outro tipo de herança, a herança múltipla.
	Na herança múltipla, uma classe é derivada de mais de uma classe-base.
	A classe derivada Derived da figura é derivada de duas classes-base, Base1 e Base2, através de herança pública e privada, respectivamente.
	class Derived: public Base1, private
	Base2
	{
	 public:
	 void print ( )
	 {
	 printf (“b1 = &d”, b1) ; / /correto
	 . . .
	 printf (“b2 = &d”, get
	( ) ; / /correto
	 . . .
	 }
	} ;
	Uma classe derivada também pode herdar funções de membro de mesmo nome de mais de uma classe-base.
	No fragmento de código mostrado abaixo, a classe derivada Derived herda duas funções diferentes chamadas set() de suas duas classes-base, Base1 e Base2. Se você invocar d.set(12), não fica claro se você está se referindo à função set() de Base1 ou de Base2.
Visualizando o código
class Base1					class Base2
{						{
 protected;					 private:
 int b1;					 int b2;
 public:					public:
 void set (int i)				 void set (int i)
 {						 {
 b1 = i;					 b2=i;
 }						 }
 } ;						 int get ( )
 						 {
 class Derived: public Base1, private		 return b2 }
 Base2					 } ;
 {
 public:
 void printf ( ) {
	printf (“b1 = &d”, b1) ;
		/ /correto
	Printf (“b2 = &d”, get ( ) ) ;
		/ /correto
 } ;
 Derived d;
 d.set (12) ;
	Para especificar a que função set() está se referindo, você pode usar o operador de solução de escopo.
Visualizando o código
class Base1						class Base2
{							{
 protected;						 private:
 int b1;						 int b2;
 public:							public:
 void set (int i)					 void set (int i)
 {{
 B1 = i;						 b2=i;	
 }							 }
} ;							 int get ( )
							 {
class Derived: public Base 1, private			 return b2)
Base2							} ;
{
 public:
 void printf ( ) {
 printf (“b1 = &d”, b1) ;
	 / /correto
 Printf (“b2 = &d”, get ( ) ) ;
	 / /correto
} ;
 d.Base1 : : set (12) ;
	Do mesmo modo, quando ria uma classe derivada a partir de mais de uma classe-base, você também precisa especificar que construtor está sendo invocado pela classe derivada.
	Por exemplo, o argumento c do construtor da classe derivada é passado para o construtor da classe-base Base1(). Entretanto, o argumento não é passado para o construtor da classe-base Base2(), porque Base2() aceita explicitamente 0 como argumento.
Visualizando o código
class Base1					class Base2
{						{
 private;				 private:
 int b1;				 int j;
 public:					 public:
 Base1 (int a) / /construtor			 Base2 (int b) / /construtor
 {						 {
 i = a;					 j = b;
 }						 }
} ;						} ;
class Derived: public Base1, public
Base2
{
 private:
 int k;
 public:
 Derived (int c) : Base1 (c) ,
public Base2 ( 0 )
 {
 . . .
 } ;
} ;
	É importante notar que o construtor da classe derivada pode ter outros argumentos além dos passados para sua classe-base ou classes-base. Geralmente, esses argumentos são para uso interno do construtor da classe derivada.
	Se uma classe-base define um construtor padrão, sua classe derivada não precisa definir um construtor. O construtor padrão permite declarar objetos sem inicializá-los.
	Uma classe derivada não pode herdar diretamente os membros de uma mesma classe-base duas vezes. No exemplo mostrado na figura, o compilador retornará um erro, porque a classe A herda membros da classe B duas vezes.
	Class A: public B, public B
	{
	 . . .
	 / /Corpo da class A
	} ;
	Entretanto, uma classe pode herdar os membros da mesma classe-base duas vezes através de diferentes caminhos na herança múltipla.
	No segmento de código, as classes Child1 e Child2 são derivadas da classe Parent. Uma outra classe Grandchild é derivada das classes Child1 e Child2. Assim, a classe Granfchild herda duas cópias de parentvar, declarado na classe Parent: uma através de Child1 e outra através de Child2. Uma cópia única de parentvar pode ser a herdada declarando-se a classe Parent como virtual.
	class Parent
	 {
 public: / /declaração public
	 char parentvar;
	} ;
	class Child1: public Parent
	 {
	 public: / /declaração public
	 int firstvar;
	} ;
	cClass Child2: public Parent
	 {
 public: / /declaração public
	 float secondvar;
	} ;
	Class Grandchild: public Child1, public
	Child2
	 {
	 public: / /declaração public
	 double somevar;
	 . . . / / ás vezes
	};
	Quando a mesma classe é herdada mais de uma vez usando vários caminhos, várias cópias dos membros da classe-base são criadas na memória. Para evitar isso, você pode declarar a classe-base como virtual. Quando você declara a classe-base como virtual, somente uma cópia dos membros da classe-base é herdada.
	No exemplo, os membros da classe parent são herdados por Child1 e Child2 usando a palavra-chave virtual. A classe Parent é uma classe-base virtual. A classe Grandcild herda somente uma cópia do membro de dados parentvar da classe Parent.
	class Parent
	 {
	 . . .
	 } ;
	class Child1 : virtual public Parent
	 {
	 . . .
	 } ;
	class Cild2 : virtual public Parent
	 {
	 . . .
	 }
	class Grandchild : public Child1; public
	Child2
	 {
	 . . .
	 } ;
	Agora você vai aprender sobre classes-base abstratas. Uma classe-base abstrata é uma classe que é usada como base para outras classes. Não é possível crias instâncias de uma classe abstrata. Ela define as propriedades comuns às classes derivadas dela.
	Uma classe-base abstrata fornece uma interface pública comum a toda a hierarquia de classes. Por exemplo, você pode ter uma classe-base abstrata Animais que defina as características gerais de todos os animais. Você não pode criar nenhum objeto dessa classe, mas pode usar Animais como classe-base para derivar como Cães e Vacas.
	Uma classe Der derivada da classe abstrata Abs pode ser declarada da maneira mostrada na figura. Enquanto as funções de membro getx() e gety() são usadas na classe derivada com suas definições originais, a função de membro fun1() foi redefinida de acordo com os requisitos da classe Der.
	class Der : public Abs
	 {
	 public:
	 int fun1 ( )
	 {
	 / /redefine o abstrato da base class
	 function fun1 ( )
	 }
	 Der ()
	 {
	 getx ( ) ; / /uso abstrato da base class
	 getx ( ) ; / /métodos getx ( ) e gety ( )
	 }
	} ;
	Em C++, uma classe que contenha uma ou mais funções virtuais puras é chamada de classe abstrata. Uma função virtual pura é uma função virtual sem corpo. Isso é feito acrescentando-se a notação = 0 à declaração da função virtual.
	No exemplo ao lado, print() e process() são declaradas como funções virtuais puras.
	class Abstract
	 {
 public:
	 virtual void printf ( ) = 0; / /puro
	virtual
	 virtual void process ( ) =
	0; / /funções 	int status ( )
	 {
	 return 1;
	 }
	} ;
	A funções virtuais puras o forçam a redefinir uma função de membro definida na classe abstrata. Por exemplo, se você não redefinir as funções virtuais puras print() e process() nas classes derivas, o compilador gera um erro.
POO usando C++ - Polimorfismo
	O polimorfismo é a propriedade que permite que funções de mesmo nome tenham interpretações diferentes em uma classe-base e em suas classes derivadas. A mesma mensagem é enviada a dois objetos diferentes e eles produzem dois conjuntos diferentes de ações.
	No exemplo mostrado abaixo, as classes derivadas como Square e Circle herdaram a função draw() da classe-base Figure. Quando essa função é invocada, a classe Square desenha um quadrado, e a classe Circle desenha um círculo.
Visualizando o código
class Figure / /Base class			class Square:public Figure
{						{
 private;					 private:
 int x; inty;					 int x 1;
public:						public:
 virtual void draw ( )				 void draw (void)
 {						 / /função draw square
 Cout << “Figure \n”;			{
 }						 count << “Square \n”;
};						}
class Circle : public Figure		 } ;
{
 private:
 int rad;
 public:
 void draw (void)
	/ / função to draw circle
 {
 cout << “Circle\n”;
 } ;
} ;
	Quando uma ou mais classes derivadas têm uma função de mesmo nome, você precisa resolver a identidade da função antes de invoca-la.
POO usando C++
	O compilador associa a função a uma classe identificando o tipo do objeto ou do ponteiro usado para invocá-la. Esse processo de associar uma função a uma chamada é conhecido como vinculação.
	Existem dois tipos de vinculação. A animação mostra os nomes dos dois tipos de vinculação.
Vinculação estática	Vinculação dinâmica
A Vinculação estática resolve a chamada de função em tempo de compilação.
A Vinculação dinâmica resolve chamadas de função em tempo de execução. Funções polimórficas usam a vinculação dinâmica para resolver chamadas de função porque o compilador não pode determinar que definição de função de membro chamar, uma vez que as funções de membro têm o mesmo nome.
	A definição de uma função de membro na classe derivada com o mesmo nome de uma função de membro da classe-base é conhecida como sobreposição. Ela é possível tanto na herança pública quanto na herança privada. O exemplo ao lado mostra que a função display()