14/03/2017 Programar em C++/Classes - Wikilivros

Programar em C++/Classes
Origem: Wikilivros, livros abertos por um mundo aberto.
< Programar em C++

Esta pgina precisa ser reciclada ( discuta).

Ao melhor-la, voc estar ajudando o W ikilivros.

ndice
1 Classes
1.1 Origem (atributos)
1.2 Funes membro (Mtodos)
1.3 Conceituao
2 Declarando classes
3 Instanciando objetos
4 Definio de classes
5 Especificadores de acesso
6 Construtores
6.1 Conceito
6.2 Declarao
7 Destrutores
7.1 Conceito
7.2 Declarao
8 "copy constructors"
9 Ver tambm

Classes
Existem duas categorias de tipos de dados usuais em C++, so classificados como tipos bsicos e tipos
definidos pelo programador.

Assim como na linguagem C, podemos definir dados compostos por associaes dos tipos bsicos, estes
tipos so chamados de estruturas (structs). C++ traz uma nova representao de dados, muito semelhante na
forma s estruturas, porm diferentes na forma conceitual: a palavra chave class, que usada para criar uma
classe de objetos mais rica que as structs. Ao declararmos um identificador, tal qual fazemos ao declarar uma
varivel e no lugar do tipo especifiquemos uma classe criaremos um objeto.

Antes de prosseguirmos, vejamos um pouco sobre o conceito por trs do uso de objetos. Um objeto
entendido como uma entidade de dados dentro da memria que, basicamente, deve ser responsvel por seu
contedo, ou seja, um objeto deve ser capaz de gerenciar seu contedo autonomamente, ou prover meios de
outras entidades de cdigo faz-lo de forma segura.

Origem (atributos)

Observemos, por exemplo, o cdigo abaixo:

https://pt.wikibooks.org/wiki/Programar_em_C%2B%2B/Classes 1/13
14/03/2017 Programar em C++/Classes - Wikilivros

struct MyData
{ int n;
char data[10];
float nReal;
};

Esta declarao, bem conhecida de quem j est familiarizado com a linguagem C, cria um tipo de dado
composto heterogneo, que neste exemplo chamamos de MyData, o que acontece aqui que os dados esto
agrupados dentro desta estrutura, isto promove a possibilidade de manipul-los em conjunto. Um dos
problemas com esta estrutura a presena de uma matriz de caracteres chamada "data", observe que a mesma
tem um tamanho definido de 10 caracteres, imagine que em algum momento da execuo do programa
tentamos colocar um caractere na posio 11, ou qualquer posio fora da matriz, neste caso estamos colocando
o referido dado em endereos invlidos para a operao que pretendemos realizar, ou seja, no h controle
nenhum que assegure que o cdigo no far um acesso fora da rea que pertena a matriz. Um acesso de
memria a qualquer elemento da matriz acima da posio 9, far com que invadamos dados na rea onde a
varivel nReal est definida.

Funes membro (Mtodos)

Agora suponha que tenhamos como definir um modo para entrar e outro para ler dados da matriz:

struct MyData
{ int n;
char data[10];
float nReal;

bool write_data (int pos, char c)

{ if (pos >= 0 && pos < 10)
{ data[pos]=c;
return true;
}
return false;
}

char read_data (int pos)

{ if (pos >= 0 && pos < 10)
{ return data[pos];
}
return '\0';
}
};

Agora temos assegurados mtodos de incluso e acesso a dados da matriz de caracteres, porm ainda
existe um pequeno problema: Quem quiser o antigo mtodo de acesso direto conseguir facilmente, pois os
elementos da estrutura esto acessveis publicamente por padro.

Conceituao

O problema da visibilidade pblica dos dados em uma estrutura pode ser resolvido com um dos
conceitos de objetos, o encapsulamento. Encapsular os dados, significa reservar o acesso a funes que estejam
dentro de um grupo restrito, especializado para tais operaes de manipulao destes dados. Uma das vantagens
deste procedimento que o cdigo adquire um formato mais organizado, onde os processos tornam-se
claramente distintos, caso tenhamos que analisar o cdigo, cada procedimento estar restrito a partes definidas
para cada operao.

Declarando classes
As estruturas so bem parecidas com as classes, com uma pequena diferena, peguemos o caso da
passagem de estruturas como argumentos de funes:

https://pt.wikibooks.org/wiki/Programar_em_C%2B%2B/Classes 2/13
14/03/2017 Programar em C++/Classes - Wikilivros

