Comment puis-je forcer le constructeur de copie généré par le compilateur d'une classe à * non * être inlincé par le compilateur?

__declSpec (NOINLINE) . < / p>

La documentation indique qu'il s'applique uniquement aux fonctions des membres, mais cela fonctionne en fait avec des fonctions libres.

12,1 $ / 5- "une déclaration implicitement déclarée Le constructeur par défaut est une inine membre public de sa classe. ".

Donc, il n'y a rien grand chose que nous pouvons faire. Le constructeur implicateur doit être en ligne. Tout autre comportement à cet égard serait probablement une extension

avoir dit que

Il est probable que votre constructeur de copie manuel (que vous avez supprimé pendant le nettoyage du code) faisait la bonne chose. Par exemple, si l'un des membres (sur 17) de votre classe est un membre du pointeur, il est probable que le constructeur de copie manuelle a pris soin de la copie profonde (et a donc pris une performance touchée).

Donc, à moins que vous ne examiniez attentivement votre constructeur de copie manuelle, ne pensez même pas à le supprimer et à compter sur le constructeur de copie implicite (potentiellement buggy) (dans votre contexte)

Il est souvent préférable de l'isoler à quelques types de nœuds que vous savez problématiques. Exemple A:

/* B.hpp */

struct B {
private:

    /* class types */
    struct t_data {
        std::string member;

        /* 16 more ... */
    public:
        /* declare + implement the ctor B needs */

        /* since it is otherwise inaccessible, it will only hurt build times to make default ctor/dtor implicit (or by implementing them in the header, of course), so define these explicitly in the cpp file */
        t_data();
        ~t_data();

        /* allow implicit copy ctor and assign -- this could hurt your build times, however. it depends on the complexity/visibility of the implementation of the data and the number of TUs in which this interface is visible. since only one object needs this... it's wasteful in large systems */
    };
private:

    /* class data */
    t_data d_data;
public:
    /* you'll often want the next 4 out of line
       -- it depends on how this is created/copied/destroyed in the wild
     */
    B();
    B(const B& other);
    ~B();
    B& operator=(const B&);
};

/* B.cpp */

/* assuming these have been implemented properly for t_data */
B::B() : d_data() {
}

B::B(const B& other) : d_data(other) {
}

B::~B() {
}

B& B::operator=(const B&) {
    /* assuming the default behaviour is correct...*/
    this->d_data = other.d_data;
    return *this;
}
/* continue to B::t_data definitions */

Je doute fortement l'inlinisation a quelque chose à voir avec ça. Si le compilateur augmente la copie CTOR générée par le compilateur, pourquoi ne serait-ce pas également définie explicitement? (Il est également inhabituel que les heuristiques d'optimisation du compilateur échouent si mal pour rendre un code inliné à 5% plus lent)

Avant de sauter aux conclusions,

• Vérifiez l'ensemble généré pour vérifier que les deux versions réalisent réellement exactement la même chose (et dans le même ordre, en utilisant le même assemblage, etc., car sinon, ce qui pourrait être la source de votre différence de performance)
• Vérifiez que le compilateur généré par un est étant inliné, et le défini manuellement est pas . .

  Si tel est le cas, pourriez-vous mettre à jour votre question avec ces informations?

  Il n'y a aucun moyen en C ++ pour indiquer si une fonction générée par le compilateur devrait ou ne doit pas être inlinée. Pas même des extensions spécifiques aux fournisseurs telles que __ DeclSpec (NOINLINE) vous aideront, puisque vous remettez explicitement la responsabilité de la fonction au compilateur. Donc, le compilateur choisit quoi faire avec elle, comment la mettre en œuvre et savoir s'il le fasse ou non. Vous ne pouvez pas tous les deux dire "Veuillez implémenter cette fonction pour moi", et en même temps "Veuillez me permettre de contrôler la manière dont la fonction est mise en œuvre". Si vous souhaitez contrôler la fonction, vous devez la mettre en œuvre. ;)

  in c ++ 0x, il est possible peut être possible (en fonction de la manière dont ces extensions spécifiques au fournisseur interagissent avec des fonctions déclarées comme = par défaut ).

  Mais encore une fois, je ne suis pas convaincu que l'inlinage est la question. Très probablement, les deux fonctions aboutissent à un code de montage différent généré.