C++ 模板组合与友谊传递

我有包含私有数据的容器和访问私有数据的friend类：

template<class T>
class Container
{
    friend typename T::MyAccessor;
    vector<T> _data;
};

template<class T>
class Accessor
{
public:
    void doSomething(Container<T> *c)
    {
        cout << c->_data.size() << endl;
    }
};

template<class T, template<typename> class CustomAccessor>
struct MyBase
{
    typedef Container<T> MyContainer;
    typedef CustomAccessor<T> MyAccessor;
};

模板
类容器
{
朋友类型名T:：MyAccessor；
矢量数据；
};
模板
类访问器
{
公众：
无效剂量测定（容器*c）
{
cout_data.size（）
类组合
{
公众：
typedef-First-MyFirst；
typedef第二个MySecond；
无效剂量测定（容器*c）
{
我的第一个a；
a、 剂量测定法（c）；
第二，b；
b、 剂量测定法（c）；
}
};
模板
类DoubleAccessor:公共复合{}；

但友谊是不可传递的，组合访问器不能访问容器私有数据。

---

有没有一种方法可以避免向所有人公开容器私有数据？

如果您只是将

类访问器

声明为

类容器的
朋友
，会怎么样

template<class T>
class Container {
    template<class T1> friend class Accessor;
    std::vector<T> _data;
};

template<class T>
class Accessor {
public:
    void doSomething(Container<T> *c) {
        std::cout << c->_data.size() << std::endl;
    }
};

template<class T, template<typename> class CustomAccessor = Accessor>
struct MyBase {
    typedef Container<T> MyContainer;
    typedef CustomAccessor<T> MyAccessor;
};

template<class T, template<typename> class First = Accessor, template<typename> class Second = Accessor>
class Composite {
public:
    typedef First<T> MyFirst;
    typedef Second<T> MySecond;

    void doSomething(Container<T> *c) {
        MyFirst a;
        a.doSomething(c);

        MySecond b;
        b.doSomething(c);
    }
};

模板
类容器{
模板好友类访问器；
std:：vector_数据；
};
模板
类访问器{
公众：
无效剂量测定（容器*c）{
std:：cout _data.size（）难道你不能让class Composite成为类访问器的朋友吗？出于什么目的？Composite不访问访问器私有数据。随着时间的推移，会有访问器2等等。似乎我必须将所有可用的访问器作为容器定义的朋友。
template<class T>
class Container {
    template<class T1> friend class Accessor;
    std::vector<T> _data;
};

template<class T>
class Accessor {
public:
    void doSomething(Container<T> *c) {
        std::cout << c->_data.size() << std::endl;
    }
};

template<class T, template<typename> class CustomAccessor = Accessor>
struct MyBase {
    typedef Container<T> MyContainer;
    typedef CustomAccessor<T> MyAccessor;
};

template<class T, template<typename> class First = Accessor, template<typename> class Second = Accessor>
class Composite {
public:
    typedef First<T> MyFirst;
    typedef Second<T> MySecond;

    void doSomething(Container<T> *c) {
        MyFirst a;
        a.doSomething(c);

        MySecond b;
        b.doSomething(c);
    }
};