Pourquoi ne l'opérateur = de travail sur les structures sans avoir été défini?

Si vous ne définissez pas de ces quatre méthodes (six en C++11) le compilateur va générer pour vous:

• Constructeur Par Défaut
• Constructeur De Copie
• Opérateur D'Affectation
• Destructeur
• Constructeur De Déplacement (C++11)
• Assignation De Déplacement (C++11)

Si vous voulez savoir pourquoi?

C'est pour assurer la compatibilité descendante avec C (car C les structures sont copiable à l'aide de = et dans la déclaration). Mais il fait aussi l'écriture de simples classes plus faciles. Certains diront qu'il ajoute des problèmes à cause de la "copie" du problème. Mon argument contre c'est que vous ne devriez pas avoir une classe avec des détenus BRUTE des pointeurs en elle. En utilisant l'une des pointeurs intelligents de ce problème disparaît.

Constructeur par défaut (Si pas d'autres constructeurs sont définis)

Le compilateur a généré constructeur par défaut qui fera appel à la les classes de base de constructeur par défaut et ensuite, chacun des membres de constructeur par défaut (dans l'ordre où elles sont déclarées)

Destructeur (Si aucun destructeur défini)

Appelle le destructeur de chaque membre dans l'ordre inverse de la déclaration. Puis appelle le destructeur de la classe de base.

Constructeur de copie (Si pas de constructeur de copie est défini)

Appelle le constructeur de copie de la classe de base en passant par le src de l'objet. Puis appelle le constructeur de copie de chacun des membres à l'aide de la src membres des objets comme la valeur à être copié.

Opérateur D'Affectation

Appelle la classe de base de l'opérateur d'affectation en passant par le src de l'objet. Ensuite, les appels de l'opérateur d'affectation de chaque membre à l'aide de la src objet comme valeur d'être copié.

Constructeur de déplacement (Si aucun constructeur de déplacement est défini)

Appelle la classe de base constructeur de déplacement de passage de la src de l'objet. Puis appelle le constructeur de déplacement de chacun des membres à l'aide de la src membres des objets comme la valeur qui doit être déplacé.

Opérateur D'Assignation De Déplacement

Appelle la classe de base de l'opérateur d'assignation de déplacement de passage de la src de l'objet. Ensuite, les appels de l'opérateur d'assignation de déplacement de chaque membre à l'aide de la src objet comme valeur d'être copié.

Si vous définissez une classe comme ceci:

struct some_struct: public some_base
{   
    std::string str1;
    int a;
    float b;
    char* c;
    std::string str2;
};

Ce que le compilateur va construire est:

struct some_struct: public some_base
{   
std::string str1;
int a;
float b;
char* c;
std::string str2;
//Conceptually two different versions of the default constructor are built
//One is for value-initialization the other for zero-initialization
//The one used depends on how the object is declared.
//       some_struct* a = new some_struct;     //value-initialized
//       some_struct* b = new some_struct();   //zero-initialized
//       some_struct  c;                       //value-initialized
//       some_struct  d = some_struct();       //zero-initialized
//Note: Just because there are conceptually two constructors does not mean
//      there are actually two built.
//value-initialize version
some_struct()
: some_base()            //value-initialize base (if compiler generated)
, str1()                 //has a normal constructor so just call it
//PODS not initialized
, str2()
{}
//zero-initialize version
some_struct()
: some_base()            //zero-initialize base (if compiler generated)
, str1()                 //has a normal constructor so just call it.
, a(0)
, b(0)
, c(0)   //0 is NULL
, str2()
//Initialize all padding to zero
{}
some_struct(some_struct const& copy)
: some_base(copy)
, str1(copy.str1)
, a(copy.a)
, b(copy.b)
, c(copy.c)
, str2(copy.str2)
{}
some_struct& operator=(some_struct const& copy)
{
some_base::operator=(copy);
str1 = copy.str1;
a    = copy.a;
b    = copy.b;
c    = copy.c;
str2 = copy.str2;
return *this;
}
~some_struct()
{}
//Note the below is pseudo code
//Also note member destruction happens after user code.
//In the compiler generated version the user code is empty
: ~str2()
//PODs don't have destructor
, ~str1()
, ~some_base();
//End of destructor here.
//In C++11 we also have Move constructor and move assignment.
some_struct(some_struct&& copy)
//   ^^^^  Notice the double &&
: some_base(std::move(copy))
, str1(std::move(copy.str1))
, a(std::move(copy.a))
, b(std::move(copy.b))
, c(std::move(copy.c))
, str2(std::move(copy.str2))
{}
some_struct& operator=(some_struct&& copy)
//   ^^^^  Notice the double &&
{
some_base::operator=(std::move(copy));
str1 = std::move(copy.str1);
a    = std::move(copy.a);
b    = std::move(copy.b);
c    = std::move(copy.c);
str2 = std::move(copy.str2);
return *this;
} 
};

Ce comportement est nécessaire pour maintenir la compatibilité avec C.

C ne pas vous donner la possibilité de définir/surcharger les opérateurs, les structures sont copiés normalement avec l'opérateur=.

La opérateur d'affectation (operator=) est l'un des implicitement généré fonctions pour une structure ou une classe en C++.

Ici est une référence décrivant les 4 implicitement généré membres:

http://www.cs.ucf.edu/~ferments/larchc++manual/lcpp_136.html

En bref, le générées implicitement membre effectue un memberwise copie superficielle. Voici la version longue de la page du lien:

La implicitement générés opérateur d'affectation de la spécification, en cas de besoin, est la suivante. La spécification indique que le résultat est l'objet assigné (self), et que la valeur de l'abrégé de la valeur de self dans l'après-etat self" est la même que la valeur de l'abrégé de la valeur de l'argument from.

//@(#)$Id: default_assignment_op.lh,v 1.3 1998/08/27 22:42:13 leavens Exp $
#include "default_interfaces.lh"
T& T::operator = (const T& from) throw();
//@ behavior {
//@   requires assigned(from, any) /\ assigned(from\any, any);
//@   modifies self;
//@   ensures result = self /\ self" = from\any\any;
//@   ensures redundantly assigned(self, post) /\ assigned(self', post);
//          thus
//@   ensures redundantly assigned(result, post) /\ assigned(result', post);
//@ }

les structures sont en fait une concaténation de ses composantes dans la mémoire (avec quelques rembourrage intégré pour un alignement). Lorsque vous affectez une struct la valeur de l'autre, les valeurs sont juste sortis sur.