Question

我遇到了以下问题，我真的不知道最好的办法是什么。我想评估使用expression对象构造的foo个对象。应允许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的每个派生类添加为朋友，或者expression继承自foo。还有其他解决方案吗？

Answer 1

我会让expression成为foo的朋友类，也就是说，将以下内容添加到foo：

friend struct expression;

然后在expression中实现get-functions，如下所示：

struct expression {
// other stuff

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

get-functions应标记为protected以减少曝光。 get-function的参数是const，这是一个很好的衡量标准。

Answer 2

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

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

2 个答案: