pointeur modèle de classe

Question

Voici le code compilable et le problème est toujours là

#include <iostream> 
#include <string>  

template<typename A,typename B,typename C> 
class Mesh{ 
    public: 
    Mesh(){} 
    Mesh(std::string file){ 
    A foo; 
    std::cout << file << endl; 
    } 
};  

template<typename A, typename B,typename C>  
class Eq{  
public:  
    Mesh<A,B,C>* pmesh;  
    Eq() {} 
    Eq(Mesh<A,B,C> *pmesh_){ 
     pmesh = pmesh_; 
    } 
}; 

template<typename A, typename B,typename C> 
class Pipe{ 
public: 
    Mesh<A, B,C> mesh; 
    Eq<A, B, C> eq1; 

    Pipe(){} 
    Pipe(std::string file){ 
     mesh = Mesh<A, B, C>(file); 
     eq1 = Eq<A,B,C>(&mesh); 
     std::cout << "P:"<<&mesh << " "; 
    } 
}; 

template<typename A,typename B, typename C> 
class Simulator { 
public: 
    Pipe<A,B,C> pipe; 

    Simulator(){} 
    Simulator(std::string file){ 
     pipe = Pipe<A,B,C>(file); 
     std::cout << "S:"<<&(pipe.mesh)<<" "; 
    } 
}; 

using namespace std; 
int main() { 
    typedef double A; 
    typedef double B; 
    typedef int C; 

    Simulator< A, B, C> simu("mesh"); 
} 

La sortie du programme est

maille T
P: 0018FE44 S: 0018FE3C

Je pense le problème est dans la déclaration de pipe, si je définis sinulator comme

template<typename A,typename B, typename C>  
class Simulator { 
public: 
    Pipe<A,B,C>* ppipe; 

Simulator(){} 
    Simulator(std::string file){ 
     ppipe = new Pipe<A,B,C>(file); 
     std::cout << "S:"<<&(ppipe->mesh)<<" "; 
    } 
}; 

la sortie est

maille P: 00308F08 S: 00308F08

une idée, pourquoi le premier code est erroné ??

Answer 1

Le problème est avec votre copie dans le constructeur de simulateur. Ce code devrait rendre les choses un peu plus évidentes.

Cela n'a rien à voir avec les modèles.

#include <iostream> 

struct Mesh{ Mesh() { std::cout << "M:" << this << " ";} }; 

struct Pipe{ 
    Mesh mesh; 

    Pipe() { std::cout << "PX:" << &mesh << " "; } 
    Pipe(int file){ 
     std::cout << "P1:"<<&mesh << " "; 
     mesh = Mesh(); 
     std::cout << "P2:"<<&mesh << " "; 
    } 
}; 

struct Simulator { 
    Pipe pipe; 

    Simulator(){ 
     std::cout << "S1:"<<&(pipe.mesh)<<" "; 
     pipe = Pipe(2); 
     std::cout << "S2:"<<&(pipe.mesh)<<" "; 
    } 
}; 

int main() { 
    Simulator simu; 
} 

sortie:

:!./temp2 
M:0x7fffffffea97 PX:0x7fffffffea97 <-- the setup of Simulator, before the constructor 
S1:0x7fffffffea97 
    M:0x7fffffffea96 <-- setup of the Pipe object, before the Pipe constructor 
    P1:0x7fffffffea96 M:0x7fffffffea95 P2:0x7fffffffea96 
S2:0x7fffffffea97 

Lorsque vous appelez le constructeur du simulateur, il crée d'abord l'objet. Comme l'un des membres est "Pipe pipe", cet objet est créé à l'emplacement mémoire ea97. Ensuite, nous appelons explicitement le constructeur Pipe (std :: string) pour créer un autre objet.

Dans le constructeur Pipe, la même chose se produit. Nous avons déjà un objet Mesh à ea96, mais nous en créons un autre (à ea95) et le copions dans cet endroit avec la fonction de copie intégrée.

Ensuite, nous sommes de retour au constructeur du simulateur, où l'objet Pipe nouvellement créé est copié à l'emplacement de SimulatorObject.pipe (ea97). EDIT: en supprimant quelques morceaux de plus qui n'ont pas d'importance ... afin que vous puissiez voir clairement quand chaque constructeur est appelé.

La syntaxe que vous cherchez est probablement

struct Simulator { 
    Pipe pipe; 

    Simulator(): pipe(2){ 
     std::cout << "S1:"<<&(pipe.mesh)<<" "; 
    } 
}; 

Cela initialiser l'objet de tuyau à l'intérieur Simulator « en place ». Notez que ce n'est pas vraiment un gros problème. Vos objets copieront quand ils sont censés.

Si vous avez un objet qui ne peut être copié (il gère une connexion de base de données ou quelque chose), vous pouvez interdire que par la création d'un constructeur de copie et un opérateur = surcharge qui sont à la fois « privé: »

Answer 2

Une version la compilation de votre code ne montre pas le même comportement:

#include <iostream> 
template<typename A> class Mesh{public: A foo; }; 

template<typename A> 
struct Eq{ 
    Mesh<A>* pmesh; 
    Eq(Mesh<A> *pmesh_){ 
     pmesh = pmesh_; 
    } 
    Eq() {} 
}; 

template<typename A> 
struct Pipe{ 
    Mesh<A> mesh; 
    Eq<A> eq1; 

    Pipe() { 
     mesh = Mesh<A>(); 
     eq1 = Eq<A>(&mesh); 
     std::cout << "P:"<<&mesh << " "; 
    } 
}; 
template<typename A> 
struct Sim { 
    Sim() { 
     Pipe<A> pipe; 
     std::cout << "S:"<<&(pipe.mesh)<<" "; 
    } 
}; 

int main() { 
    Sim<int> bar; 
} 

Son exécution:

[@foomanchu]$ ./temp 
P:0x7fffffffeaf0 S:0x7fffffffeaf0 [@foomanchu]$