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:// 编写的 SDL Sprite C++ 类ken-soft.com/?p=234

一切似乎都工作得很好。不过，我对这种方法的任何反馈都很感兴趣。 我注意到一个问题。如果我像这样初始化我的类：（方法2）

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

然后我会遇到各种内存问题，有时事情无法正常工作（您可以通过更改我在 main.c 中初始化所有 Sprite 对象的方式来看到这一点。我的 Sprite 演示的 cpp）。
这正常吗？或者行为应该是相同的吗？
编辑设置器主要是为了让我的初始化工作更轻松。我的主要问题是方法 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 调用 A 的复制构造函数。如果您只执行了 A a; ，它就会使用默认构造函数创建一个 A 的新实例。

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

因此，本质上，该行正在创建 A 的新实例，然后使用默认构造函数构造 A 的另一个临时实例，然后复制临时 A code> 到新的 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 超出范围，它就会尝试再次删除数据，这会导致更多问题。

Answer 2

您在那里实现的称为流畅界面。我主要在脚本语言中遇到它们，但没有理由不能在 C++ 中使用。

Answer 3

如果您真的非常讨厌一个接一个地调用大量设置函数，那么您可能会喜欢下面的代码，对于大多数人来说，这对于解决“问题”来说太过分了。

此代码演示了如何创建一个集合函数，该函数可以接受任意数量、任意顺序的集合类。

#include "stdafx.h"
#include <stdarg.h>

// Base class for all setter classes
class cSetterBase
{
public:
    // the type of setter
    int myType;
    // a union capable of storing any kind of data that will be required
    union data_t {
        int i;
        float f;
        double d;
    } myValue;

    cSetterBase( int t ) : myType( t ) {}
};

// Base class for float valued setter functions
class cSetterFloatBase : public cSetterBase
{
public:
    cSetterFloatBase( int t, float v ) :
        cSetterBase( t )
        { myValue.f = v; }
};

// A couple of sample setter classes with float values
class cSetterA : public cSetterFloatBase
{
public:
    cSetterA( float v ) :
        cSetterFloatBase( 1, v )
        {}
};
// A couple of sample setter classes with float values
class cSetterB : public cSetterFloatBase
{
public:
    cSetterB( float v ) :
        cSetterFloatBase( 2, v )
        {}
};


// this is the class that actually does something useful
class cUseful
{
public:
    // set attributes using any number of setter classes of any kind
    void Set( int count, ... );

    // the attributes to be set
    float A, B;
};

    // set attributes using any setter classes
void cUseful::Set( int count, ... )
{
    va_list vl;
   va_start( vl, count );

     for( int kv=0; kv < count; kv++ ) {
        cSetterBase s = va_arg( vl, cSetterBase );
        cSetterBase * ps = &s;
        switch( ps->myType ) {
        case 1:
            A = ((cSetterA*)ps)->myValue.f; break;
        case 2:
            B = ((cSetterB*)ps)->myValue.f; break;
        }
     }
     va_end(vl);
}


int _tmain(int argc, _TCHAR* argv[])
{
    cUseful U;
    U.Set( 2,  cSetterB( 47.5 ), cSetterA( 23 ) );
    printf("A = %f B = %f\n",U.A, U.B );
    return 0;
}

Answer 4

您可以考虑 ConstrOpt 范例。我第一次听说这个是在阅读 XML-RPC C/C++ lib 文档时： http://xmlrpc-c.sourceforge.net/doc/libxmlrpc++.html#constropt

基本上这个想法与您的类似，但是“ConstrOpt”范例使用您想要实例化的子类。然后使用默认选项在堆栈上实例化该子类，然后以与您相同的方式使用“引用链”设置相关参数。

然后，真实类的构造函数使用 constrOpt 类作为唯一的构造函数参数。

这不是最有效的解决方案，但可以帮助获得清晰且安全的 API 设计。