#include <iostream>
#include <string>

using namespace std;

class Person
{
string name;
int height ;
};

void setValues (Person &);

void getValues (const Person &);

int main ()
{
Person p1;
setValues (p1);
cout << "Informando dados sobre a pessoa: \n";
cout << "================================ \n";
getValues (p1);
return 0;
}

void setValues (Person & pers)

{
cout << "Informe o nome da pessoa: " ;
getline (cin, pers.name);
cout << "Informe a altura em milmetros: " ;
cin >> pers.height ;
cin.ignore ();
}

void getValues (const Person & pers)

{
cout << "Nome da pessoa: " << pers.name << endl;
cout << "A altura da pessoa em milmetros : " << pers.height << endl;
}

Mudamos o identificador de struct para class

Mas se tentarmos compilar o programa isto vai causar erros de compilao, porque agora temos variveis
membro que so privadas por padro, estas no so vistas por funes fora da classe.

Dentro de uma classe podemos definir diversos modos de visibilidade de variveis e funes.

As modalidades podem ser:

private (s podem ser acessados por membros da mesma classe)

public (pode ser acessadas fora do objeto, onde este estiver definido)
protected (deixemos esta para quando falarmos em classes derivadas, pois depende deste conceito).

Ora, como as funes getValues e setValues no so membros da classe Person, tal como o construtor
Person, no conseguem acessar as variveis "name" e "height".

Visualizamos melhor em forma de tabela:

Class Person private

string name
Int height

p1

https://pt.wikibooks.org/wiki/Programar_em_C%2B%2B/Classes 3/13
14/03/2017 Programar em C++/Classes - Wikilivros

A soluo criar funes publicas, para ler de e escrever para as variveis privadas:

#include <iostream>
#include <string>

using namespace std;

class Person
{
private :
string name;
int height ;
public :
string getName () const;
void setName (string );
int getHeight () const;
void setHeight (int);
};

string Person ::getName () const

{ return name; }

void Person ::setName (string s)

{
if (s.length () == 0)
name = "No name assigned" ;
else
name = s;
}

int Person ::getHeight () const

{ return height ; }

void Person ::setHeight (int h)

{
if (h < 0)
height = 0;
else
height = h;
}

void setValues (Person &);

void getValues (const Person &);

int main ()
{
Person p1;
setValues (p1);
cout << "Outputting person data \n";
cout << "====================== \n";
getValues (p1);
return 0;
}

void setValues (Person & pers)

{
string str;
int h;
cout << "Enter person's name: " ;
getline (cin,str);
pers.setName (str);
cout << "Enter height in milimeters: " ;
cin >> h;
cin.ignore ();
pers.setHeight (h);
}

void getValues (const Person & pers)

{
cout << "Person's name: " << pers.getName () << endl;
cout << "Person's height in milimeters is: " << pers.getHeight () << endl;
}

Mas perguntam: Por que que nos demos ao trabalho de recorrer a membros privados em vez de fazer
todos pblicos? Quando tnhamos uma estrutura no lugar de uma classe, no havia nada que impedisse a
colocao de valores invlidos, por isso poderamos ter valores vazios para a string e valores negativos para a
https://pt.wikibooks.org/wiki/Programar_em_C%2B%2B/Classes 4/13
14/03/2017 Programar em C++/Classes - Wikilivros

varivel "height".

Agora que "Person" uma classe, as funes membro podem realizar a validao dos dados antes da
atribuio de valores nas variveis. Poderamos fazer com que a funo setName verificasse se a entrada na
string seria vazia e caso fosse, colocaria um valor padro como: sem nome. similarmente poderamos ter
"setHeight" para verificar se seriam colocados valores de entrada negativos e caso fossem, colocaria zero, ou
no tomaria nenhuma ao.

Todas estas caractersticas demonstram o conceito de encapsulamento. A sua finalidade de tornar o

cdigo mais modularizado, restringindo o escopo de anlise a partes bem delimitadas dos programas. Devido a
este conceito podemos contar com cdigos mais fceis de analisar e fazer manuteno.

Instanciando objetos
Instanciao de objetos o processo de criar a estrutura lgica dos mesmos na memria. Isto ocorre
quando declaramos os objetos, pois neste momento todo o processo de construo dos mesmos efetivado.
Assim, toda vez que declaramos um objeto estamos instanciando-o, ou seja, estamos criando uma instncia da
classe.

