一千萬個為什麽

搜索

運算符+表示模板類的子類型


我有一個定義子類型的模板類。我正在嘗試將二進制 operator + 定義為模板函數,但編譯器無法解析 operator + 的模板版本。

#include 
template 
struct c {
  c(other_type v) : cs(v) {}
  struct subtype { subtype(other_type v) : val(v) {} other_type val; } cs;
};

template
typename c::subtype operator+(const typename c::subtype& left,
                      const typename c::subtype& right)
{ return typename c::subtype(left.val + right.val); }

// This one works
// c::subtype operator+(const c::subtype& left,
//          const c::subtype& right)
// { return c::subtype(left.val + right.val); }

int main()
{
  c c1 = 1;
  c c2 = 2;
  c::subtype cs3 = c1.cs + c2.cs;
  std::cerr << cs3.val << std::endl;
}

I think the reason is because the compiler (g++4.3) cannot guess the template type so it's searching for operator+ instead of operator+.

這是什麽原因?你能提出什麽優雅的解決方案?

最佳答案

你的懷疑是正確的。編譯器不知道 other_type 是什麽。它無法從論證中推斷出來。這種形式通常太松,無法提供所需的信息。考慮

template 
struct c {
  c(other_type v) : cs(v) {}
  typedef int subtype;
};

If you were to pass an int, then any of c would fit the bill because all of them have type int. In the specific case of nested classes, it may be possible, but even then it's not unique. Imagine that in c you could put a typedef c subtype;, then both c::subtype and c::subtype would fit the bill.

回到預先標準的時間,存在一個模板問題列表,特別是John Spicer確實經歷過並發明了合理的解決方案。這是一個這樣的問題,並且發現它不值得麻煩。你總是明確地需要提供參數 - 它永遠不會被推斷出來。

您可以將代碼更改為此

template 
struct subtype { 
  subtype(other_type v) : val(v) {}
  other_type val; 
};

template 
struct c {
  c(other_type v) : cs(v) {}
  subtype cs;
};

template
subtype operator+(const subtype& left,
                      const subtype& right)
{ return subtype(left.val + right.val); }

或者對此

template 
struct c {
  c(other_type v) : cs(v) {}
  struct subtype { 
   subtype(other_type v) : val(v) {} other_type val; 

    /* note: don't forget friend! */
    friend subtype operator+(const subtype& left,
                      const subtype& right)
    { return subtype(left.val + right.val); }
  } cs;
};

轉載註明原文: 運算符+表示模板類的子類型

猜你喜歡