我可以避免 Matrix 类迭代器中的循环依赖吗？

Question

我们有两个类：

template<typename T, typename Size, typename Stack, typename Sparse>
class Matrix

Matrix

template<typename T, typename Size>
class Iterator

---

应该能够返回开始和结束迭代器，并且 Iterator 将保留对 Matrix 的引用以通过其接口访问元素。我们不希望Iterator依赖于Matrix的内部存储来防止耦合。我们如何解决这个循环依赖问题呢？

（内部Storage类具有与Matrix类相同的模板参数以及与Matrix本身相同的访问过程）

Answer 1

首先，向前声明 Matrix 类。这允许 Iterator 类查看 Matrix 类的名称，并对其进行指针和引用。 （它还不允许 Iterator 类访问成员数据或调用成员函数。）

template<typename T, typename Size, typename Stack, typename Sparse>
class Matrix;

然后，定义 Iterator 类。此时它所能做的就是保存指向 Matrix 的引用和指针。 （还不能访问 Matrix 的成员。）

template<typename T, typename Size>
class Iterator{
   // don't define any function bodies in here
   //but do put all data members and prototypes in here
};

然后定义 Matrix 类（可以访问 Iterator 成员），

template<typename T, typename Size, typename Stack, typename Sparse>
class Matrix{
   // don't define any function bodies in here
   //but do put all data members and prototypes in here
};

然后定义每个类的方法体。此时，两个类的方法就可以访问彼此的成员了。通常，这部分位于 .cpp 文件中，但对于模板，它属于 .h 文件中。

template<typename T, typename Size, typename Stack, typename Sparse>
Matrix<T,Size,Stack,Sparse>::Matrix(){ /*...*/}

template<typename T, typename Size>
Iterator<T,Size>::Iterator(){ /*...*/ }

Answer 2

在这里使用嵌套类也可能是合适的，并且它可能会减少您需要的模板参数的数量。

template<typename T, typename Size, typename Stack, typename Sparse>
class Matrix{
public:
   class Iterator{
       // define Iterator members here
   };
   // declare Matrix members here
}

Answer 3

为了进行迭代，迭代器通常需要了解它们迭代的内部存储——这种耦合通常是无法避免的。以地图迭代器为例 - 它必须了解地图的内部树结构才能完成其工作。

Answer 4

您可以前向声明模板。它看起来像这样：

template<typename T> struct Foo;

template <typename T> struct Bar
{
    Foo<T>* foo;
};

template<typename T> struct Foo
{
        T value;
        Bar<T*> foobar;
};

void bla()
{
        Foo<int> grml;
}

Answer 5

在定义 Iterator 模板之前前向声明 Matrix 模板。

请注意，当您意识到 Iterator 无法引用 Matrix 时，您就会碰壁。 >。