Question

我有以下类，我试图从内部类迭代器

重载operator *

#ifndef __LISTMAP_H__
#define __LISTMAP_H__

#include "xless.h"
#include "xpair.h"

template <typename Key, typename Value, class Less=xless<Key>>
class listmap {
   public:
      using key_type = Key;
      using mapped_type = Value;
      using value_type = xpair<const key_type, mapped_type>;
   private:
      Less less;
      struct node;
      struct link {
         node* next{};
         node* prev{};
         link (node* next, node* prev): next(next), prev(prev){}
      };
      struct node: link {
         value_type value{};
         node (node* next, node* prev, const value_type&);
      };
      node* anchor() { return static_cast<node*> (&anchor_); }
      link anchor_ {anchor(), anchor()};
   public:
      class iterator;
      listmap(){};
      listmap (const listmap&) = default;
      listmap& operator= (const listmap&) = default;
      ~listmap();
      iterator insert (const value_type&);
      iterator find (const key_type&);
      iterator erase (iterator position);
      iterator begin() { return anchor()->next; }
      iterator end() { return anchor(); }
      bool empty() const { return begin() == end(); }
};


template <typename Key, typename Value, class Less>
class listmap<Key,Value,Less>::iterator {
   private:
      friend class listmap<Key,Value>;
      listmap<Key,Value,Less>::node* where {nullptr};
      iterator (node* where): where(where){};
   public:
      iterator(){}
      value_type& operator*();
      value_type* operator->();
      iterator& operator++(); //++itor
      iterator& operator--(); //--itor
      void erase();
      bool operator== (const iterator&) const;
      bool operator!= (const iterator&) const;
};

template <typename Key, typename Value, class Less>
value_type& listmap<Key,Value,Less>::iterator<Key,Value,Less>::operator*()
{
      return where->value;
}

#include "listmap.tcc"
#endif

问题是value_type是类listmap中的公共成员，并且它不是静态的，所以我不知道如何完成operator *（）的声明。我不想通过改变代码的结构来修复bug。例如：制作

using value_type = xpair<const key_type, mapped_type>;

全局。我只是想知道是否还有其他技巧可以用来访问value_type。

....编辑：我不知道内部类如何识别value_type

Answer 1

它几乎与迭代器相同，您只需添加typename关键字

typename listmap<Key,Value,Less>::value_type

static对于某种类型而言无关紧要。

迭代器中的别名¹

template <typename Key, typename Value, class Less>
class listmap<Key,Value,Less>::iterator {
    ...
    using value_type = typename listmap<Key,Value,Less>::value_type;

};

允许您使用自动后缀类型更简洁地编写定义：

template <typename Key, typename Value, class Less>
auto listmap<Key,Value,Less>::iterator::operator*() -> value_type&
{
      return where->value;
}

小心：内部iterator类不是模板，只有listmap是：

listmap<Key,Value,Less>::iterator<Key,Value,Less>::operator
//                               ~~~~~~~~~~~~~~~~ remove this

¹顺便说一句，不要忘记others。

从内部类访问外部公共成员

1 个答案: