迭代器C++模板继承

template inheritance C++ iterator

本文关键字：继承 C++ 迭代器      更新时间：2023-10-16
    template<class T, template<typename> class Seq>
    class SequenceWithApply : public Seq<T*>
    {
    public:
      // 0 arguments, any type of return value:
      template<class R>
      void apply(R (T::*f)()) {
        iterator it = begin();
        while(it != end()) {
          ((*it)->*f)();
          it++; }
      }
      // 1 argument, any type of return value:
      template<class R, class A>
      void apply(R(T::*f)(A), A a) {
        iterator it = begin();
        while(it != end()) {
          ((*it)->*f)(a);
          it++; }
      }
      // 2 arguments, any type of return value:
      template<class R, class A1, class A2>
      void apply(R(T::*f)(A1, A2),
                 A1 a1, A2 a2) {
        iterator it = begin();
        while(it != end()) {
          ((*it)->*f)(a1, a2);
          it++;
        }
      }
    }; ///:~
//: C03:applyGromit2.cpp
// Test applyMember.h
#include "Gromit.h"
#include "applyMember.h"
#include <vector>
#include <iostream>
using namespace std;
int main() {
  SequenceWithApply<Gromit, vector> dogs;
  for(int i = 0; i < 5; i++)
    dogs.push_back(new Gromit(i));
  dogs.apply(&Gromit::speak, 1);
  dogs.apply(&Gromit::eat, 2.0f);
  dogs.apply(&Gromit::sleep, 'z', 3.0);
  dogs.apply(&Gromit::sit);
} ///:~

我不太明白为什么编译器在这里抱怨iterator。由于此代码段代码实现了基于模板的类SequenceWithApply。在这种情况下， SequenceWithApply实际上是一个基于vector类。迭代器在此基类中应该是可见的。我真的很感激有人可以帮助我解决这个问题。

编译器

在第一阶段查找中查找iterator，即在模板实例化之前。为了知道类从哪个类型派生，必须实例化模板(以便Seq<T*>是实际类型(。因此，编译器永远不会在基类中找到iterator。

您可以通过两种简单的方法解决此问题：

一次性：

typename Seq<T*>::iterator

派生类中的类型别名：

using iterator = typename Seq<T*>::iterator;

所有这些都明确指定iterator属于哪种类型，当Seq和T已知时，在查找的第二阶段查找。更多关于typename的信息。

您可以对函数执行相同的操作：

一次性：

Seq<T*>::begin()
this->begin() // if inside a member function

使用 声明：

using Seq<T*>::begin;

您正在使用的图书可能已过期。如今，c++已经朝着使用自由函数来更好地解耦的方向发展。

例：

#include <vector>
#include <iostream>
// an example Gromit
struct Gromit
{
    Gromit(int index) : index(index) {};
    void speak(int i) { std::cout << name() << " speaking " << i << std::endl; }
    void eat(float f) { std::cout << name() << " eating " << f << std::endl; }
    void sleep(char c, double f) { std::cout << name() << " sleeping " << c << " " << f << std::endl; }
    void sit() { std::cout << name() << " sitting" << std::endl; }
private:
    std::string name() const {
        return "Gromit " + std::to_string(index);
    }
    int index;
};
// apply some function object to each item in a container    
template<class Container, class F>
void apply(Container& container, F f)
{
    for (const auto& p : container)
    {
        f(p);
    }
}
int main() {
    std::vector<std::unique_ptr<Gromit>> dogs;
    for(int i = 0; i < 5; i++)
        dogs.emplace_back(new Gromit(i));
    using namespace std::placeholders;
    // apply dog.speak(1) to each dog in dogs...        
    apply(dogs, std::bind(&Gromit::speak, _1, 1));
    // dog.eat(2.0f) for each dog in dogs...
    apply(dogs, std::bind(&Gromit::eat, _1, 2.0f));
    // ...etc
    apply(dogs, std::bind(&Gromit::sleep, _1, 'z', 3.0));
    apply(dogs, std::bind(&Gromit::sit, _1));
}

预期输出：

Gromit 0 speaking 1
Gromit 1 speaking 1
Gromit 2 speaking 1
Gromit 3 speaking 1
Gromit 4 speaking 1
Gromit 0 eating 2
Gromit 1 eating 2
Gromit 2 eating 2
Gromit 3 eating 2
Gromit 4 eating 2
Gromit 0 sleeping z 3
Gromit 1 sleeping z 3
Gromit 2 sleeping z 3
Gromit 3 sleeping z 3
Gromit 4 sleeping z 3
Gromit 0 sitting
Gromit 1 sitting
Gromit 2 sitting
Gromit 3 sitting
Gromit 4 sitting
相关文章：