Блог

У меня есть эта функция шаблона:

 template <class P>
double Determinant(const P amp; a, const P amp; b, const P amp; c) {
    return  (b.x-a.x)*(c.y-a.y) - (c.x-a.x)*(b.y-a.y);
}
  

но я не хочу постоянно указывать возвращаемый тип double — P:: x и P:: y также могут быть целыми числами, и мне нужна эта функция в обеих ситуациях. Есть ли способ указать тип x и y, что-то вроде этого?

 //doesn't compile; can't deduce template argument for T
template <typename T, class P>
T Determinant(const P amp; a, const P amp; b, const P amp; c) {
    return  (b.x-a.x)*(c.y-a.y) - (c.x-a.x)*(b.y-a.y);
}
  

редактировать: Мой компилятор — VC2005

правка 2: извините, что забыл упомянуть: К сожалению, я не могу изменить реализацию структур для P; одним из типов точек, с которыми я имею дело, является CPoint MFC / ATL, которые жестко запрограммированы как { long x; long y; } .

Компилятор не может определить возвращаемый тип шаблона функции из аргумента функции. Вывод типа выполняется только с помощью аргументов функции.

В C 03 вы можете определить typedef в своем классе как:

 struct A //suppose A is going to be type argument to your function template
{
   int x, y;     //I'm assuming type of x and y is same!
   typedef int value_type; //type of x and y!
};
  

И затем вам придется переписать свою функцию как:

 template <class P>
typename P::value_type Determinant(const P amp; a, const P amp; b, const P amp; c) {
    return  (b.x-a.x)*(c.y-a.y) - (c.x-a.x)*(b.y-a.y);
}
  

Теперь обратите внимание на возвращаемый тип, это зависимый тип. Его :

 typename P::value_type
  

Здесь требуется ключевое слово typename .

Хорошо, как вы сказали, вы не можете изменять свои структуры, тогда вы можете использовать вместо них черты. Вот как это можно сделать:

 template<typename T> struct PTraits;

//Suppose this is your type which you can't modify
struct A //A is going to be type argument to your function template
{
   long x, y; 
};

//specialization: defining traits for struct A
template<>
struct PTraits<A>
{
    typedef long value_type; //since type of A::x and A::y is long!
};
  

И ваш шаблон функции будет выглядеть следующим образом:

 template <class P>
typename PTraits<P>::value_type Determinant(const P amp; a, const P amp; b, const P amp; c) {
    return  (b.x-a.x)*(c.y-a.y) - (c.x-a.x)*(b.y-a.y);
}
  

Обратите внимание на возвращаемый тип; теперь он немного отличается:

 typename PTraits<P>::value_type
  

Опять же, value_type это зависимое имя, поэтому ключевое слово typename является обязательным.

Обратите внимание, что вы должны специализироваться PTraits<> на каждом типе, который вы передаете в шаблон функции, как это сделал я.

Мне нравится использовать подход в стиле черт для этого:

 template<typename T> struct DeterminantReturnInfo {};  
template<> struct DeterminantReturnInfo<MyType> { typedef MyOtherType ReturnType; }

template< typename T >
typename DeterminantReturnInfo<T>::ReturnType Determinant( const P amp; a, const P amp; B, const P amp; c)
{
  return  (b.x-a.x)*(c.y-a.y) - (c.x-a.x)*(b.y-a.y);
}
  

Если вы хотите, чтобы по умолчанию он был равен double, тогда вы просто добавляете typedef double ReturnType; к исходному шаблону.

Если вы используете Visual Studio 2010 или GCC 4.5 , вы можете использовать форму завершающего типа возвращаемого значения:

 template<class P>
auto fun(const Pamp; a) -> decltype(a.x   a.y){
  return a.x   a.y;
}
  

Благодаря decltype мы автоматически получаем правильный возвращаемый тип. Кроме того, вычисление по-прежнему выполняется только один раз в теле, а не в завершающем возврате.

Проверьте возвращаемый тип его переменной-члена типа x / y. Вы можете не возвращать so тип T.