Question

在这个人为的例子中，我有一个在构造时运行的静态初始化函数。

我想知道这是否是初始化a_，b_和c_的合法方式。或者，在构建过程中以这种方式使用它们还为时尚早吗？

DWORD SomeInitializationFunction( HANDLE*, DWORD*, DWORD* );

class MyClass
{
public:
    MyClass() : m_( MyClass::Create( &a_, &b_, &c_ ), &::CloseHandle )
    {
    };

private:

    static HANDLE Create( DWORD* a, DWORD* b, DWORD* c )
    {
        DWORD a1, b1;
        HANDLE h;

        *c = ::SomeInitializationFunction( &h, &a1, &b1 );
        if( *c == 0 )
        {
            *a = a1;
            *b = b1;
            return h;
        }
        return NULL;
    };

    boost::shared_ptr< void > m_;
    DWORD a_;
    DWORD b_;
    DWORD c_;
};

谢谢， PaulH

Answer 1

类中的成员按照在类中定义的顺序进行初始化。因此，如果你有

class A
    int t
    int u
    int v
A() : v(0), u(1), t(2) {}

然后，尽管你编写构造函数参数的顺序，首先要设置t的值，然后是u的值，最后是v的值。

因此，如果您将班级定义的顺序更改为：

class MyClass
{
public:
    MyClass() : m_( MyClass::Create( &a_, &b_, &c_ ), &::CloseHandle )
    {
    };

private:

    static HANDLE Create( DWORD* a, DWORD* b, DWORD* c )
    {
        DWORD a1, b1;
        HANDLE h;

        *c = ::SomeInitializationFunction( &h, &a1, &b1 );
        if( *c == 0 )
        {
            *a = a1;
            *b = b1;
            return h;
        }
        return NULL;
    };


    DWORD a_;
    DWORD b_;
    DWORD c_;
    boost::shared_ptr< void > m_;
};

然后你的构造函数应该没问题。

我建议发表一条评论，说你班级成员的初始化存在依赖关系，以便阅读代码的人知道不会乱搞。

使用静态初始化函数

1 个答案: