Question

假设我有一辆汽车，有发动机和收音机。我想在发动机启动时启动无线电，并且想要在发动机超过一定温度时摧毁汽车。在 Thinking in C ++ 一书中，有一个组合示例帮助了我。我的想法很相似：

class Engine
{
public:
    int temperature;
    void start()
    {
        temperature = 15
    }

    void rev()
    {
        temperature += 2;
    }
}

class Radio
{
public:
    void open() {}
}

class Car
{
public:
    ~Car();
    Engine engine;
    Radio radio;
}

我知道我可以手动实施：

main()
{
    Car car;
    car.engine.start();
    car.radio.open();
    while(car != NULL)
    {
        car.engine.rev();
        if(car.engine.temperature > 50)
        {
            delete(&car);
        }
    }
}

我可能有语法错误，这并不重要。我的问题是：如何自动创建类之间的所有通信，以便

main()
{
    Car car;
    while(car!= NULL)
    {
        car.engine.rev();
    }

做同样的工作吗？我还尝试了继承和虚函数来创建通信，但失败了。

Answer 1

你好像混淆了几个问题。首先，你说你想从内部delete一个类。这通常不是一个好主意。

这里的关键是分配和释放内存以及拥有有效对象之间存在差异。您可以在班级中设置bool overheated变量，当true过热时，您将设置为Car。然后你的循环看起来像这样：

class Engine {
private:
    bool overheated;
public:
    bool isOverheated() const { return overheated; }
    void rev();

    // Rest of implementation ...
};

void Engine::rev() {
    temperature += 2;
    if (temperature > 50) overheated = true; 
}

class Car { /* ... */ };

int main() {
    Car car;
    while (!car.engine.isOverheated()) {
        car.engine.rev();
    }
}

使用NULL，delete等与内存分配有关。对于这样的课程，您通常应该分开关注点。内存分配（堆栈与堆）是一回事，对象是否处于正确状态是另一回事。

修改

如果您希望Car的状态依赖于Engine，那么就这样做：

class Car { Engine engine; public: bool isWorking() const { return !engine.isOverheated(); } };

Answer 2

首先

你的方法有很多错误，

最重要的（我认为）：您似乎将指针的概念混淆为动态分配的对象和本地声明的对象。在您的代码中Car car;不是指针。因此，它不能是NULL，您无法将其删除。

我给你一个例子

int main()
{
  // this is a pointer unitialized, so it points a random place in memory
  // (depending on what was in memory before) 
  Car * car;

  // initialization at NULL
  // the pointer points to NULL, i.e no object
  car = NULL;   

  // a car object is created in memory and the pointer `car` now points on it
  car = new car();

  // do things with your object through the pointer
  car->engine.start();

  // the car object is deleted from memory and Car points to NULL
  delete(car);

  return 0;
}

现在没有指针（这是在C ++中做事的更好方法）

int main()
{
   // car is a local object, it is automatically created by calling the default
   // constructor
   Car car;

   // do things with your object
   car.engine.start();

   return 0;

} // <- the oject is automatically destroyed when you go out of the scope

我的例子肯定不是穷举指针和本地对象之间的区别。我强烈建议您阅读更多有关面向对象编程及其概念的内容（例如封装，因为在您的情况下它也不好）。

请记住，C ++并不像其他OO语言那样可以做的事情，比如java，例如每个Object变量都像指针一样工作。

然而

关于对象行为和它们之间关系的原始问题，Lstor的答案是OO设计如何看起来的一个很好的例子。但我认为你误解了OO编程会导致你遇到那种糟糕的设计，因此我的建议是在C ++中用OO编程阅读（或仔细阅读或选择另一本书）

Answer 3

观察者模式

您可以使用观察者模式，它为引擎向任意感兴趣方传递通知提供了一般方法（通常您允许多个观察者通知所有人，但为此目的，支持一个就足够了）。

struct IEngineObserver
{
    virtual void on_overheated() = 0;
};

class Engine
{
  public:
    Engine(IEngineObserver& observer) : observer_(observer) { }

    void start()
    {
        temperature_ = 15;
    }
    void rev()
    {
        if ((temperature_ += 2) > 50)
            on_overheated();
    }
    IEngineObserver& observer_;
    int temperature_;
};

class Radio
{
  public:
    void open() {}
};

class Car : public IEngineObserver
{
  public:
    Car() : engine_(this), finito_(false) { }
    ~Car();
    virtual void on_overheat() override { finito_ = true; }
    Engine engine_;
    Radio radio_;
    bool finito_;
};

然后，您可以循环直到car.finito_为true。但是，如果在delete中有一些代码不断调用Car对象上的操作，那么main()来自引擎内的Car是没有意义的......那会崩溃。当Car在main结束时超出范围时，rev()将被销毁，因此您的重点应该是在正确的时间突破finito_循环 - 即{已设置{1}}。

Lambda和std :: function

使用lambdas和std::function可以做类似的事情，这样Car可以指定引擎在过热时运行的任意代码，如...

    Car() : engine_([&] () { finito_ = true; }), finito_(false) { }

    Engine(std::function<void (*)()>& f) : f_(f) { }

...无需额外的IEngineObserver类或on_overheat函数。

Answer 4

可能可能，即使在一般情况下不推荐，也要从内部删除对象。你可以这样做：

class A
{
public:
    void commitSuicide()
    { 
        delete this; 
    }
}

但是，在您当前的设计中，有几个问题阻止您这样做：

您正在使用堆栈中的对象，即不是指向堆中使用new分配的对象的指针。因此，禁止致电delete。
engine不知道它所属的car。因此，在engine::rev()中，调用delete this;会删除引擎，而不是汽车。一个选项是将成员car * theCarIBelongTo添加到engine，以便您可以致电delete theCarIBelongTo;。另一个选择是让方法car::revEngine()调用Engine.rev();，然后在温度过高时调用delete this;。（所以你拨打Car->revEngine()而不是Car->Engine.rev()）
最后但同样重要的是，删除对象不会导致指向对象的指针变为NULL，因此您的测试Car != NULL仍然会成功。这将在引用它时导致未定义的行为（实际上是段错误）。这是最严重的问题，主要是为什么经常不建议“自杀”。您需要更改设计以将其考虑在内。

因此，即使我的答案是对你的问题的最直接的答案，我也不建议你在这种情况下使用“自杀”范例。仔细研究提供的其他答案，它们是最有用的，并为您提供良好的实践。

Answer 5

“假设我有一辆车，有发动机和收音机。我想在发动机启动时启动收音机，并且想要在发动机超过一定温度时摧毁汽车”

引擎启动时启动收音机：来自引擎：

好的，向引擎添加一个无线电字段并从engine :: start

调用open方法

当发动机超过一定温度时摧毁汽车

好的，当您在发动机转速后增加发动机温度时，

temperature += 2;                          /// add this line
if (  temperature > 50  ) car.destroy();

引擎需要有一辆汽车才能销毁，所以确保你的引擎看起来像这样，

class Engine
{
public:
    int temperature;
    car car;
    void start()
    {
        temperature = 15
    }

    void rev()
    {
        temperature += 2;
        if (  temperature > 50  ) car.destroy();
    }
}



main()
{
    Car car; 
    CAR.ENGINE.CAR = CAR;
    CAR.ENGINE.RADIO = CAR.RADIO;

    while(car!= NULL)
    {
        car.engine.rev();
    }

C'a froid，NON？

C ++中面向对象的设计问题

5 个答案:

首先

然而

观察者模式

Lambda和std :: function