Question

我们说我有两个班，A和B：

class B;

class A
{
private:
    int an_int;
    B *something_else;
public:
    A(int n) : an_int(n), something_else(nullptr) {}
};

class B
{
private:
    int an_int;
    A *something_else;
public:
    B(int n) : an_int(n), something_else(nullptr) {}
};

我怎样才能做到这一点，以便我不必使用原型B来获得指向A类B对象的指针？

Answer 1

这个解决方案很可能是关于继承的练习中你不能使用前向声明的。

而不是前瞻声明

class B;

您可以定义类似

的界面

struct I_whoop
{
    virtual void whoop_whoop() = 0;
};

然后让B类实现该接口，并使用指向接口的指针。

Answer 2

实际上如果使用具体的课程你就不能。但您可以使用模板参数来实现目标。使B类成为模板类A的模板参数。

Answer 3

我怎样才能做到这一点，以便我不必使用原型B来获得指向A类B对象的指针？

像这样：

class A
{
private:
    int an_int;
    class B *something_else;
public:
    A(int n) : an_int(n), something_else(nullptr) {}
};

class B
{
private:
    int an_int;
    class A *something_else;
public:
    B(int n) : an_int(n), something_else(nullptr) {}
};

在C和C ++中，T类型从未需要在声明T *类型的对象之前声明的forward （或const个变体），因为声明T * 本身需要编译器只知道T *的大小，而不是大小或定义 T的{{1}}，T *的大小相同，无论T如何。

这是一个更加充实的插图：

class A
{
private:
    int an_int;
    class B *something_else;
public:
    A(int n, class B * pb = nullptr) : an_int(n), something_else(pb) {}
    int get_int() const {
        return an_int;
    }
    void set_B(class B * pb) {
        something_else = pb;
    }   
    class B * get_B() const {
        return something_else;
    }
};

class B
{
private:
    int an_int;
    class A *something_else;
public:
    B(int n, class A * pa = nullptr) : an_int(n), something_else(pa) {}
    int get_int() const {
        return an_int;
    }
    void set_A(class A * pa) {
        something_else = pa;
    }   
    class A * get_A() const {
        return something_else;
    }
};

#include <iostream>

int main()
{
    A a(1);
    B b(2);
    a.set_B(&b);
    b.set_A(&a);

    std::cout << a.get_B()->get_int() << std::endl; 
    std::cout << b.get_A()->get_int() << std::endl;

    return 0;
}

输出：

2
1

（gcc 4.9.2 / clang 3.5.2 -std = c ++ 11 -Wall -pedantic）

我如何避免前瞻性声明？

3 个答案: