纯虚拟类的派生类的朋友状态

Question

我遇到了以下问题，我不知道最好的解决方法是什么。我想评估使用foo对象构建的对象expression。应允许expression类及其派生类访问foo的私有成员;但除了将所有派生类单独声明为朋友之外，我不知道如何才能完成这项工作 - 我可以声明一个虚拟函数foo的朋友吗？

class foo{ 
public: 
      foo(int a, int b, int c) : a(a), b(b), c(c) {} 
    void addExpression(expression *e){exp.push_back(e);} 
    bool evaluateAll(){ 
     for(expression* e : exp){ 
      if(!e->evaluate()) 
       return false; 
     } 
     return true; 
    } 
private: 
    int a,b,c; 
    std::list<expression*> exp; 
}; 

的expression类：

struct expression{ 
    expression(foo *f) : f(f) {} 
    virtual bool evaluate() = 0; 
private: 
    foo *f; 
}; 

struct anExpression : public expression{ 
    anExpression(foo *f) : expression(f) {} 
    bool evaluate(){ 
     return f->a < f->b; 
    } 
}; 

struct anotherExpression : public expression{ 
    anotherExpression(foo *f) : expression(f) {} 
    bool evaluate(){ 
     return f->a > f->b && f->a != f->c; 
    } 
}; 

的main功能：

int main(int argc, char *argv[]){ 
    foo f(3,2,1); 
    f.addExpression(new anExpression(&f)); 
    f.addExpression(new anotherExpression(&f)); 
    f.evaluateAll(); 

    return 0; 
} 

此代码不能当然的工作，但我真的不希望添加每一个派生类的作为朋友的expression或从foo继承expression。还有其他解决方案吗？

Answer 1

我会做expression朋友类foo，即，添加以下为foo：

friend struct expression; 

，然后实现获得-功能expression，像这样：

struct expression { 
// other stuff 

protected: 
    int get_a(foo const * f) { return f->a; } 
} 

的获取函数应该标记为protected以减少暴露。获得函数的参数是const，这是一个很好的衡量标准。

Answer 2

我可能是错的，但是这不是奇怪的循环模板模式的情况吗？ https://en.m.wikipedia.org/wiki/Curiously_recurring_template_pattern