非constテンプレートの引数型をconstに暗黙的に変換するための標準的な方法はありますか？

Question

私は、特定のテンプレートタイプの引数を取る関数を持っています。簡易版は、次のようになります。

機能的

#include <type_traits> 

template <typename T> 
struct foo 
{ 
    // default constructor 
    foo() { } 

    // simple copy constructor that can construct a foo<T> from a foo<T> 
    // or foo<const T> 
    foo(const foo<typename std::remove_const<T>::type> &) { } 
}; 

、fooはこの質問に関連していない他のいくつかのアドオン機能で、shared_ptr<T>に似て動作します。関数のセマンティクスは、foo<const T>を取り込むことを好むことを指示する。 foo<const T>はfoo<T>から暗黙的に構築可能であるので、私は、次のような何かをできるようにしたいと思います：

template <typename T> 
void bar(foo<const T> f) { } 

int main() 
{ 
    bar(foo<const int>()); // fine 
    bar(foo<int>());  // compile error 
} 

取るbarに該当するオーバーロードが存在しないため、これが失敗したfoo<int>（foo<const int>は、暗黙のうちに可能性にもかかわらず、 foo<int>から構築、テンプレートのインスタンスと協力してオーバーロードの解決はより厳しいように思われる。

これを達成するための標準的な方法はありますか？私はを取るbar()ための2番目のオーバーロードを導入できることを知っています0と手動でbar(foo<const T>)にディスパッチしますが、可能であれば重複を避けたいと思います。

Answer 1

理由があります。その場合、foo<int>は実際にはfoo<const T>と一致せず、コンパイラはTが何であるかを推測することができません。あなたは、直接型を指定チェックするために自分で試すことができます：あなたは何ができるか

int main() 
{ 
    bar(foo<const int>()); // fine 
    bar<int>(foo<int>()); // also fine 
} 

は、コンパイラは任意の型を取るようにすることです：

template <typename T> // T might be foo<int> 
void bar(T f) { } 

それともたい場合は、コンパイラを推論をさせることができますconstなしインナーT：

template <typename T> // can deduce T as const int 
void bar(foo<T> f) { } 

あなたは本当に、あなたのクラスにユーティリティ関数を追加したい場合があります（でも、汎用コードで）const性を強制したい場合は、このような何か：あなたは一般的な機能を使用するときに、あなたが送ることができる

foo<const T> as_const() const { return *this; } 

は、あなたのクラスのconstのバージョンである：私の前のC++ 11コンパイラに示したように、私にとって

​​

Answer 2

テンプレートではコンバージョンが許可されていません。

あなたが書いた：

template <typename T> 
void bar(foo<const T> f) { } 

barはどのTため、foo<const T>を受け入れます。それは何も受け入れません。 foo<int>がfoo<const int>に変換されても問題はありません。その変換は決して考慮されません。完全停止。

あなたはconstとして受け取っfを扱いたい場合は、条件付きでそれconst行うことができます：暗黙的な変換は、テンプレート引数控除した後に適用されるので、あなたは、コードが動作しない

// convert this version 
template <class T> foo<T const> make_const_f(foo<T> const& rhs) { return {rhs}; }  
// pass this version through 
template <class T> foo<T const>& make_const_f(foo<T const>& rhs) { return rhs; } 

template <typename T> 
void bar(foo<T> f) { 
    auto&& const_f = make_const_f(f); 

    // if T was const, const_f is a reference to f 
    // if T wasn't const, const_f is a new object of type foo<T const> 
}