Podemos declarar os objetos logo aps definir a classe conforme podemos ver no 1 caso logo abaixo.
Neste caso teremos a varivel rect criada como um objeto conforme estabelecido pelo modelo definido pela
palavra chave class. Este tipo de declarao mais usual para objetos criados globalmente, pois a incluso
desta declarao no cabealho pode fazer com que vrios objetos sejam criados com o mesmo nome quando o
cabealho invocado de vrios arquivos. Portanto, mais prudente usar esta opo quando a declarao est no
arquivo fonte e no no cabealho.

1 caso:

class CRectangle
{
int x, y;
public :
void set_values (int,int);
int area (void);
} rect;

No 2 caso, apresentado logo abaixo, podemos declarar objetos apenas quando precisarmos. Esta opo
de declarar o objeto depois a mais usada, pois na maioria das vezes temos o modelo dos objetos, a classe,
declarada em um arquivo de cabealho enquanto que os objetos sero criados no resto do cdigo fonte. Desta
forma mais usual criar as classes em cabealhos e depois declarar os objetos na parte do programa que for
mais conveniente.

2 caso:

class CRectangle
{
int x, y;
public :
void set_values (int,int);
int area (void);
};

int main()
{
CRectangle rect;
}

https://pt.wikibooks.org/wiki/Programar_em_C%2B%2B/Classes 5/13
14/03/2017 Programar em C++/Classes - Wikilivros

Em ambos os casos temos

CRectangle Private public

int x
int y
void set_values (int,int);
int area (void);

rect

Podemos, ento, entender os objetos como blocos de dados que tm propriedades (variveis) e que
podem fazer algo (mtodos). Ento, criamos todas as funcionalidades que precisamos que a classe fornea aos
programas, fazendo os testes necessrios para assegurar sua consistncia e estabilidade. Sempre que precisemos
utilizar os objetos s temos que instanci-los (declar-los), e no precisamos nos preocupar como eles
funcionam internamente, uma vez que os desenhamos adequadamente.

Para entendermos melhor este conceito podemos fazer uma analogia. Consideremos um objeto
resistncia: sabemos que temos de us-lo e que ela deve ter certas caractersticas, ento teremos o seu valor em
Ohms, sua potncia mxima, tolerncia, entre outras, e teremos uma funo que nos dar a corrente que passa
por ela quando lhe aplicamos uma tenso eltrica. No precisamos saber de que que ela feita, ou como estas
caractersticas internas a faz funcionar, basta-nos receber os resultados.

Vejamos o exemplo:

Agora vamos mostrar que podemos ter funes membro apenas como prottipos e defini-las fora da
classe. Para isso usamos o operador de definio de escopo :: que permite definir o local do cdigo onde um
identificador existe, no formato: ESCOPO::funo ou ESCOPO::dado. De maneira geral, quando declaramos
identificadores dentro da classe podemos defini-los no escopo global referenciando estes pelo operador de
escopo.

// classes example
#include <iostream>

using namespace std;

class CRectangle
{
int x, y;
public :
void set_values (int,int);
int area () {return (x*y);}
};

void CRectangle ::set_values (int a, int b)

{
x = a;
y = b;
}

//repare no :: que pemite-nos definir a funo membro da classe CRectangle fora da classe

int main ()
{
CRectangle rect; //definimos objeto de classe
rect.set_values (3,4); //objeto-membro
cout << "area: " << rect.area();
return 0;
}

// classes example

https://pt.wikibooks.org/wiki/Programar_em_C%2B%2B/Classes 6/13
14/03/2017 Programar em C++/Classes - Wikilivros
#include <iostream>

using namespace std;

class CRectangle
{
int x, y;
public :
void set_values (int a,int b)
{
x = a;
y = b;
}
int area () {return (x*y);}
};

int main ()
{
CRectangle rect; //definimos objeto de classe
rect.set_values (3,4); //objeto-membro
cout << "area: " << rect.area();
return 0;
}

area: 12

O exemplo anterior explora a caracterstica de toda figura geomtrica fechada, que possui uma rea
interna. Observe que este modo de definir a classe coloca o clculo da rea dentro da definio da mesma. Este
modo faz com que o cdigo seja apenas um modelo, a funo de clculo da rea no ser criada se no for
usada durante o escrita do resto do programa.

Vejamos outro exemplo:

class Dog
{
public :
void setAge (int age);
int getAge ();
void setWeight (int weight );
int getWeight ();
void speak();
private :
int age;
int weight ;
};
void Dog::setAge (int age)
{
this->age = age;
}
int Dog::getAge ()
{
return age;
}
void Dog::setWeight (int weight )
{
this->weight = weight ;
}
int Dog::getWeight ()
{
return weight ;
}
void Dog::speak()
{
cout << "BARK!!" << endl;
}

Acima podemos ver um modo de declarar as funes apenas como prottipos, que ficam dentro da
declarao da classe. Nesse contexto as funes so definidas fora da classe, usando-se o operador "::" para
ligar a funo classe. Neste caso teremos as funes definidas e construdas no cdigo das mesmas, enquanto

https://pt.wikibooks.org/wiki/Programar_em_C%2B%2B/Classes 7/13
14/03/2017 Programar em C++/Classes - Wikilivros

que o modelo da classe poder permanecer em um arquivo cabealho, o que possibilita inclu-lo em qualquer
arquivo de cdigos fontes do programa.

Definio de classes
Usa-se a palavra "class" para criar uma classe, seguindo-se depois o nome que se queira dar-lhe e
finalmente a definio da mesma entre chaves.

A definio contm:

os dados ( propriedades );
os mtodos (as funes membro)

Vamos acompanhar com um exemplo: Vamos fazer o desenho de uma classe chamada Image, que
ser usada para guardar e manipular uma imagem.

Primeiro perguntamos o que necessrio para guardar uma imagem, depois que tipo de manipulaes
necessitamos.

A imagem possui 400 pixels de largura e 300 pixels altura. Cada pixel tem as propriedades de cor e
imagem. A cor composta por: vermelho, azul e verde, numa escala de 0 a . Portanto vamos necessitar de
membros para guardar estas informaes

Agora planejemos os mtodos. Vamos, primeiramente, assumir que temos a restrio de <= 400 pixeis,
e estes valores sero feitos pelo construtor na criao do objeto. Ns no precisamos dos mtodos para estipular
a altura e largura, mas vamos precisar para obter e ler os valores. Esta estratgia tambm nos ajudar a manter
os valores de um determinado pixel e a sua localizao.

A primeira verso ento seria:

class Image {
public :
int getWidth ();
int getHeight ();
void setX(int x);
int getX();
void setY(int y);
int getY();
void setRed (double red);
double getRed ();
void setBlue (double blue);
double getBlue ();
void setGreen (double green);
double getGreen ();
private :
int _width ;
int _height ;
int _x;
int _y;
double _red[400][400];
double _blue[400][400];
double _green [400][400];
boolean isWithinSize (int s);
double clipIntensity (double brightness );
};

Especificadores de acesso
Temos as palavras reservadas private e public so os chamados especificadores de acesso.
private Especifica uma faixa de variveis ou funes que podem ser acessadas exclusivamente
por membros da classe, de forma que nenhum outro cdigo fora da mesma possa acess-las;

https://pt.wikibooks.org/wiki/Programar_em_C%2B%2B/Classes 8/13
14/03/2017 Programar em C++/Classes - Wikilivros

public Especifica uma faixa de variveis ou funes que podem ser acessadas por qualquer
cdigo no programa, sendo que para as funes internas da classe no necessrio especificar o
objeto enquanto que para as outras partes do programa necessrio especificar o objeto a qual
estas pertencem.

Esta caracterstica de limitar o acesso e manipulao dos membros de uma classe chama-se
Encapsulamento. A boa prtica no desenho de classes deve sempre forar o encapsulamento. raramente
necessrio ou desejvel ter acesso livre e pblico aos dados internos de uma classe.

O encapsulamento visa, primariamente duas metas:

1. Eliminar a necessidade de conhecimento da estrutura interna por quem deseja us-la. Por exemplo, se os
objetos precisam manter um conjunto de 4 bytes, isto pode ser conseguido usando-se duas variveis
short int, uma int, um vetor com 4 characteres, ou a variao de qualquer um dos anteriores sem sinal,
mas estes detalhes no precisam estar expostos.
2. Se a representao interna dos dados for modificada, desde que os tipos de retorno e de parmetros das
funes pblicas mantenham-se inalteradas, no necessitemos de alterar cdigo que utilizem objetos da
classe.

Ou seja, o encapsulamento simplifica a programao escondendo as particulariadades da classe e

elimina o retrabalho do cdigo por alteraes da mesma. Geralmente as funes (mtodos) privadas, so
auxiliares a outras funes da classe.

Se nenhum especificador de acesso for usado, todos os membros e metodos so declarados como
privados por padro.

H dois mtodos para definir as funes membro:

