访问超类类型成员对象的受保护成员 - 一个优雅的解决方案

首先，我知道我做不到，我认为这不是一个重复的问题(这个问题和这个问题处理同一个问题，但他们只想解释为什么它不起作用(。

所以，我对类和继承有一个类似的概念，我会以某种方式优雅地想要做一些被禁止的事情。这是一个非常简单的代码片段，反映了我想做的事情：

#include <iostream>
class A{
protected:
    int var;
    std::vector <double> heavyVar;
public:
    A() {var=1;}
    virtual ~A() {}
    virtual void func() {
        std::cout << "Default behavior" << this->var << std::endl;
    }
    // somewhere along the way, heavyVar is filled with a lot of stuff
};
class B: public A{
protected:
    A* myA;
public:
    B(A &a) : A() {
        this->myA = &a;
        this->var = this->myA->var;
             // copy some simple data, e.g. flags
             // but don't copy a heavy vector variable
    }
    virtual ~B() {}
    virtual void func() {
        this->myA->func();
        std::cout << "This class is a decorator interface only" << std::endl;
    }
};
class C: public B{
private:
    int lotsOfCalc(const std::vector <double> &hv){
        // do some calculations with the vector contents
    }
public:
    C(A &a) : B(a) {
        // the actual decorator
    }
    virtual ~C() {}
    virtual void func() {
        B::func(); // base functionality
        int heavyCalc = lotsOfCalc(this->myA->heavyVar); // illegal
            // here, I actually access a heavy object (not int), and thus
            // would not like to copy it
        std::cout << "Expanded functionality " << heavyCalc << std::endl;
    }
};
int main(void){
    A a;
    B b(a);
    C c(a);
    a.func();
    b.func();
    c.func();
    return 0;
}

这样做的原因是我实际上是在尝试实现一个装饰器模式(class B具有我想要装饰的myA内部变量(，但我也想在进行"装饰"计算时使用一些受保护的class A成员(在class B及其所有子类中(。因此，这个例子不是装饰器的正确例子(甚至不是一个简单的例子(。在示例中，我只专注于演示有问题的功能(我想使用但不能使用的功能(。在这个例子中，甚至没有使用实现装饰器模式所需的所有类/接口(我没有一个抽象的基类接口，由具体的基类实例继承，以及一个抽象的装饰器集成，用作具体装饰器的超类(。我只提到上下文的装饰器(我想要一个A*指针的原因(。

在这种特殊情况下，我认为将(我的等价物(int var公开(甚至编写一个可公开访问的getter(没有多大意义，原因有两个：

• 更明显的一个，我不希望用户实际直接使用信息(我有一些函数返回与我的protected变量相关和/或写入的信息，但不是变量值本身(
• 在我的例子中，protected变量比复制int要重得多(它是 double 的 2D std::vector(，并且将其复制到派生类的实例中将不必要地消耗时间和内存

有两种不同的方法让我的代码做我想让它做的事情，但我不喜欢这两种方法，我正在寻找一个C++概念，它实际上是为了做这种事情(我不能成为第一个想要这种行为的人(。

到目前为止我有什么以及为什么我不喜欢它：

1. 向基类声明所有(相关的(继承类friend S：

class A{
    ....
    friend class B;
    friend class C;
};

不喜欢这个解决方案，因为它会迫使我每次编写新的子类时修改我的基类，而这正是我试图避免的。(我只想在系统的主要模块中使用"A"接口。

2. 将 A* 指针转换为继承类的指针并使用它

void B::func(){
    B *uglyHack = static_cast<B*>(myA);
    std::cout << uglyHack->var + 1 << std::endl;
}

变量名称非常暗示我使用这种方法的感觉，但这是我现在正在使用的方法。由于我设计了这个类，我知道如何小心并只使用class A中实际实现的东西，同时将其视为class B。但是，如果其他人继续我的项目工作，他可能不太熟悉代码。此外，将变量指针投向我非常清楚的东西，它对我来说不仅仅是纯粹的邪恶。

我试图使这个项目的代码尽可能漂亮和干净，所以如果有人对不需要时不时修改基类或使用邪恶概念的解决方案有任何建议，我将不胜感激。