Выберите шаблон строки неявно пропусканием константный символ *

Question

Предположим, что у меня есть пользовательский строковый класс:

class my_string : public std::string 
{ 
    // ... 
} 

И я хочу сделать шаблонный функцию, которая принимает и с my_string по умолчанию:

template <typename TString = my_string> 
TString do_something(const TString& input) 
{ 
    // ... 
} 

Но когда я называю его:

auto result = do_something("abcdef"); 

Он называет (конечно) do_something<char[7]>(). Как заставить это позвонить do_something<my_string>без, явно указывая тип (т. Е. Напишите do_something("abcdef"), а не do_something<my_string>("abcdef"))?

Answer 1

Уточнить для "construct from string arguments".

template <typename TString = my_string, 
typename std::enable_if<std::is_base_of<std::string, TString>::value>::type = nullptr> 
TString do_something(const TString& input) 
{ 
    // ... 
} 

template <typename ...Args, 
typename std::enable_if<std::is_constructible<my_string, Args....>::value>::type = nullptr> 
my_string do_something(Args&&... args) 
{ 
    return do_something<my_string>({args}); 
} 

Answer 2

Действительно ли вам нужен шаблон функции? Простая функция:

my_string do_something(my_string const& input) { ... } 

решает использовать ваш случай использования. Вы можете передать my_string или строковый литерал, или даже braced-init-list, и все просто работает.

---

Поскольку вам нужен шаблон по другим причинам, вы можете просто обеспечить перегрузку для массивов const char:

template <class TString> 
TString do_something(TString const&) { ... } 

template <size_t N> 
my_string do_something(const char (&arr)[N]) { 
    return do_something(my_string{arr, N-1}); 
} 

---

Примечание: нет никаких причин, чтобы обеспечить по умолчанию для параметра шаблона TString. Нет смысла использовать это значение по умолчанию.

Answer 3

Re

” Я хочу сделать шаблонную функцию, которая принимает как с my_string по умолчанию

#include <string> 

template< class Type > 
struct Explicit_t_ { using T = Type; }; 

template< class Type > 
using Explicit_ = typename Explicit_t_<Type>::T; 

namespace my { 
    struct String: std::string { using std::string::string; }; 
} // namespace my 

template< class Some_string > 
auto do_something(Explicit_<Some_string> const&) 
    -> Some_string 
{ return "Template func!"; } 

auto do_something(my::String const&) 
    -> my::String 
{ return "my::String!"; } 

#include <iostream> 
using namespace std; 
auto main() 
    -> int 
{ 
    cout << do_something("") << endl;  // Output "my::String!" 
    cout << do_something<std::string>("") << endl; 
} 

Вы можете позволить перегрузку my::String только вперед шаблон функции , если вы не хотите более специализированной или другой реализации.