appelez le constructeur de copie de l'opérateur d'assignation de fonction

La ligne incriminée n'est pas ce que vous pensez qu'elle est. Il fait déclare une variable other de type FeatureValue. C'est parce que les constructeurs de ne pas avoir de noms et ne peut pas être appelée directement.

Vous pouvez appeler l'opérateur d'assignation de copie à partir du constructeur, tant que l'opérateur n'est pas déclarée virtuelle.

FeatureValue::FeatureValue(const FeatureValue& other)
    : m_value(nullptr), m_size(0)
{
    *this = other;
}

//assignment operator function
FeatureValue& FeatureValue::operator=(const FeatureValue& other)
{
    if(this != &other)
    {
        //copy data first. Use std::unique_ptr if possible
        //avoids destroying our data if an exception occurs
        uint8_t* value = new uint8_t[other.m_size];
        int size = other.m_size;  

        for (int i = 0; i < other.m_size; i++)
        {
            value[i] = other.m_value[i];
        }

        //Assign values
        delete[] m_value;
        m_value = value;
        m_size = size;
    }
    return *this;
}

Cela travaille juste dandy ou vous pouvez utiliser le typique lignes directrices pour la copie & échanger de l'idiome suggéré dans Vaughn de Caton répondre

OriginalL'auteur Captain Obvlious

Réponse courte - ne pas le faire.

Détails:

//copy constructor 
FeatureValue::FeatureValue(const FeatureValue& other)
{
    m_size = other.m_size;  
    delete[] m_value;      //m_value NOT INITIALISED - DON'T DELETE HERE!
    m_value = new uint8_t[m_size];

    for (int i = 0; i < m_size; i++)
    {
        m_value[i] = other.m_value[i];
    }
}

//assignment operator function
FeatureValue& FeatureValue::operator=(const FeatureValue& other)
{
    FeatureValue(other); //error C2082: redefinition of formal parameter
    return *this;
}

Notes:

• Lorsque le constructeur de copie est appelé, c'est la construction du nouvel objet avec référence à l'objet à copier, mais le constructeur par défaut n'est pas exécuté avant que le constructeur de copie. Cela signifie m_value a une valeur indéterminée lorsque le constructeur de copie commence à courir: vous pouvez attribuer à elle, mais à lire c'est un comportement indéterminé, et à delete[] considérablement le pire (si quelque chose peut être pire que UD! ;-)). Donc, il suffit de laisser que delete[] ligne.

Prochaine, si operator= essaie de tirer parti de la fonctionnalité de l'constructeur de copie, il a d'abord communiqué toutes les données existantes m_value pointe ou il sera coulé. La plupart des gens essayer de faire comme suit (qui est cassé) - je pense que c'est ce que vous essayiez de:

FeatureValue& FeatureValue::operator=(const FeatureValue& other)
{
    //WARNING - this code's not exception safe...!
    ~FeatureValue();  //call own destructor
    new (this) FeatureValue(other); //reconstruct object
    return *this;
}

Le problème avec cela est que si la création de FeatureValue échoue (par exemple, parce que new ne pouvez pas obtenir le mémoire qu'il veut), puis le FeatureValue objet est mis avec un état non valide (par exemple, m_value peut être orienté dans l'espace). Plus tard, lorsque le destructeur court et fait un delete[] m_value, vous avez un comportement indéterminé (votre programme sera probablement planter).

Vous devriez vraiment cette approche de manière plus systématique... soit l'écrire, étape par étape, ou peut-être la mise en œuvre d'une garantie de non-lancer swap() méthode (facile à faire... juste std::swap() m_size et m_value, et de l'utiliser ala:

FeatureValue& FeatureValue::operator=(FeatureValue other)
{
    swap(other);
    return *this;
}

C'est facile et propre, mais il a un couple mineurs de la performance/les problèmes d'efficacité:

• maintien de l'existant m_value tableau plus longtemps que nécessaire, ce qui augmente utilisation maximale de la mémoire... on pourrait appeler clear(). Dans la pratique, la plupart des non-trivial programmes ne se soucient pas de cela, sauf si la structure de données en question a été la tenue d'énormes quantités de données (par exemple, des centaines de méga-octets ou giga-octets pour une application PC).

• de ne même pas essayer de réutiliser l'existant m_value de mémoire au lieu de toujours faire un autre new pour other (qui peut mener à la réduction de l'utilisation de la mémoire mais n'est pas toujours utile).

En fin de compte, les raisons, il peut être distinct du constructeur de copie et l' operator= - plutôt que de demander au compilateur de créer automatiquement l'un de l'autre -, c'est que de manière optimale efficace des implémentations ne peut pas - en général - l'effet de levier les uns des autres dans la façon dont vous l'auriez espéré.

OriginalL'auteur Tony Delroy