Question

这个线程有几个类似的线程Q1或Q2，但不完全相同。

问题只是以优雅的方式编写以下代码，没有代码重复：

template <typename T, class Container = std::vector<T> >
class container{
    iterator begin(){
        return iterator(data_.begin(), 1);
    }

    const_iterator begin() const{
        return const_iterator(data_.begin(), 1);
    }
    Container data_;
};

Q2有一种优雅的方法可以避免代码重复使用具有完全相同签名的const和非const函数。然而，这不是这种情况，因为没有强制转换将const_iterator转换为迭代器。

Q1提供了一种使用模板的好方法，但是，一旦容器是一个类，begin_impl函数就变为static，同时friend。

我提出的最优雅的代码是：

template <T>
class container{
        template< typename I, typename C >
        static I begin_impl( C & c ){
            return I(data_.begin(), 1);
        }

        template< typename I, typename C >
        friend I container<T>::begin_impl( C & c );

        iterator begin(){
            return container<T>::template begin_impl< iterator >( *this );
        }

        const_iterator begin() const{
            return container<T>::template begin_impl< const_iterator >( *this );
        }
}

我的问题是，这是否是您认为最优雅的方式。如果不是，请建议一些更好的代码。

编辑：我的迭代器实现：

class container{
        template <bool isConst>
        class iterator_ {

        public:
            typedef Container container_type;
            typedef typename Container::value_type value_type; 
            typedef typename Container::difference_type difference_type;
            typedef typename Container::size_type size_type;
            typedef typename Container::reference reference;
            typedef typename Container::const_reference const_reference;
            typedef typename Container::pointer pointer; 
            typedef typename Container::const_pointer const_pointer;
            typedef typename std::forward_iterator_tag iterator_category;

            template<bool isCond, typename cref, typename ref>
            struct IS_CONST_REF{
                typedef ref reference_type;
            };
            template<typename cref, typename ref>
            struct IS_CONST_REF<true, cref, ref>{
                typedef cref reference_type;
            };            
            typedef typename IS_CONST_REF<isConst, const_reference, reference>::reference_type ref;

            template<bool isCond, typename citr, typename itr>
            struct IS_CONST_ITR{
                typedef itr iterator_type;
            };
            template<typename citr, typename itr>
            struct IS_CONST_ITR<true, citr, itr>{
                typedef citr iterator_type;
            };            
            typedef typename IS_CONST_ITR<isConst, typename Container::const_iterator, typename Container::iterator>::iterator_type itr; 

            iterator_()
            :data_(), stepSize_(0){
            }

            iterator_(itr data, difference_type stepSize)
            :data_(data), stepSize_(stepSize){
            }

            iterator_(const iterator_<false>& src)
            :data_(src.getData()), stepSize_(src.getStepSize()){
            }

        [some more code ...] 

        protected:
            itr data_;
            difference_type stepSize_;
        };

        typedef iterator_<true> const_iterator;
        typedef iterator_<false> iterator;
};

Answer 1

怎么样：

class container{
    iterator begin(){
        return iterator(getStuff());
    }

    const_iterator begin() const{
        return const_iterator(getStuff());
    }

    private:
       Stuff getStuff() const  { [some code here] }
};

如果您有共同的代码将其移动到执行该工作的私有方法。

Answer 2

好吧，显然这仍然是最好的答案：

template <T>
class container{
        template< typename I, typename C >
        static I begin_impl( C & c ){
            return I(data_.begin(), 1);
        }

        template< typename I, typename C >
        friend I container<T>::begin_impl( C & c );

        iterator begin(){
            return container<T>::template begin_impl< iterator >( *this );
        }

        const_iterator begin() const{
            return container<T>::template begin_impl< const_iterator >( *this );
        }
}

避免在通用容器中使用begin（）和end（）函数的重复代码

2 个答案: