C++ 类设计 - 轻松初始化/构建对象

Question

我使用 C++ 构建了一个类，该类具有许多 setter 函数，以及可以在运行时连续调用的各种函数。所以我最终得到的代码如下所示:

A* a = new A();
a->setA();
a->setB();
a->setC();
...
a->doA();
a->doB();

不是，这很糟糕，但我不喜欢一遍又一遍地输入“a->”。
所以我重写了我的类定义，如下所示:

class A{
public:
    A();
    virtual ~A();

    A* setA();
    A* setB();
    A* setC();
    A* doA();
    A* doB();

    // other functions

private:

    // vars
};

然后我可以像这样初始化我的类:(方法 1)

A* a = new A();
a->setA()->setB()->setC();
...
a->doA()->doB();

(我更喜欢它，因为它更容易写)
要对此进行更精确的实现，您可以查看我在 http://ken-soft.com/?p=234 上编写的 SDL Sprite C++ 类

似乎一切正常。但是，我会对对这种方法的任何反馈感兴趣。我注意到一个问题。如果我像这样初始化我的类(class):(方法 2)

A a = A();
a.setA()->setB()->setC();
...
a.doA()->doB();

然后我遇到各种内存问题，有时事情无法正常工作(您可以通过更改我在我的 Sprite 演示的 main.cpp 中初始化所有 Sprite 对象的方式来看到这一点)。
那是正常的吗？还是行为应该相同？
编辑 setter 主要是为了让我的初始化工作更轻松。我的主要问题是方法 1 和方法 2 对我来说有什么不同？

编辑:这是一个 getter 和 setter 示例:

Sprite* Sprite::setSpeed(int i) {
    speed = i;
    return this;
}

int Sprite::getSpeed() {
    return speed;
}

Answer 1

一个与您的问题无关的注释，声明 A a = A(); 可能没有按照您的预期进行。在 C++ 中，对象不是默认为 null 的引用类型，因此这种说法几乎永远不会正确。您可能只需要 A a;

A a 创建了 A 的新实例，但是 = A() 部分调用了 A' s 具有临时默认构造的 A 的复制构造函数。如果您只执行了 A a;，它就会使用默认构造函数创建 A 的新实例。

如果您没有为类显式实现自己的复制构造函数，编译器将为您创建一个。编译器创建的复制构造函数只会复制另一个对象的数据；这意味着如果您有任何指针，它不会复制指向的数据。

因此，从本质上讲，该行是创建 A 的新实例，然后使用默认构造函数构造 A 的另一个临时实例，然后复制临时 A 到新的 A，然后销毁临时的 A。如果临时 A 在其构造函数中获取资源并在其析构函数中取消分配它们，您可能会遇到对象试图使用已被取消分配的数据的问题，这是未定义的行为。

以这段代码为例:

struct A {
    A() { 
        myData = new int;
        std::cout << "Allocated int at " << myData << std::endl;
    }
    ~A() { 
        delete myData; 
        std::cout << "Deallocated int at " << myData << std::endl;
    }
    int* myData;
};

A a = A();
cout << "a.myData points to " << a.myData << std::endl;

输出看起来像这样:

Allocated int at 0x9FB7128
Deallocated int at 0x9FB7128
a.myData points to 0x9FB7128

如您所见，a.myData 指向一个已经被释放的地址。如果您尝试使用它指向的数据，您可能正在访问完全无效的数据，甚至是在内存中占用它的其他对象的数据。然后，一旦您的 a 超出范围，它将尝试第二次删除数据，这将导致更多问题。