Question

我在C ++程序中遇到了一个无法解决的问题。我试图传递一个对象作为另一个的构造参数，但我无法弄清楚如何做到这一点。

我的主要是创建一个Simulation对象。在模拟中，我创建了两个对象：planete和modelisation。问题是，我想在模型化对象中传递planete对象。

我的第一个对象是模拟。

#include "Simulation.h"
#include "Modelisation.h"
#include "Planete.h"

Planete *Obj;
Modelisation *Model;

Simulation::Simulation (int argc, char **argv)
{
    Obj = new Planete ("Terre", (5.98*pow(10.0,24.0)), 6378.137, 0, 0, 0);
    Model = new Modelisation (argc, argv,"Modelisation",1600 ,1004, 306, 0);
};
Simulation::~Simulation ()
{
    delete Obj;
    delete Model;
};

Modelisation.h

class Modelisation
{
private:
    int hauteur, largeur, x, y;
    int fenetre;
    //Planete ClonePlanete
public:
    Modelisation (int argc, char **argv, char[], int, int, int, int);
    ~Modelisation ();
    static void Dessiner ();
    static void Redessiner (int, int);
    void InitCallBack ();
};

Modelisation.cpp

#include "stdafx.h"
#include "Modelisation.h"
#include "Camera.h"
#include "Planete.h"

Camera *camera;

Modelisation::Modelisation (int argc, char **argv, char nomFenetre [] ,int hauteur, int largeur, int x, int y)
{

    glutInit (&argc, argv);
    glutInitDisplayMode (GLUT_SINGLE);
    glutInitWindowSize (hauteur, largeur);
    glutInitWindowPosition (x, y);
    fenetre = glutCreateWindow (nomFenetre);
    camera = new Camera;
//  Planete ClonePlanete = new Planete(planete);  // Basicaly that's what i'm trying to do
};

Modelisation::~Modelisation ()
{
    delete camera;
};

Planete.h

class Planete
{
private:
    std::string nom;
    double masse;
    double diametre;
    struct position { double x, y, z;};
    double x,y,z;

public:
    Planete (std::string nom, double masse, double diametre, double x, double y, double z);
    Planete (const Planete &);
    ~Planete ();
};

感谢您的帮助，我们将非常感激！

Answer 1

你可以在构造函数中通过常量引用传入它，然后有一个像这样初始化的私有成员：

Modelisation(const Planete& planRef) : m_planete(planRef)

还有漂亮的法语变量名;）

编辑：

这里有一些有趣的设计选择你可能想要重新考虑全局变量以支持类成员，支持智能指针而不是动态分配和释放传统方式，并考虑对象具有的关系。你的模拟是构图的主要候选者，你的行星可以使用继承和多态，因为你可以在以后更容易地使用模型绘制它们。

编辑：我很无聊......

class Planete
{
public:
    Planete (const std::string& nom, double masse, double diametre, double x, double y, double z)
        : m_nom(nom), m_masse(masse), m_position(x, y, z) {}
    virtual ~Planete() {}

    // default implementation as most planets don't have people
    virtual unsigned long HumanPopulation() { return 0; } // virtual with default implemenation, each planet can change it
    virtual double Temp() = 0; // pure virtual each planet must have it's own version
protected:
    std::string m_nom;
    double m_masse;
    double m_diametre;
    class Position
    {
    public:
        Position(double x, double y, double z)
            : x_(x), y_(y), z_(z) {}
    private:
        double x_, y_, z_;
    };
    Position m_position;
};

class Terre : public Planete // Earth is a Planet
{
public:
    Terre(double masse, double diametre, double x, double y, double z)
        : Planete("Terre", masse, diametre, x, y, z) {}
    ~Terre() {}

    // override base class default virtual
    unsigned long HumanPopulation() { return CalculatePeople(); }
    double Temp() { /* yata yata */ }

private:
    unsigned long CalculatePeople() { /* figure out how many people on earth */ }
};

class Mercure : public Planete // Mecury is also a Planet
{
public:
    Mercure(double masse, double diametre, double x, double y, double z)
        : Planete("Mercure", masse, diametre, x, y, z) {}
    ~Mercure() {}

    double Temp() { /* tres chaud */ } 
};

Answer 2

你的意思是什么？

Modelisation::Modelisation (int argc, char **argv, char nomFenetre [] ,
int hauteur,    int    largeur, int x, int y, Planet * planet)
{

};


Simulation::Simulation (int argc, char **argv)
{
   Obj = new Planete ("Terre", (5.98*pow(10.0,24.0)), 6378.137, 0, 0, 0);
   Model = new Modelisation (argc, argv,"Modelisation",1600 ,1004, 306, 0, Obj);
};

Answer 3

我不确定你究竟在问什么，但这很好用：

Simulation::Simulation (Planete* planete, Model* model)
{
    Obj = planete;
    Model = model;
};

其他几点说明：

Obj和Model应该是Simulation中的成员变量，而不是Simulation.cpp中的全局变量。
我认为将argc, argv作为参数传递给构造函数是一种主要的代码气味。相反，您的main方法应该解析命令行参数，然后将解析后的值传递给构造函数。

Answer 4

您需要在此处更改一些内容。首先，Planete和Modelisation变量应该是模拟的成员，而不是全局变量。因此，您的模拟声明将如下所示：

class Simulation
{
public:
    Simulation(int argc, char **argv);
    virtual ~Simulation();

private:
    Planete *Obj;
    Modelisation *Model;
}

关于将Planete对象传递给Modelisation，你也可以让Modelisation有一个像这样的Planete成员：

class Modelisation
{        
    // stuff you already have...
private:
    Planete *planete;
}

然后你可以改变你的Modelisation构造函数来获取Planete指针并在构造函数中赋值：

Modelisation (Planete *p, int argc, char **argv, char[], int, int, int, int)
{
    // Stuff that's already there...
    planete = p;    
}

现在你必须要小心，因为你必须确定谁拥有Planete以及谁应该删除它。删除两次会导致糟糕的事情。我建议使用shared_ptr来防止在那里做错事。

对象成员的问题

4 个答案: