2

我正在围绕一些自动生成的类编写一个包装器，以提供更好的接口。我写了一个简化的例子来演示这个问题。

我有一个 A 类，它有一个指向 X 类对象的指针，然后我有一个 B 类（继承 A），它有一个指向 Y 类对象（继承 X）的指针。

一切都很好，除了我不确定存储指向 X 和 Y 的指针的最佳方法是什么。我需要能够操作 A 类和 B 类对象的集合，就好像它们都是 A 一样（带有指向 X 的指针是我所需要的），这适用于我下面的示例。

我的实际问题是如何最好地处理需要操作 Y 类对象而不是 X 类的 B 类的情况。我确信有一些非常明显的东西我可以在这里使用。每次我使用这个变量并为每个继承我创建的 A 的类定义一个具有不同名称（例如 getY）的方法时，我不得不重复地转换这个变量，这感觉很笨拙。可能有许多像 doStuff 这样的方法，所有这些方法都必须调用 getY。

class X {
private:
    int i;
public:
    X(int i) : i(i) {}
    int getI() {
        return i;
    }
};

class Y : public X {
private:
    int j;
public:
    Y(int i, int j) : X(i), j(j) {}
    int getJ() {
        return j;
    }
};

class A {
protected:
    X* x;
public:
    A(X* a) : x(a) {}
    X* get() {
        return x;
    }
};

class B : public A {
public:
    B(Y* y) : A(y) {}
private:
    //I could create a new function for each class like class B
    Y* getY() {
        return (Y*)x;
    }
public:
    void doStuff() {
        Y* y = getY();
        y->getJ();
        std::cout << "J: " << y->getJ() << cout::endl;
    }
};

主要内容摘录：

X* x = new X(5);
Y* y = new Y(5,6);
B b(y);
b.doStuff();

我想到的另一种选择是，当我构造类 BI 时，可以初始化一个 Y 类型变量的指针，该指针指向与 X 中设置的位置相同的位置。只要我的指针是 const，我认为这应该是安全的两个引用指向不同的事物。

欢迎任何想法。

谢谢。

4

2 回答 2

1

好吧，我要做的第一件事就是打破A和B之间的继承关系。你说他们有一个共同的接口，所以从定义这个接口开始：

class ILibraryWrapper {
public:
    virtual X * get() = 0;
};

我假设 A 和 B 共享很多代码（因此是继承关系），所以接下来定义一个模板类来实现接口并定义公共位：

template <class T> class LibraryWrapper : public ILibraryWrapper {
protected:
    T * pointer;

public:
    LibraryWrapper( T * value ) : pointer( value ) {}

    virtual X * get() override { return static_cast<X *>( this->pointer ); }
};

最后，像这样定义 A 和 B：

class A : public LibraryWrapper<X> {
public:
    A( X * value ) : LibraryWrapper( value ) {}
};

class B : public LibraryWrapper<Y> {
public:
    B( Y * value ) : LibraryWrapper( value ) {}

    void doStuff() {
        std::cout << "J: " << this->pointer->getJ() << cout::endl;
    }
};

实际上，您的所有代码都应该处理 ILibraryWrapper 指针或引用。如果某些代码绝对必须知道被包装对象的具体类型，那么您可以进行动态转换：

auto wrapper = dynamic_cast<LibraryWrapper<Y> *>( object );
if( wrapper != nullptr ) {
    // ...
}

但一般来说，最好在 ILibraryWrapper 接口中提供所有需要的功能。

于 2013-01-25T14:54:13.423 回答
0

只要 Y 从 X 派生，B 从 A 派生，那么这很容易。

只要这些返回类型是多态的，虚函数就可以因返回类型而异。在 A 中实现以下内容：

virtual X* Get() const { return x; }

B中的以下内容：

virtual Y* Get() const { return static_cast< Y* >( A::Get() ); }
于 2013-01-25T15:05:50.400 回答