std ::轉換爲任意容器

Question

我想寫的通用函數接收container1值[a1, .. , an]並返回container2值[convert(a1), .. , convert(an)]。 如果container2是std::vector，問題是微不足道的，std::transform正是我想要的。下面的函數可以處理任意container2和container1

template<class ToType, class FromType> 
ToType convert(const FromType& from) 
{ 
    std::vector<typename ToType::value_type> tmp; 
    std::transform(from.begin(), from.end(), 
        std::back_inserter(tmp), 
        [](const typename FromType::value_type& f) { 
     return convert<typename ToType::value_type>(f); 
    }); 
    return ToType(tmp.begin(), tmp.end()); 
} 

但它確實增加複製。有誰知道如何做得更好？

Answer 1

結賬this answer至Is it possible to write a C++ template to check for a function's existence?。您可以使用SFINAE檢測目標容器的功能是否存在（如push_back或insert），或者存在容器的插入器（例如inserter或back_inserter），並相應地執行此操作。

另一種方法是創建一個假的迭代器：

template <class T, class U> 
struct ConvertIterator { 
    typedef T dest_type; 
    typedef U it_type; 

    ConvertIterator(U&& val) : iterator(std::forward<U>(val)) { 

    } 

    bool operator == (const ConvertIterator &other) const { 
     return iterator == other.iterator; 
    } 

    bool operator != (const ConvertIterator &other) const { 
     return iterator != other.iterator; 
    } 

    dest_type operator *() const { 
     return convert<dest_type>(*iterator); 
    } 

    ConvertIterator<T, U> & operator ++() { 
     ++iterator; 
     return *this; 
    } 

    it_type iterator; 
}; 

然後：

template<class ToType, class FromType> 
ToType convert(const FromType& from) 
{ 
    typedef ConvertIterator<typename ToType::value_type, decltype(from.begin()) > convert_it; 

    return ToType(convert_it(from.begin()), convert_it(from.end())); 
} 

Answer 2

這裏是一個基於函數的轉換迭代器。它具有正向迭代器的所有正確類型定義。我們可以將其升級到支持所有傳入Base迭代器類型的標記屬性的，如果我們選擇：

template< 
    class Base, 
    class F, 
    class R=typename std::result_of<F(decltype(*std::declval<Base const&>()))>::type 
> 
struct convert_iterator: 
    std::iterator<std::forward_iterator_tag,typename std::decay<R>::type> 
{ 
    Base it; 
    F f; 

    template<class It, class Func> 
    convert_iterator(It&&base, Func&&func):it(std::forward<It>(base)), 
    // defaulted stuff: 
    convert_iterator()=default; 
    convert_iterator(convert_iterator const&)=default; 
    convert_iterator(convert_iterator &&)=default; 
    convert_iterator& operator=(convert_iterator const&)=default; 
    convert_iterator& operator=(convert_iterator &&)=default; 

    bool operator==(convert_iterator const&other) const { 
    return it == other.it; 
    } 
    bool operator!=(convert_iterator const&other) const { return !(*this==other); } 

    // a bit overkill, but rvalue and lvalue overrides for these: 
    R operator*() const& { 
    return f(*it); 
    } 
    R operator*() & { 
    return f(*it); 
    } 
    R operator*() const&& { 
    return std::move(f)(*std::move(it)); 
    } 
    R operator*() && { 
    return std::move(f)(*std::move(it)); 
    } 
    // normal pre-increment: 
    convert_iterator& operator++()& { 
    ++it; 
    return *this; 
    } 
    // pre-increment when we are guaranteed not to be used again can be done differently: 
    convert_iterator operator++()&& { 
    return {std::next(std::move(it)), std::forward<F>(f)}; 
    } 
    // block rvalue post-increment like a boss: 
    convert_iterator operator++(int)& { 
    return {it++, f}; 
    } 
}; 

一個輔助函數來創建它們：

template< class Base, class F > 
convert_iterator<typename std::decay<Base>::type,typename std::decay<F>::type> 
make_convert_iterator(Base&& b, F&& f) { return {std::forward<Base>(b), std::forward<F>(f)}; } 

接下來，我創建處理轉換類。專業化讓我們派遣不同的容器和標量：

// for scalars: 
template<class ToType,class=void> 
struct converter { 
    template<class FromType> 
    ToType operator()(FromType&& from)const{ return std::forward<FromType>(from); } 
}; 

// attempt at SFINAE test for container: 
template<class ToContainer> 
struct converter<ToContainer, (void)(
    typename std::iterator_traits< 
    typename std::decay<decltype(std::begin(std::declval<ToContainer&>())>::type 
    >::value_type 
)> 
{ 
    using std::begin; using std::end; 

    using R=std::iterator_traits<typename std::decay<decltype(begin(std::declval<ToContainer&>()))>::type>::value_type; 

    template<class FromType, class T=decltype(*begin(std::declval<FromType>())> 
    ToContainer operator()(FromType&& from) const { 
    auto sub_convert = [](T&& t)->R{ 
     return converter<R>{}(std::forward<T>(t)); 
    }; 
    return { 
     make_convert_iterator(begin(std::forward<From>(from)), sub_convert), 
     make_convert_iterator(end(std::forward<From>(from)), sub_convert) 
    }; 
    }; 
}; 

現在的動作轉換功能是一個班輪：

template<class ToType> 
ToType convert(FromType&& from) 
{ 
    return converter<ToType>{}(std::forward<FromType>(from)); 
}