C++ 如果我在c++；

A有一个静态函数A:：create（），该函数创建A的实例，执行一些初始化，并返回指向它的指针。 我想创建a的子类，并具有类似的create（）funct：

在这个B:：create（）函数中，我必须执行以下操作：

B* B::create() {
    auto b = (B*)A::create();
    b -> val = 0;
    //...
    return b;
}

这样做对吗？演员阵容结束后会发生什么

---

跟进：A有一个受保护/私有构造函数，我应该如何编写B:：create（）或B的构造函数？我确实希望从A继承的变量具有与A:：create（）创建的变量相同的值，除非

A:：create（）

返回指向

B

对象的指针，否则cast将不会执行任何合理的操作。如果

A:：create（）

返回指向非

B

对象的指针，则表示行为未定义

在C++中，你使用构造函数处理对象的初始化：基类的初始化是继承的，每个派生的都可以做它需要做的任何初始化。您的

B:：create（）

只会返回一个适当构造的对象：

B::B()
    : A() // initialize base
    , val(0) {
        // other initialization
}
B* B::create() { return new B(); }

---

你可以让B班成为像这样的a班的朋友

class A {
public:
    static A* createA();
    int varA;

private:
    friend class B;    // Make B a friend so that B can use private constructor of A

    A()
    {
        cout << "In A constructor" << endl;

        varA = 5;  // Initialize members of A here
    }
};

A* A::createA()
{
    return new A;
}

class B : public A {
public:
    static B* createB();
    int varB;
private:
    B()
    {
        cout << "In B constructor" << endl;

        varB = -5;  // Initialize members of B here
    }
};

B* B::createB()
{
    return new B;
}

int main()
{
    cout << "Create A" << endl;
    A* x=A::createA();
    cout << "x->varA is " << x->varA << endl;
    cout << endl;

    cout << "Create B" << endl;
    B* y=B::createB();
    cout << "y->varA is " << y->varA << endl;
    cout << "y->varB is " << y->varB << endl;
    cout << endl;

    delete x;
    delete y;
}

---

另一种方法是将构造函数设置为受保护的，而不是私有的。

未定义的行为。这取决于很多事情是否可行；但不要依赖未定义的行为。避免C++中的C样式转换（使用<代码> DyrimeCase< < /Cord>）。此外，如果您的<代码> < <代码> >代码> b>代码>类共享类似的数据成员，那么考虑使用MIXIN、组合或继承来避免代码复制。如果需要帮助，提供更多代码，例如A类。实际上，您想完成什么？这看起来像是在不知道你在做什么的情况下重新发明工厂模式（没有冒犯——继承是复杂的，C++模型是非常奇怪的）！非常感谢！但是现在B:：create（）不会像A:：created（）那样为从A继承的变量赋值。我的后续工作是如何在B:：create（）或B:：B（）中使用A:：create（）来初始化继承的字段您应该修复

A

的构造函数，这样就不需要在

A:：create（）

中进行初始化。如果需要使用

A:：create（）

可以使用

A*aptr=A:：create（）*这=*aptr在
B
的构造函数中（当然适当地释放
aptr
）。我强烈建议不要这样做，而是建议修复
A
的构造函数。
class A {
public:
    static A* createA();
    int varA;

private:
    friend class B;    // Make B a friend so that B can use private constructor of A

    A()
    {
        cout << "In A constructor" << endl;

        varA = 5;  // Initialize members of A here
    }
};

A* A::createA()
{
    return new A;
}

class B : public A {
public:
    static B* createB();
    int varB;
private:
    B()
    {
        cout << "In B constructor" << endl;

        varB = -5;  // Initialize members of B here
    }
};

B* B::createB()
{
    return new B;
}

int main()
{
    cout << "Create A" << endl;
    A* x=A::createA();
    cout << "x->varA is " << x->varA << endl;
    cout << endl;

    cout << "Create B" << endl;
    B* y=B::createB();
    cout << "y->varA is " << y->varA << endl;
    cout << "y->varB is " << y->varB << endl;
    cout << endl;

    delete x;
    delete y;
}

Create A
In A constructor
x->varA is 5

Create B
In A constructor
In B constructor
y->varA is 5
y->varB is -5