Ich habe im Schweiße meines Angesichts einen folgenden Iterator geschrieben:

struct default_tag {};

		template< typename ReferenceType, typename PointerType, typename Tag, typename SizeType = std::size_t >
		struct do_dereference {
			static ReferenceType dereference( PointerType obj_, SizeType index_ )
			{
				return obj_->dereference( index_, Tag() );
			}
		};

		template< typename ReferenceType, typename PointerType, typename SizeType >
		struct do_dereference< ReferenceType, PointerType, default_tag, SizeType > {
			static ReferenceType dereference( PointerType obj_, SizeType index_ )
			{
				return obj_->dereference( index_ );
			}
		};

		template< typename ValueType, typename FriendClass, bool IsConst, typename Tag = default_tag, typename SizeType = std::size_t >
		class index_iterator : 
public boost::iterator_facade< index_iterator< ValueType, FriendClass, IsConst, Tag, SizeType >,
typename std::conditional< IsConst, const ValueType, ValueType >::type, std::random_access_iterator_tag > {
		private:
			typedef Tag tag_type;
			typedef SizeType size_type;
			friend FriendClass;

		public:
			typedef typename std::conditional< IsConst, const FriendClass*, FriendClass* >::type pointer_type;
			typedef SizeType size_type;

			index_iterator( pointer_type object, size_type index )
				: object_( object ), index_( index )
			{
			}

			index_iterator( const index_iterator& other )
			{
				object_ = other.object_;
				index_ = other.index_;
			}

		public:
			reference dereference() {
				return do_dereference<reference,pointer_type, tag_type>::dereference( object_, index_ );
			}

			const reference dereference() const {
				return do_dereference<const reference,pointer_type, tag_type>::dereference( object_, index_ );
			}

			void increment() {
				++index_;
			}

			void decrement() {
				--index_;
			}

			void advance( size_type off ) {
				index += off;
			}

			bool equal( const index_iterator& other ) const {
				assert( object_ == other.object_ );
				return index_ == other.index_;
			}

			difference_type distance( index_iterator& other ) const {
				return index_ - other.index_;
			}

			operator index_iterator< ValueType, FriendClass, true, Tag, SizeType >() const
			{
				return index_iterator< ValueType, FriendClass, true, Tag, SizeType >( object_, index_ )
			}

		private:
			pointer_type object_;
			size_type get_index() const { return index_; }
			size_type index_;
		};

Sodass folgendes Minimalbeispiel funktioniert:

class my_vector {
public:
	typedef utility::index_iterator< double, my_vector, false > iterator;
	typedef utility::index_iterator< double, my_vector, true  > const_iterator;

	iterator begin() {
		return iterator( this, 0 );
	}

	iterator end() {
		return iterator( this, vec_.size() );
	}

	double& dereference( std::size_t index ) {
		return vec_[index];
	}

private:
	std::vector< double > vec_;
};

Jetzt meine Fragen:
- Gibts sowas schon? Sinnlos?
- Werden die nutzlosen Tag-Argumente vom Compiler wegoptimiert?

Viele Grüße,
Deci

Viele Grüße,
Deci