Quando um novo objeto é gerado a partir de um objeto existente como uma cópia do objeto existente, a função de cópia Object () {[código nativo]} é nomeada. Quando um objeto inicializado anteriormente recebe um novo valor de outro objeto, o operador de atribuição é usado. Function Object () {[código nativo]} é uma função de membro que usa outro objeto da mesma classe para inicializar um objeto. A seguir está um protótipo de função geral para uma função de cópia Object () {[código nativo]}:
Sintaxe:
Classname (const classname & obj);
Entrada:
#include
usando namespace std;
class Point
{
privado:
int a, b;
público: co
Ponto (int x1, int y1) {a=x1; b=y1; }
//Copiar construtor
Ponto (const Ponto & p1) {a=p1.a; b=p1.b; }
int getX () {return a; }
int getY () {return b; }
};
int main ()
{
Ponto p1 (10, 15);//O construtor normal é chamado aqui
Ponto p2=p1;//O construtor de cópia é chamado aqui
//Vamos acessar os valores atribuídos pelos construtores
cout <<"p1.x="<
Quando é necessário um construtor de cópia definido pelo usuário?
De acordo com o construtor de cópia C ++, o compilador C ++ produz um construtor de cópia padrão Object () {[código nativo]} para cada classe se não definir o próprio construtor de cópia Object () {[código nativo]}, que executa uma cópia do membro entre os itens. Em geral, a função de cópia Object () {[código nativo]} gerada pelo compilador funciona bem. Ele só precisa definir sua própria função de cópia Object () [código nativo] se um objeto tiver ponteiros ou qualquer alocação de recurso de tempo de execução, como um identificador de arquivo ou uma conexão de rede.
Destaque-se de seus colegas esta avaliação Temporada
Comece a aprender com nossos cursos GRATUITOS Inscreva-se agora
Copiar Construtor vs Operador de Atribuição
Quando um novo objeto é gerado a partir de um objeto existente como uma cópia do objeto existente, a função de cópia Object () {[código nativo]} é nomeada. Quando um objeto já inicializado recebe um novo valor de outro objeto, o operador de atribuição é usado.
Myclass c1, c2;
Myclass c3;
c2=c1;
A linha acima ilustra o construtor de cópia
Onde o construtor de cópia é necessário:
Entrada:
#include
#include
usando namespace std;
class String
{
privado:
char * s;
tamanho interno;
público:
String (const char * str=NULL);//construtor
~ String () {delete [] s; }//destruidor
String (const String &);//copiar construtor
void print () {cout <
void change (const char *);//Função para alterar
};
String:: String (const char * str)
{
size=strlen (str);
s=novo caractere [tamanho + 1];
strcpy (s, str);
}
void String:: change (const char * str)
{
delete [] s;
size=strlen (str);
s=novo caractere [tamanho + 1];
strcpy (s, str);
}
String:: String (const String & old_str)
{
size=old_str.size;
s=novo caractere [tamanho + 1];
strcpy (s, old_str.s);
}
int main ()
{
String str1 (“Bem-vindo”);
String str2=str1;
str1.print ();//o que é impresso?
str2.print ();
str2.change (“Bem-vindo a todos”);
str1.print ();//o que é impresso agora?
str2.print ();
return 0;
}
Resultado:
O que acontece se removermos o construtor de cópia do código acima?
No construtor de cópia c ++, os usuários não obtêm o resultado previsto se excluirmos a função de cópia Object () {[código nativo]} do programa acima. As alterações em str2 também são refletidas em str1, o que é inesperado.
Entrada:
#include
#include
usando namespace std;
class String
{
privado:
char * s;
tamanho interno;
público:
String (const char * str=NULL);//construtor
~ String () {delete [] s; }//destruidor
void print () {cout <
void change (const char *);//Função para mudar
};
String:: String (const char * str)
{
size=strlen (str);
s=novo caractere [tamanho + 1];
strcpy (s, str);
}
void String:: change (const char * str)
{
delete [] s;
size=strlen (str);
s=novo caractere [tamanho + 1];
strcpy (s, str);
}
int main ()
{
String str1 (“Bem-vindo”);
String str2=str1;
str1.print ();//o que é impresso?
str2.print ();
str2.change (“Bem-vindo a todos”);
str1.print ();//o que é impresso agora?
str2.print ();
return 0;
}
Resultado:
Como tornar o construtor de cópia privado?
De acordo com o construtor de cópia C ++, é possível fazer uma função de cópia Object () {[código nativo]}. Quando uma função de cópia Object () {[código nativo]} em uma classe se torna privada, os objetos daquela classe se tornam não copiáveis. Isso é especialmente útil quando a classe contém ponteiros ou recursos que são alocados dinamicamente. Nesses casos, ele pode escrever nossa própria função de cópia Object () {[código nativo]}, como no exemplo String acima, ou criar uma função de cópia privada Object () {[código nativo]}, caso em que os usuários irão receba erros do compilador em vez de avisos.
Por que um argumento para um construtor de cópia deve ser passado como referência?
De acordo com o construtor de cópia C ++, quando um objeto é transferido por valor, uma função de cópia Object () {[código nativo]} é nomeada. A função de cópia Object () {[código nativo]} é uma função em si mesma. Se um argumento é passado por valor em uma função de cópia Object () {[código nativo]}, uma chamada para copiar a função Object () {[código nativo]} é feita para chamar a função de cópia Object () {[código nativo]} , resultando em uma sequência de chamadas sem término. Como resultado, o compilador não permitirá que você mova parâmetros por valor.
Curso Full Stack Web Developer
Para se tornar um especialista em MEAN Stack Ver Curso
Por que o argumento do construtor de cópia deve ser Const em C ++?
De acordo com o construtor de cópia C ++, passamos um objeto por referência à função de cópia Object () {[código nativo]}, e normalmente o passamos como uma referência const. Uma justificativa para passar uma referência const é que ele pode usar const sempre que possível em C ++ para evitar a alteração involuntária de objetos. Esta é uma desculpa convincente para transferir referências como const, mas existem outras.
Entrada:
#include
usando namespace std;
teste de classe
{
/* Membros de dados da classe */
público:
Teste (Teste & t) {/* Copie membros de dados de t */}
Test () {/* Inicializar membros de dados */}
};
Teste divertido ()
{
cout <<"fun () Chamado \ n";
Teste t;
return t;
}
int main ()
{
Teste t1;
Teste t2=diversão ();
return 0;
}
Resultado:
É necessário alterar o construtor de cópia da seguinte forma:
Test (const Test & t) {cout <<"Copiar construtor chamado \ n"; }
A função fun () retorna um valor. Como resultado, o compilador gera uma entidade temporária, que é então copiada para t2 usando a função de cópia do programa original Object () {[código nativo]} (O objeto temporário é passado como um argumento para o construtor de cópia). O erro do compilador ocorre porque os objetos temporários criados pelo compilador não podem ser vinculados a referências não constantes, apesar de o programa original tentar fazer isso. Não faz sentido mudar algo que não está quebrado.
Avance sua carreira como desenvolvedor MEAN stack com o Desenvolvedor Web Full Stack-Programa MEAN Stack Master . Inscreva-se agora!
Conclusão
De acordo com o construtor de cópia C ++, quando um objeto é feito, uma função Object () {[código nativo]} é um tipo especial de função-membro que é chamada automaticamente. Uma função Object () {[código nativo]} em C ++ tem o mesmo nome da classe à qual pertence e não tem um formulário de retorno.
Neste artigo, você aprendeu sobre pilha, implementação, operações com sintaxe e exemplos. Para obter experiência em programação C ++, você pode ingressar em Curso de treinamento de certificação C ++ da Simplilearn . Para os alunos, a Simplilearn fez uma seleção especial de cursos disponíveis gratuitamente. Participe dos cursos gratuitos do Simplilearn e revolucione sua profissão com certificados, especializações e dezenas de outros cursos.
Tem alguma pergunta para nós? Deixe-os na seção de comentários deste artigo e nossos especialistas entrarão em contato com você sobre eles, o mais rápido possível!
