102

我有一个有几个对象作为成员变量的类。我不希望在声明时调用这些成员的构造函数，所以我试图明确地挂在指向对象的指针上。我不知道我在做什么。

我想也许我可以执行以下操作，在初始化对象成员变量时立即调用构造函数：

class MyClass {
    public:
        MyClass(int n);
    private:
        AnotherClass another(100); // Construct AnotherClass right away!
};

但我希望MyClass构造函数调用AnotherClass构造函数。这是我的代码的样子：

文件BigMommaClass.h

#include "ThingOne.h"
#include "ThingTwo.h"

class BigMommaClass {

        public:
                BigMommaClass(int numba1, int numba2);

        private:
                ThingOne* ThingOne;
                ThingTwo* ThingTwo;
};

文件BigMommaClass.cpp

#include "BigMommaClass.h"

BigMommaClass::BigMommaClass(int numba1, int numba2) {
        this->ThingOne = ThingOne(100);
        this->ThingTwo = ThingTwo(numba1, numba2);
}

这是我尝试编译时遇到的错误：

g++ -Wall -c -Iclasses -o objects/BigMommaClass.o classes/BigMommaClass.cpp
In file included from classes/BigMommaClass.cpp:1:0:
classes/BigMommaClass.h:12:8: error: declaration of âThingTwo* BigMommaClass::ThingTwoâ
classes/ThingTwo.h:1:11: error: changes meaning of âThingTwoâ from âclass ThingTwoâ
classes/BigMommaClass.cpp: In constructor âBigMommaClass::BigMommaClass(int, int)â:
classes/BigMommaClass.cpp:4:30: error: cannot convert âThingOneâ to âThingOne*â in assignment
classes/BigMommaClass.cpp:5:37: error: â((BigMommaClass*)this)->BigMommaClass::ThingTwoâ cannot be used as a function
make: *** [BigMommaClass.o] Error 1

我是否使用了正确的方法，但语法错误？还是我应该从不同的方向来？

4

5 回答 5

110

您可以在成员初始化器列表中指定如何初始化成员：

BigMommaClass {
    BigMommaClass(int, int);

private:
    ThingOne thingOne;
    ThingTwo thingTwo;
};

BigMommaClass::BigMommaClass(int numba1, int numba2)
    : thingOne(numba1 + numba2), thingTwo(numba1, numba2) {}
于 2012-10-17T04:39:09.563 回答
38

您正在尝试ThingOne通过使用operator=which 不起作用（语法不正确）来创建一个。此外，您使用类名作为变量名，即ThingOne* ThingOne. 首先，让我们修复变量名称：

private:
    ThingOne* t1;
    ThingTwo* t2;

由于这些是指针，它们必须指向某些东西。如果对象尚未构建，则需要在BigMommaClass构造函数中使用 new 显式执行此操作：

BigMommaClass::BigMommaClass(int n1, int n2)
{
    t1 = new ThingOne(100);
    t2 = new ThingTwo(n1, n2);
}

然而，通常初始化列表是构造的首选，所以它看起来像：

BigMommaClass::BigMommaClass(int n1, int n2)
    : t1(new ThingOne(100)), t2(new ThingTwo(n1, n2))
{ }
于 2012-10-17T04:39:57.510 回答
12

这个问题有点老了，但这是 C++11 在初始化成员变量之前在构造函数中“做更多工作”的另一种方式：

BigMommaClass::BigMommaClass(int numba1, int numba2)
    : thingOne([](int n1, int n2){return n1+n2;}(numba1,numba2)),
      thingTwo(numba1, numba2) {}

上面的 lambda 函数将被调用，并将结果传递给 thingOnes 构造函数。你当然可以让 lambda 变得像你喜欢的那样复杂。

于 2015-12-03T23:28:43.523 回答
7

我知道这是 5 年后的事了，但上面的回复并没有解决你的软件出了什么问题。（嗯，Yuushi 有，但直到我输入了这个我才意识到 - 哦！）。他们回答了标题中的问题如何在构造函数中初始化 C++ 对象成员变量？这是关于其他问题：我是否使用了正确的方法但语法错误？还是我应该从不同的方向来？

编程风格在很大程度上是一个见仁见智的问题，但在构造函数中尽可能多地做的另一种观点是将构造函数保持在最低限度，通常具有单独的初始化函数。无需尝试将所有初始化都塞入构造函数中，更不用说有时尝试将事物强制放入构造函数初始化列表中。

那么，直截了当，您的软件出了什么问题？

private:
    ThingOne* ThingOne;
    ThingTwo* ThingTwo;

请注意，在这些行之后，ThingOne(和ThingTwo) 现在有两个含义，具体取决于上下文。

在 BigMommaClass 之外，ThingOne是您创建的类#include "ThingOne.h"

BigMommaClass 内部ThingOne是一个指针。

那是假设编译器甚至可以理解这些行并且不会陷入循环，认为这 ThingOne是一个指向某物的指针，该指针本身就是指向某物的指针，该指针指向...

