問題描述
我決定測試Effective C++"中的一個示例，但沒有得到預期的結果.所以，顯然這個(簡化的)代碼不應該編譯:
I decided to test one of the examples in "Effective C++" and I'm not getting the result I expected. So, apparently this (simplified) code shouldn't compile:
template <class T>
struct A {
void f(){}
};
template <class T>
struct B : public A <T> {
void f2() { f(); } // calling base function - will not compile
};
以下是解釋(為了簡單起見，類名已更改):
Here's the explanation (class names changed for simplicity) :
上面的代碼不能編譯，至少在符合標準的編譯器中不能.這樣的編譯器會抱怨 f 不存在.我們可以看到 f 在基類中，但編譯器不會在那里尋找它.
The code above won't compile, at least not with conformant compilers. Such compilers will complain that
fdoesn't exist. We can see thatfis in the base class, but compilers won't look for it there.
我們需要了解原因.問題是當編譯器遇到類模板 B 的定義時，它們不知道它繼承自哪個類.當然，它是 A，但 T 是一個模板參數，一個直到以后才會知道(當 B 被實例化時).不知道什么T也就是說，沒有辦法知道 A<T> 類是什么樣的.特別是，沒有辦法知道它是否有 f 函數.
We need to understand why.
The problem is that when compilers encounter the definition for the class template B, they
don't know what class it inherits from. Sure, it's A<T>, but T is a template parameter,
one that won't be known until later (when B is instantiated). Without knowing what T
is, there's no way to know what the class A<T> looks like. In particular, there's no way to know if it has a f function.
我的編譯器 (Visual Studio) 不介意...它甚至不顯示任何警告.
My compiler (Visual Studio) doesn't mind... It doesn't even show any warnings.
以上代碼是否正確?
推薦答案
template <class T>
struct A {
void f(){}
};
template <class T>
struct B : public A <T> {
void f2() { f(); } // calling base function - will not compile
};
在派生模板中，表達式 f() 不依賴于任何模板參數，因此編譯器會在第一階段查找期間嘗試解析它.此時，模板還沒有用類型實例化，編譯器不會查看基本的 A<T>.原因是編譯器不可能知道對于實例化的類型是否存在可能不包含任何成員的 A 特化.
In the derived template, the expression f() is not dependent on any template argument, so the compiler attempts to resolve it during the first phase lookup. At this point, the template has not yet been instantiated with the type, and the compiler won't look into the base A<T>. The reason is that the compiler could not possibly know whether for the type of the instantiation there is a specialization of A<T> that might not contain any members.
解決方案是使表達式依賴，最簡單的方法是使用 this-> 進行限定:
The solution is to make the expression dependent, the simplest way would be to qualify with this->:
template <typename T>
void B<T>::f2() { this->f(); }
由于表達式現在是相關的，查找被延遲到第二階段，在該階段替換類型并且 A 是一個具體類型.另一種選擇是使用定義它的類進行限定:
As the expression is now dependent, lookup is delayed until the second phase, where the type is substituted and A<T> is a concrete type. Another alternative is qualifying with the class where it is defined:
template <typename T>
void B<T>::f2() { A<T>::f(); }
再次表達變得依賴，并將在第二階段解決.主要區別在于，在第二種情況下，調用是合格的，因此它不使用動態調度.如果 A<T>::f() 是虛擬的，它仍然會執行 A<T>::f()，而不是最終的覆蓋.
Again the expression becomes dependent and will be resolved during the second phase. The main difference is that in this second case, the call is qualified and thus it does not use dynamic dispatch. If A<T>::f() was virtual it would still execute A<T>::f(), and not the final overrider.
代碼正確嗎?不.VS 接受嗎?是的.
Is the code correct? No. Does VS accept it? Yes.
這是 Visual Studio 編譯器中已知的不符合項，未實現兩階段查找.它將模板內的所有查找延遲到第二階段，此時查找成功.
This is a known non-conformance in the Visual Studio compiler, that does not implement two phase lookup. It delays all lookup inside the template to the second phase and at that point lookup succeeds.
這篇關于為什么我可以從派生類調用基模板類方法的文章就介紹到這了，希望我們推薦的答案對大家有所幫助，也希望大家多多支持html5模板網！