Как я могу специализировать функцию-член шаблона для std :: vector <T>

Question

Мне нужно определить метод get двумя разными способами. Один для простых типов T. И один раз для std :: vector.

template<typename T>
const T& Parameters::get(const std::string& key)
{
    Map::iterator i = params_.find(key);
    ...
    return boost::lexical_cast<T>(boost::get<std::string>(i->second));
    ...
}

Как я могу специализировать этот метод для std :: vector. Как там код должен выглядеть примерно так:

template<typename T>
const T& Parameters::get(const std::string& key)
{
    Map::iterator i = params_.find(key);
    std::vector<std::string> temp = boost::get<std::vector<std::string> >(i->second)
    std::vector<T> ret(temp.size());
    for(int i=0; i<temp.size(); i++){
         ret[i]=boost::lexical_cast<T>(temp[i]);
    }
    return ret;    
}

Но я не знаю, как специализировать функцию для этого. Большое спасибо.

Answer 1

Не специализировать шаблон функции.

• Почему бы не специализировать шаблоны функций?
• Специализация шаблона и перегрузка

Вместо этого используйте перегрузку.

Напишите шаблон функции get_impl для обработки общего случая и перегрузка (не specialize ) это для обработки конкретного случая, затем вызовите get_impl from get как:

template<typename T>
const T& Parameters::get(const std::string& key)
{
     //read the explanation at the bottom for the second argument!
     return get_impl(key, static_cast<T*>(0) );
}

И здесь идут фактические реализации.

//general case
template<typename T>
const T& Parameters::get_impl(const std::string& key, T*)
{
    Map::iterator i = params_.find(key);
    return boost::lexical_cast<T>(boost::get<std::string>(i->second));
}

//this is overload - not specialization
template<typename T>
const std::vector<T>& Parameters::get_impl(const std::string& key, std::vector<T> *)
{
      //vector specific code
}

static_cast<T*>(0) в get - это просто хитрый способ устранения неоднозначности вызова.Тип static_cast<T*>(0) - T*, и передача его в качестве второго аргумента get_impl поможет компилятору выбрать правильную версию get_impl.Если T не std::vector, будет выбрана первая версия, в противном случае будет выбрана вторая версия.

Answer 2

Эммы.назвать это что-то еще?например,

template<typename T>
const T& Parameters::getVector(const std::string& key)
{
  Map::iterator i = params_.find(key);
  std::vector<std::string> temp = boost::get<std::vector<std::string> >(i->second)
  // T is already a vector
  T ret; ret.reserve(temp.size());
  for(int i=0; i<temp.size(); i++){
     ret.push_back(boost::lexical_cast<typename T::value_type>(temp[i]));
  }
  return ret;  
}

Вам нужно будет назвать это как:

foo.getVector<std::vector<int> > ("some_key");

Ничто в вашем вопросе не исключает этого.

Теперь, если вам действительно нужно использоватьget(), тогда вам придется полагаться на частичную специализацию структуры, поскольку частичная специализация функции не поддерживается языком.

Это намного сложнее, например:

template <typename T>
struct getter
{
  const T& operator()(std::string const& key)
  {
    // default operations
  }
};

// Should double check this syntax 
template <typename T>
struct getter<std::vector<T, std::allocator<T> > >
{
  typedef std::vector<T, std::allocator<T> > VecT;
  const VecT& operator()(std::string const& key)
  {
    // operations for vector
  }
};

Тогда у вас метод становится:

template<typename T>
const T& Parameters::get(const std::string& key)
{
  return getter<T>()(key); // pass the structures getter needs?
}