后来，当你写

this->ThingOne = ThingOne(100);
this->ThingTwo = ThingTwo(numba1, numba2);

请记住，BigMommaClass您的内部ThingOne是一个指针。

如果您更改指针的声明以包含前缀 (p)

private:
    ThingOne* pThingOne;
    ThingTwo* pThingTwo;

然后ThingOne将始终引用类和pThingOne指针。

然后可以重写

this->ThingOne = ThingOne(100);
this->ThingTwo = ThingTwo(numba1, numba2);

作为

pThingOne = new ThingOne(100);
pThingTwo = new ThingTwo(numba1, numba2);

它纠正了两个问题：双重含义问题和缺失new. （如果你愿意，你可以离开this->！）

有了它，我可以将以下几行添加到我的 C++ 程序中，它编译得很好。

class ThingOne{public:ThingOne(int n){};};
class ThingTwo{public:ThingTwo(int x, int y){};};

class BigMommaClass {

    public:
            BigMommaClass(int numba1, int numba2);

    private:
            ThingOne* pThingOne;
            ThingTwo* pThingTwo;
};

BigMommaClass::BigMommaClass(int numba1, int numba2)
{
    pThingOne = new ThingOne(numba1 + numba2);
    pThingTwo = new ThingTwo(numba1, numba2);
};

当你写

this->ThingOne = ThingOne(100);
this->ThingTwo = ThingTwo(numba1, numba2);

的使用this->告诉编译器左边ThingOne的意思是指针。但是我们BigMommaClass当时在里面，没有必要。

问题在于等号的右侧，其中ThingOne的意思是类。所以另一种纠正你的问题的方法是写

this->ThingOne = new ::ThingOne(100);
this->ThingTwo = new ::ThingTwo(numba1, numba2);

或者干脆

ThingOne = new ::ThingOne(100);
ThingTwo = new ::ThingTwo(numba1, numba2);

用于::更改编译器对标识符的解释。

于 2018-08-30T12:00:29.107 回答
3

关于克里斯的第一个（也是很好的）答案，他提出了一个解决方案，即类成员被视为“真正的复合”成员（即不是指针或 引用 ）：

注释有点大，所以我将在这里用一些示例代码进行演示。

当你像我提到的那样选择持有成员时，你还必须记住这两件事：

  1. 对于每个没有默认构造函数的“组合对象” - 您必须在“父”类的所有构造函数的初始化列表中对其进行初始化（即 -BigMommaClass或MyClass在原始示例和MyClass下面的代码中），以防万一有几个（见InnerClass1下面的例子）。这意味着，您可以“注释掉”m_innerClass1(a)并且m_innerClass1(15) 仅当您启用InnerClass1默认构造函数时。

  2. 对于确实具有默认构造函数的每个“组合对象” - 您可以在初始化列表中对其进行初始化，但如果您选择不这样做，它也将起作用（参见InnerClass2下面的示例）。

查看示例代码（在Ubuntu 18.04（Bionic Beaver）下编译，g++版本 7.3.0）：

#include <iostream>

using namespace std;

class InnerClass1
{
    public:
        InnerClass1(int a) : m_a(a)
        {
            cout << "InnerClass1::InnerClass1 - set m_a:" << m_a << endl;
        }

        /* No default constructor
        InnerClass1() : m_a(15)
        {
            cout << "InnerClass1::InnerClass1() - set m_a:" << m_a << endl;
        }
        */

        ~InnerClass1()
        {
            cout << "InnerClass1::~InnerClass1" << endl;
        }

    private:
        int m_a;
};

class InnerClass2
{
    public:
        InnerClass2(int a) : m_a(a)
        {
            cout << "InnerClass2::InnerClass2 - set m_a:" << m_a << endl;
        }

        InnerClass2() : m_a(15)
        {
            cout << "InnerClass2::InnerClass2() - set m_a:" << m_a << endl;
        }

        ~InnerClass2()
        {
            cout << "InnerClass2::~InnerClass2" << endl;
        }

    private:
        int m_a;
};

class MyClass
{
    public:
        MyClass(int a, int b) : m_innerClass1(a), /* m_innerClass2(a),*/ m_b(b)
        {
            cout << "MyClass::MyClass(int b) - set m_b to:" << m_b << endl;
        }

         MyClass() : m_innerClass1(15), /*m_innerClass2(15),*/ m_b(17)
        {
            cout << "MyClass::MyClass() - m_b:" << m_b << endl;
        }

        ~MyClass()
        {
            cout << "MyClass::~MyClass" << endl;
        }

    private:
        InnerClass1 m_innerClass1;
        InnerClass2 m_innerClass2;
        int m_b;
};

int main(int argc, char** argv)
{
    cout << "main - start" << endl;

    MyClass obj;

    cout << "main - end" << endl;
    return 0;
}
于 2018-12-20T16:55:58.910 回答