Eles podem ser definidos dentro da classe, o que apropriado para funes pequenas;
E funes grandes podem ser definidas fora da classe.

Neste caso tero de ser identificadas como pertencentes classe e para isso utilizamos o operador de
resoluo de escopo ::.

Construtores
Conceito

Os construtores "constructors" so funes membro (mtodos) especiais de uma classe. Permitem a

inicializao das variveis membro de um objeto. Ou melhor, permitem a construo e a inicializao de
objetos das classes. Se no os declararmos o compilador faz isso por ns. Os construtores tm sempre o mesmo
nome que a classe.

Os objetos so construdos atravs destas funes especiais chamadas de construtores. At aqui no os

declaramos, eram criados automaticamente. Estas funes tem certas caractersticas que as fazem distintas das
normais, que permitem que as mesmas construam a estrutura lgica inicial do objeto. Desta forma estas funes
so caractersticas da orientao a objetos e servem para criao dos mesmos.

Construtores no podem ser chamados explicitamente como fazemos no caso de funes membro
regulares. Eles so apenas executados quando um novo objeto da classe criado. Portanto, existe apenas um
evento capaz de executar um construtor, a instanciao do objeto.

As principais caractersticas dos construtores so:

No tm qualquer valor de retorno;

No podem ser executados por chamada explcita no cdigo;
https://pt.wikibooks.org/wiki/Programar_em_C%2B%2B/Classes 9/13
14/03/2017 Programar em C++/Classes - Wikilivros

So executados logo depois que os tipos bsicos do objeto foram criados;

Inicializam os dados com os valores que o objeto precisa para comear a funcionar corretamente.

Declarao

Podemos criar construtores facilmente, atravs das caractersticas que os distinguem das funes
membro convencionais. Ou seja, definimos uma funo membro que possua o mesmo nome da classe, no
tenha tipo de retorno e a declaramos como pblica para que possa ser acessada por quem queira instanciar
objetos. Vejamos como definir um construtor:

class Caneta
{ string cor;
int volume ;
///////////////
public :
Caneta ( string c, int v );
};

Caneta ::Caneta ( string c, int v )

{ cor = c;
volume = v;
}

Construtores podem iniciar os membros da classe de uma forma simplificada. Este formato usado
sempre que o construtor tem dados bsicos que podem ser iniciados antes do resto da construo da estrutura
do objeto. Podemos iniciar os dados do objeto declarando-o desta forma:

class Caneta
{ string cor;
int volume ;
///////////////
public :
Caneta ( string c, int v ) : cor(c), volume (v)
{
}
};

Para faz-lo, como vemos no cdigo, basta listar as variveis membro em uma sequncia depois da
declarao do nome do construtor e de um sinal de dois pontos ":". Iniciamos uma lista de membros, com o
valor a ser atribudo entre parnteses depois de cada um, separando-os por vrgulas.

Destrutores
Conceito

Alm do construtor a linguagem C++, assim como outras linguagens orientadas a objeto, possuem outro
tipo de funo especialmente criada e gerenciada pela linguagem, os destrutores. Estas so destinadas a
desmontar a estrutura do objeto quando o mesmo est sendo encerrado. O destrutor ter o mesmo nome da
classe, mas precedido pelo sinal til ~ e tambm no retorna valor.

O destrutor tem as seguintes caractersticas:

O destrutor chamado quando o objeto est sendo finalizado;

usado para liberar qualquer memria que tenha sido alocada;

Declarao

Faamos a classe Dog com o construtor e o destrutor.

https://pt.wikibooks.org/wiki/Programar_em_C%2B%2B/Classes 10/13
14/03/2017 Programar em C++/Classes - Wikilivros

class Dog
{
public :
Dog(); //Constructor
~Dog(); //Destructor
void setAge (int age);
int getAge ();
void setWeight (int weight );
int getWeight ();
void speak();
private :
int age;
int weight ;
};

Dog::Dog()
{
age = 0;
weight = 0;
cout << "Dog Constructor Called" << endl;
}

Dog::~Dog()
{
cout << "Dog Destructor Called" << endl;
}

Repare que:

O construtor tem o mesmo nome que a classe;

O destrutor tem o mesmo nome que a classe com o prefixo de tilde ~;
O construtor foi usado para inicializar as variveis membro, mas noutros exemplos poderia alocar
memria, tomar controle de recursos como dispositivos de sistema e executar inicializaes de cdigo;
O destrutor no exemplo no faz nenhuma ao real, para alm de fazer o eco informando que foi
chamado.

"copy constructors"
Um "copy constructor" um construtor especial que toma como argumento a referncia de um objeto da
mesma classe e cria um novo objeto que a copia do objeto em referncia. Por padro, o compilador
providencia um "copy constructor" que faz a cpia membro por membro do objeto original, construindo um
objeto idntico. Isto chamado de "shallow copy" ou "member wise".

Em algumas situaes a cpia de um objeto no satisfatria, para ver isso vamos ver a classe
employee, abaixo:

#include <iostream>
#include <string.h>

using namespace std;

class Employee
{
public :
Employee (char *name, int id);
~Employee ();
char *getName (){return _name;}
private ://Other Accessor methods
int _id;
char *_name;
};

Employee ::Employee (char *name, int id)

{
_id = id;
_name = new char[strlen (name) + 1]; //Allocates an character array object
strcpy (_name, name);
}

https://pt.wikibooks.org/wiki/Programar_em_C%2B%2B/Classes 11/13
14/03/2017 Programar em C++/Classes - Wikilivros
Employee ::~Employee ()
{
delete _name;
}

int main()
{
Employee programmer ("John" ,22);
cout << programmer .getName () << endl;
return 0;
}

A funo strlen retorna o tamanho da string passada pelo constructor. Repare que o nome do employee
agora guardado num carcter array dinmico. o string lenght +1 para permitir o null terminator usado no
estilo c.

A funo strcpy automaticamente adiciona o null terminator a string destino.

Note tambm que o destrutor liberta a memoria usada para guardar o employee name, para evitar
memory leak.

Agora imagine que o john promovido:

int main()
{
Employee programmer ("John" ,22);
cout << programmer .getName () << endl;

//Lots of code ....

Employee manager (&programmer );

//Creates a new Employee "manager",
//which is an exact copy of the
//Employee "programmer".

return 0;
}

Este programa contm um bug srio e morre com uma exceo quando executado. O problema que o
construtor que est sendo usado para criar um objeto manager", mas ele copia o endereo no ponteiro _name
em "manager".

Nos temos 2 pointers ambos contendo o mesmo endereo. Imagine que agora um novo empregado
contratado. quando o nome for atualizado, no apenas iremos alterar o nome do empregado mas tambm do
gerente. Finalmente, quando os objetos deixarem de ser usados e o destrutor da classe fizer a liberao de
espao na memria tentar liberar duas vezes para o mesmo endereo, provocando um erro no sistema de
alocao dinmica de memria, o que forar o sistema operacional a eliminar o programa da memria.

Para resolver esse problema podemos definir um construtor de cpia ("copy constructor") na classe,
substituindo a implementao padro do compilador. Este recurso automaticamente identificado e faz com
que o compilador no crie a sua verso do construtor. Assim, definir um construtor de cpia prprio a maneira
mais eficiente quando nossos objetos detm caractersticas que os fazem diferentes do padro.

Para criar o construtor basta defin-lo na classe:

class Employee
{
public :
Employee ( const Employee & e);
Employee (char *name, int id);
~Employee ();
char *getName (){return _name;}
private ://Other Accessor methods
int _id;
char *_name;

https://pt.wikibooks.org/wiki/Programar_em_C%2B%2B/Classes 12/13
14/03/2017 Programar em C++/Classes - Wikilivros
};

Employee ::Employee ( const Employee & e )

{
_id = e._id;
_name = new char[strlen (e._name) + 1]; //Allocates an character array object
strcpy (_name, e._name);
}

Agora temos um construtor que pode fazer a cpia da forma correta. Neste novo construtor alocamos
uma cadeia de caracteres para copiar o contedo da original no objeto a ser copiado e copiamos o contedo
para o novo objeto. Assim, teremos objetos distintos, cada um com seu prprio contedo.

Ver tambm
Programao orientada a objetos/Classes e Objetos - conceitos tericos

Obtido em "https://pt.wikibooks.org/w/index.php?title=Programar_em_C%2B%2B/Classes&oldid=389901"

Categorias: !Mdulos precisando de reciclagem Livro/Programar em C++

Esta pgina foi modificada pela ltima vez (s) 20h19min de 5 de novembro de 2015.
Este texto disponibilizado nos termos da licena Creative Commons Atribuio-Compartilhamento pela
mesma Licena 3.0 Unported; pode estar sujeito a condies adicionais. Consulte as Condies de Uso
para mais detalhes.

https://pt.wikibooks.org/wiki/Programar_em_C%2B%2B/Classes 13/13