標準ライブラリコンテナの一般化された関数テンプレート

Question

私は、コンテナ要素の反復のための簡単な一般化関数を書こうとしています。すべての要素はstd::stringに（どのように）変換され、別の場所に格納されます。基本的なバージョンは些細だった：

template<class Container> 
void ContainerWork(const Container& c) 
{ 
    for(const auto& elem : c) { 
     /* convert to string and store*/ 
    } 
} 

はそれからに変換値型std::stringとコードとのコンテナの特殊化を追加する必要になった：

template<typename T, template<typename, typename> class Container, class Allocator> 
void ContainerWork(Container<T, Allocator> c) 
{ 
    for(const T& elem : c) { 
     /* convert to string and store*/ 
    } 
} 

template<template<typename, typename> class Container, class Allocator> 
void ContainerWork(Container<std::string, Allocator> c) 
{ 
    for(const std::string& elem : c) { 
     /* frame elem in quotes*/ 
    } 
} 

それは素晴らしい作品が、今私は、シーケンスコンテナを使用することができます（vector,listなど）ですが、setとunordered_setも使用します。任意のアイデアはどのように4つのパラメータを持つコンテナの "コピー貼り"の実現なしでこれを行うのですか？私はdecltype(Container)::value_typeと遊ぶことを試みているが運がない。

私は（コンパイラ - VS2012またはGCC 4.8.x）++ 11個の機能Cのほとんどを使用することができ、

Answer 1

あなたはvariadic-templatesを使用することができます

template<typename T, template<typename...> class Container, typename... Args> 
void ContainerWork(Container<T, Args...> c) 
{ 
} 

template<template<typename...> class Container, typename... Args> 
void ContainerWork(Container<std::string, Args...> c) 
{ 
} 

そしておそらくあなたはもちろん、簡単な使用することができるようなものを派遣

template<typename Container> 
void ContainerWork(Container c, 
typename std::enable_if<!std::is_same<typename Container::value_type, 
std::string>::value>::type* = 0) 
{ 
} 

template<typename Container> 
void ContainerWork(Container c, 
typename std::enable_if<std::is_same<typename Container::value_type, 
std::string>::value>::type* = 0) 
{ 
} 

しかし、差は機能のみを変換するための呼び出しであれば、とにかく、 - あなたは単にTためとのためにそれをオーバーロードすることができます、stringのバージョンではこの文字列を単純に返します。

また、あなたは、標準ライブラリのアルゴリズムの全てがイテレータではなく、コンテナ上で動作する理由ですC++ 11 decltype機能

template<typename Container> 
auto ContainerWork(Container c) -> 
decltype(c.begin(), 
typename std::enable_if<!std::is_same<typename Container::value_type, 
std::string>::value, void>::type()) 
{ 
} 

template<typename Container> 
auto ContainerWork(Container c) -> 
decltype(c.begin(), 
typename std::enable_if<std::is_same<typename Container::value_type, 
std::string>::value, void>::type()) 
{ 
} 

Answer 2

でSFINAEを使用することができます。

コンテナではなくイテレータで機能するようにコア関数を変更できます。これは、関数テンプレートのために存在していない部分特殊化を、必要になりますので、我々は、デリゲートとクラスのトリック使用します：あなたは本当に、あなたは、このラッパーを作成することができますしたい場合は

template <typename It> 
void DoIteratorWork(It start, It end) 
{ 
    DoIteratorWork_Impl<It, typename std::iterator_traits<It>::value_type>::call(start, end); 
} 

template <typename It, typename ValueType> 
struct DoIteratorWork_Impl 
{ 
    static void call(It start, It end) 
    { 
    for (; start != end; ++start) { 
     // operate on *it 
    } 
    } 
}; 

template <typename It> 
struct DoIteratorWork_Impl<It, std::string> 
{ 
    static void call(It start, It end) 
    { 
    for (; start != end; ++start) { 
     // operate on *it 
    } 
    } 
}; 

を：我々は特性クラスまたは他の技術を利用したアルゴリズムの本体内変換を呼び出したい場合は

template <class Container> 
void DoContainerWork(const Container& c) 
{ 
    using std::begin; using std::end; // enable ADL of begin and end 
    return DoIteratorWork(begin(c), end(c)); 
} 

Answer 3

// implement the bodies as functors to allow for partial 
// specialization for value_type: 
template <class value_type> 
struct DoContainerWorkImpl { 
    template<typename Container> 
    void operator()(const Container& c) const 
    { 
    for (auto&& x : c) { 
     // code 
    } 
    } 
}; 
template <> 
struct DoContainerWorkImpl<std::string> { 
    template<typename Container> 
    void operator()(const Container& c) const 
    { 
    for (std::string const& x : c) { 
     // code 
    } 
    } 
}; 

template <class Container> 
void DoContainerWork(const Container& c) 
{ 
    using std::begin; // enable ADL of begin 
    // extract the iterator for the container c: 
    typedef typename std::decay<decltype(std::begin(c))>::type iterator; 
    // extract the value type of the container: 
    typedef typename std::iterator_traits<iterator>::value_type value_type; 
    DoContainerWorkImpl<value_type>()(c); 
} 

別のアプローチは、「ローカル」アルゴリズム一つのことをする、と決定伴うだろう。ここで

は、そのアプローチで刺しです：今

// convert non-strings: 
template<typename T> 
std::string as_string(T&& t) 
{ 
    // converting code goes here 
} 
// block dangling rvalues: 
std::string as_string(std::string&& s) { return std::move(s); } 
// pass lvalues through: 
std::string const& as_string(std::string const& s) { return s; } 
std::string const& as_string(std::string& s) { return s; } 

、我々はあなたのループ本体に次の操作を行います。

NOOPにコンパイル

for(auto&& elem : c) { 
    std::string const& s = as_string(std::forward<decltype(elem)>(elem)); 
    // code using s as a string 
} 

（または、最悪でもいくつかの動き）コンテナがstd::stringのコンテナの場合はコンバージョンコード、そうでない場合はコンバージョンコードです。

参照に割り当てられた一時的な一時的な拡張は、一時的にstd::stringに生成され、イテレータのlvalueの有効期間は、「イテレータが参照を返す文字列コンテナ」のライフタイムを十分長く保持します。

Answer 4

限り、私はこのことを理解して、あなただけの多型ファンクタでstd::for_eachを使用することができます。

namespace detail { 

    template<typename T> 
    std::string do_conversion(const T& item) { 
     // convert to string 
    } 

    template<> 
    std::string do_conversion<std::string>(const std::string& item) { 
     // frame in quotes 
    } 
} 

struct convert_to_string { 
    template<typename T> 
    void operator()(const T& item) { 
     // delegate to free function in namespace scope, because otherwise we 
     // cannot specialize 
     std::string result = detail::do_conversion(item); 
    } 
}; 

// in calling code 

std::for_each(std::begin(container), std::end(container), convert_to_string{}); 

はあなたのためにこの仕事をしていますか？