2

有几个与此类似的线程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_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;
};
4

2 回答 2

2

关于什么：

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

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

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

如果你有通用代码。
将其移至执行该工作的私有方法。

于 2012-04-30T22:36:48.507 回答
1

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

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 );
        }
}
于 2012-05-01T19:53:41.807 回答