Le constructeur de copie de classe C++ n'a pas de fonction correspondante.

Question

J'essaie d'écrire une classe Core, dont la variable membre est un pointeur. Le constructeur de la copie est Core(Core& x) au lieu de Core(const Core& x) .

Le noyau a une fonction membre Core Core::new_core (int * ptr) le code a un problème lorsque j'essaie de construire Core new_core= core.new_core(ptr); veuillez consulter le code et les informations sur les erreurs ci-dessous.

#include<iostream>

class Core
{
    private:
    int* a;

    public:
    Core(int* in) {a=in;}
    Core(Core& x) {a = x.data();}

    inline const int * data() const {return a;}
    inline       int * data()       {return a;}

    Core new_core (int * ptr)
    {
        Core b(ptr);
        return b;
    }
};

using namespace std;

int main()
{
    int ptr[3]= {1,2,3};
    Core core(ptr);
    Core new_core= core.new_core(ptr);
    cout<< new_core.data() <<endl;
    return 0; 
}

Information sur les erreurs :

main.cpp : Dans la fonction 'int main()' :

main.cpp:30:37 : error : no matching function for call to 'Core::Core(Core)' (erreur : aucune fonction correspondante pour l'appel à 'Core::Core(Core)').

Core new_core= core.new_core(ptr);
                                 ^

main.cpp:30:37 : note : les candidats sont :

main.cpp:12:6 : note : Core::Core(Core&)

 Core(Core& x) { a = x.data() ;}
 ^

main.cpp:12:6 : note : pas de conversion connue pour l'argument 1 de 'Core' vers >'Core&'.

main.cpp:10:6 : note : Core::Core(int*)

 Core(int* in) {a=in;}
 ^

main.cpp:10:6 : note : no known conversion for argument 1 from 'Core' to en 'int*'.

Je peux facilement résoudre le problème en remplaçant

Core(Core& x) { a = x.data() ;}

à

Core(const Core& x) { a = const_cast<int* > ( x.data() ) ;}, 

Existe-t-il un meilleur moyen de résoudre le problème sans utiliser const_cast ?

Je veux garder int* a privé, et garder les deux lignes suivantes :

inline const int * data() const {return a;}
inline       int * data()       {return a;}

Merci.

Answer 1

Le problème ici est que new_core renvoie un Core qui est temporaire. Lorsque vous l'utilisez dans

Core new_core= core.new_core(ptr);

Le compilateur appelle le constructeur de copie mais il ne peut pas se lier à ce temporaire puisqu'il prend une référence. Pour résoudre ce problème, nous pouvons changer le constructeur de copie pour qu'il prenne une référence. const Core& qui peut se lier au temporaire et vous permettre d'en faire une copie.

Dans cet exemple, pour contourner le const et l'utilisation de const_cast nous pouvons accéder directement au membre de la classe comme :

Core(const Core& x) : a(x.a) {}