Constructeur de copie explicite

J'ai étendu std::string pour combler mon besoin d'avoir à écrire fonction personnalisée construire en classe string appelé CustomString

J'ai défini les constructeurs:

    class CustomString : public std::string {
    public:
        explicit CustomString(void);
        explicit CustomString(const std::string& str);
        explicit CustomString(const CustomString& customString);
        //assignment operator
        CustomString& operator=(const CustomString& customString);
    ... };

Dans le troisième constructeur (constructeur de copie) et l'opérateur d'affectation, dont la définition est:

CustomString::CustomString(const CustomString& customString):
    std::string(static_cast<std::string>(customString)) 
{}
CustomString& CustomString::operator=(const CustomString& customString){
    this->assign(static_cast<std::string>(customString));
    return *this;
}

Première puisque c'est "explicite", ce qui signifie un cast explicite est nécessaire pour affecter à un autre CustomString objet; il se plaint de la cession.

CustomString s = CustomString("test");

Je ne suis pas sûr exactement où est coulée nécessaire explicitement.

Le code fonctionne très bien si le constructeur de copie n'est pas explicite, mais je voudrais savoir et de mettre en œuvre définition explicite au lieu de "deviner la bonne fonte".

source d'informationauteur abumusamq

assignment-operator c++copy-constructor explicit stdstring

25

Explicitement le constructeur de copie signifie que le constructeur de copie ne sera pas appelé implicitement, ce qui est ce qui se passe dans l'expression:
```
CustomString s = CustomString("test");
```
Cette expression signifie littéralement: créer un temporaire CustomString en utilisant le constructeur qui prend un const char*. Implicitement appeler le constructeur de copie de CustomString pour la copie temporaire dans s.

Maintenant, si le code est correct (c'est à dire si le constructeur de copie n'était pas explicite), le compilateur permettrait d'éviter la création temporaire et éluder la copie par la construction de s directement avec le littéral de chaîne. Mais le compilateur doit toujours vérifier que la construction peut être fait et ne parvient pas là.

Vous pouvez appeler le constructeur de copie explicitement:
```
CustomString s( CustomString("test") );
```
Mais je vous recommande d'éviter le temporaire tout à fait et il suffit de créer s avec le const char*:
```
CustomString s( "test" );
```
Qui est ce que le compilateur pourrait faire de toute façon...
5

Découlant de std::string n'est pas sûr, comme std::string n'a pas de destructeur virtuel. Quant à votre question - votre copie les constructeurs devraient pas être explicite, pour permettre une telle utilisation:
```
CustomString s = "test";
```
Aussi je n'ai aucune idée de pourquoi vous voulez déclarer un constructeur par copie explicite que, comme il n'est pas nécessaire.
Explicitement un constructeur par copie ne fonctionnera que si vous déclarez votre CustomString objet:
```
CustomString s(CustomString("test"));
```

Vous devez vous connecter pour publier un commentaire.