Question

我有以下情况：

工厂类实现：

class FactoryClassA {
    public:
        FactoryClassA(){};
        ~FactoryClassA(){};

        ClassA create(double a, double b) {
            return ClassA;
        };
};

ClassA实施：

class ClassA {
    friend class FactoryClassA
    ~FactoryClassA() {}
    private:
        ClassA(double a = 0, double b = 0)
        {
            a(a),
            b(b)
        };
        double a;
        double b;
};

OtherClass实施：

class OtherClass {
    public:
        OtherClass() {
            ClassFactory myClassAFactory;
            aClassA = myClassAFactory.create();
        }
        ~OtherClass() {};

    private:
        aClassA;
};

不幸的是，这不起作用。因为在OtherClass的（空）成员初始值设定项列表中，调用了ClassA的空构造函数，该构造函数不存在。

我之所以制作ClassA private的构造函数，是因为我希望用户只能通过ClassA创建FactoryClassA的对象。

Answer 1

首先，create()应该有一个返回类型：

ClassA create(double a, double b) {
   return {a, b};
}

我没有经历所有其他语法错误。请修复它们，因为其他人在搜索答案时可能会发现您的问题。请让他们轻松理解您的问题。

在ClassA定义之后，这必须在你的代码中，因为编译器必须知道ClassA对象的大小以及要使用的构造函数。

其次，只需在构造函数体之前初始化您的成员：

OtherClass() :
   aClassA{ClassFactory{}.create(0.0, 0.0)}
{}

您可能希望将create()作为ClassFactory的静态成员函数。然后OtherClass构造函数如下所示：

OtherClass() :
   aClassA{ClassFactory::create(0.0, 0.0)}
{}

这更直观。

Answer 2

此代码充满了小错误，使其无法使用。成员初始化的第一个语法是：

class A {
    A(x, y): m_a(x) { ... }
    ...
}

和类声明是语句，因此需要最终的;

接下来，如果您希望能够使用临时对象，则类的dtor必须是公共的。

默认值不应位于ClassA ctor，而应位于create工厂方法。

最后，你应该在OtherClass中使用静态工厂，不需要为每个对象创建一个新工厂。

代码变为：

class FactoryClassA;

class ClassA {
public:
    friend class FactoryClassA;
    ~ClassA(){}
private:
    ClassA(double a, double b):a(a),b(b){}
    double a;
    double b;
};

class FactoryClassA {
public:
    FactoryClassA(){}
    ~FactoryClassA(){}

    ClassA create(double a = 0, double b = 0) {
        return ClassA(a, b);
    }
};

class OtherClass {
public:
    OtherClass(): aClassA(myClassAFactory.create()){}
    ~OtherClass(){}

private:
    static FactoryClassA myClassAFactory;
    ClassA aClassA;

};

FactoryClassA OtherClass::myClassAFactory;

离原始版本不远，但这些编译......

使用Factory创建一个类，该类在另一个类中使用

2 个答案: