typedef與typename的用法
1、型別說明typedef
型別說明的格式為:
typedef 型別 定義名;
型別說明只定義了一個數據型別的新名字而不是定義一種新的資料型別。定義名錶示這個型別的新名字。
例如: 用下面語句定義整型數的新名字:
typedef int SIGNED_INT;
使用說明後, SIGNED_INT就成為int的同義詞了, 此時可以用SIGNED_INT 定義整型變數。
例如: SIGNED_INT i, j;(與int i, j等效)。
但 long SIGNED_INT i, j; 是非法的。
typedef同樣可用來說明結構、聯合以及列舉和類。
說明一個結構的格式為:
typedef struct
{
資料型別 成員名;
資料型別 成員名;
...
} 結構名;
此時可直接用結構名定義結構變量了。例如:
typedef struct
{
char name[8];
int class;
char subclass[6];
float math, phys, chem, engl, biol;
} student;
student Liuqi;
則Liuqi被定義為結構陣列和結構指標。
2、型別解釋Typename
Typename關鍵字告訴了編譯器把一個特殊的名字解釋成一個型別，在下列情況下必須對一個name使用typename關鍵字：
1． 一個唯一的name（可以作為型別理解），它巢狀在另一個型別中的。
2． 依賴於一個模板引數，就是說：模板引數在某種程度上包含這個name。當模板引數使編譯器在指認一個型別時產生了誤解。
保險起見，你應該在所有編譯器可能錯把一個type當成一個變數的地方使用typename。就像上面那個例子中的T::id，因為我們使用了typename，所以編譯器就知道了它是一個型別，可以用來宣告並建立例項。
給你一個簡明的使用指南：如果你的型別在模板引數中是有限制的，那你就必須使用typename.
#include <iostream>
#include <typeinfo> // for typeid() operator 以上例子在Linux下用G++ 2.93編譯通過, 結果列印”Right”. 但是如果把*1行的註釋號去掉, 註釋
*2行, 則編譯時報錯, 編譯器不知道COne:one_value_type為何物. 通常在模板類引數中的型別到
例項化之後才會顯露真身, 但這個CTwo類偏偏又要依賴一個已經存在的COne模板類, 希望能夠預先
保證CTwo::two_value_type與COne::one_value屬於同一型別, 這是就只好請typename出山, 告訴
編譯器, 後面的COne::one_value_type是一個已經存在於某處的型別的名字(type name), 這樣編譯
器就可以順利的工作了.
使用typename來代替class
詳細介紹了typename的使用方法之後，我們現在就可以選擇typename來取代class宣告，這樣可以增加程式的清晰度。
//: C03:UsingTypename.cpp
// Using 'typename' in the template argument list
template<typename T> class X { };
int main()
{
X<int> x;
}你當然也會看到許多類似的程式碼沒有使用typename關鍵字，因為模板概念誕生之後很久了,才有了typename關鍵字的加入。
用typename自定義一個型別
要知道typename關鍵字不會自動的typedef，
typename Seq::iterator It;
只是聲明瞭一個Seq::iterator型別的變數，如果你想定義一個新型別的話，你必須這樣：
typedef typename Seq::iterator It;
另外這裡關於其他typename用法的解釋如下：
問題：在下面的 template declarations（模板宣告）中 class 和 typename 有什麼不同？
template class Widget; // uses “class”
template class Widget; // uses “typename”
答案：沒什麼不同。在宣告一個 template type parameter（模板型別引數）的時候，class 和 typename 意味著完全相同的東西。一些程式設計師更喜歡在所有的時間都用 class，因為它更容易輸入。其他人（包括我本人）更喜歡 typename，因為它暗示著這個引數不必要是一個 class type（類型別）。少數開發者在任何型別都被允許的時候使用 typename，而把 class 保留給僅接受 user-defined types（使用者定義型別）的場合。但是從 C++ 的觀點看，class 和 typename 在宣告一個 template parameter（模板引數）時意味著完全相同的東西。
然而，C++ 並不總是把 class 和 typename 視為等同的東西。有時你必須使用 typename。為了理解這一點，我們不得不討論你會在一個 template（模板）中涉及到的兩種名字。
假設我們有一個函式的模板，它能取得一個 STL-compatible container（STL 相容容器）中持有的能賦值給 ints 的物件。進一步假設這個函式只是簡單地列印它的第二個元素的值。它是一個用糊塗的方法實現的糊塗的函式，而且就像我下面寫的，它甚至不能編譯，但是請將這 些事先放在一邊——有一種方法能發現我的愚蠢：
template<typename C> // print 2nd element in
void print2nd(const C& container) // container;
{
// this is not valid C++!
if (container.size() >= 2) {
C::const_iterator iter(container.begin()); // get iterator to 1st element
++iter; // move iter to 2nd element
int value = *iter; // copy that element to an int
std::cout << value; // print the int
}
}我突出了這個函式中的兩個 local variables（區域性變數），iter 和 value。iter 的型別是 C::const_iterator，一個依賴於 template parameter（模板引數）C 的型別。一個 template（模板）中的依賴於一個 template parameter（模板引數）的名字被稱為 dependent names（依賴名字）。當一個 dependent names（依賴名字）巢狀在一個 class（類）的內部時，我稱它為 nested dependent name（巢狀依賴名字）。C::const_iterator 是一個 nested dependent name（巢狀依賴名字）。實際上，它是一個 nested dependent type name（巢狀依賴型別名），也就是說，一個涉及到一個 type（型別）的 nested dependent name（巢狀依賴名字）。
print2nd 中的另一個 local variable（區域性變數）value 具有 int 型別。int 是一個不依賴於任何 template parameter（模板引數）的名字。這樣的名字以 non-dependent names（非依賴名字）聞名。（我想不通為什麼他們不稱它為 independent names（無依賴名字）。如果，像我一樣，你發現術語 “non-dependent” 是一個令人厭惡的東西，你就和我產生了共鳴，但是 “non-dependent” 就是這類名字的術語，所以，像我一樣，轉轉眼睛放棄你的自我主張。）
nested dependent name（巢狀依賴名字）會導致解析困難。例如，假設我們更加愚蠢地以這種方法開始 print2nd：
template<typename C>
void print2nd(const C& container)
{
C::const_iterator * x;
...
}這看上去好像是我們將 x 宣告為一個指向 C::const_iterator 的 local variable（區域性變數）。但是它看上去如此僅僅是因為我們知道 C::const_iterator 是一個 type（型別）。但是如果 C::const_iterator 不是一個 type（型別）呢？如果 C 有一個 static data member（靜態資料成員）碰巧就叫做 const_iterator 呢？再如果 x 碰巧是一個 global variable（全域性變數）的名字呢？在這種情況下，上面的程式碼就不是宣告一個 local variable（區域性變數），而是成為 C::const_iterator 乘以 x！當然，這聽起來有些愚蠢，但它是可能的，而編寫 C++ 解析器的人必須考慮所有可能的輸入，甚至是愚蠢的。
直到 C 成為已知之前，沒有任何辦法知道 C::const_iterator 到底是不是一個 type（型別），而當 template（模板）print2nd 被解析的時候，C 還不是已知的。C++ 有一條規則解決這個歧義：如果解析器在一個 template（模板）中遇到一個 nested dependent name（巢狀依賴名字），它假定那個名字不是一個 type（型別），除非你用其它方式告訴它。預設情況下，nested dependent name（巢狀依賴名字）不是 types（型別）。（對於這條規則有一個例外，我待會兒告訴你。）
記住這個，再看看 print2nd 的開頭：
template<typename C>
void print2nd(const C& container)
{
if (container.size() >= 2) {
C::const_iterator iter(container.begin()); // this name is assumed to
... // not be a type
這為什麼不是合法的 C++ 現在應該很清楚了。iter 的 declaration（宣告）僅僅在 C::const_iterator 是一個 type（型別）時才有意義，但是我們沒有告訴 C++ 它是，而 C++ 就假定它不是。要想轉變這個形勢，我們必須告訴 C++ C::const_iterator 是一個 type（型別）。我們將 typename 放在緊挨著它的前面來做到這一點：
template<typename C> // this is valid C++
void print2nd(const C& container)
{
if (container.size() >= 2) {
typename C::const_iterator iter(container.begin());
...
}
}
通用的規則很簡單：在你涉及到一個在 template（模板）中的 nested dependent type name（巢狀依賴型別名）的任何時候，你必須把單詞 typename 放在緊挨著它的前面。（重申一下，我待會兒要描述一個例外。）
typename 應該僅僅被用於標識 nested dependent type name（巢狀依賴型別名）；其它名字不應該用它。例如，這是一個取得一個 container（容器）和這個 container（容器）中的一個 iterator（迭代器）的 function template（函式模板）：
template<typename C> // typename allowed (as is "class")
void f(const C& container, // typename not allowed
typename C::iterator iter); // typename requiredC 不是一個 nested dependent type name（巢狀依賴型別名）（它不是巢狀在依賴於一個 template parameter（模板引數）的什麼東西內部的），所以在宣告 container 時它不必被 typename 前置，但是 C::iterator 是一個 nested dependent type name（巢狀依賴型別名），所以它必需被 typename 前置。
“typename must precede nested dependent type names”（“typename 必須前置於巢狀依賴型別名”）規則的例外是 typename 不必前置於在一個 list of base classes（基類列表）中的或者在一個 member initialization list（成員初始化列表）中作為一個 base classes identifier（基類識別符號）的 nested dependent type name（巢狀依賴型別名）。例如：
template<typename T>
class Derived: public Base<T>::Nested {
// base class list: typename not
public: // allowed
explicit Derived(int x)
: Base<T>::Nested(x) // base class identifier in mem
{
// init. list: typename not allowed
typename Base<T>::Nested temp; // use of nested dependent type
... // name not in a base class list or
} // as a base class identifier in a
... // mem. init. list: typename required
};
這樣的矛盾很令人討厭，但是一旦你在經歷中獲得一點經驗，你幾乎不會在意它。
讓我們來看最後一個 typename 的例子，因為它在你看到的真實程式碼中具有代表性。假設我們在寫一個取得一個 iterator（迭代器）的 function template（函式模板），而且我們要做一個 iterator（迭代器）指向的 object（物件）的區域性拷貝 temp，我們可以這樣做：
template<typename IterT>
void workWithIterator(IterT iter)
{
typename std::iterator_traits<IterT>::value_type temp(*iter);
...
}不要讓 std::iterator_traits::value_type 嚇倒你。那僅僅是一個 standard traits class（標準特性類）的使用，用 C++ 的說法就是 “the type of thing pointed to by objects of type IterT”（“被型別為 IterT 的物件所指向的東西的型別”）。這個語句聲明瞭一個與 IterT objects 所指向的東西型別相同的 local variable（區域性變數）(temp)，而且用 iter 所指向的 object（物件）對 temp 進行了初始化。如果 IterT 是 vector::iterator，temp 就是 int 型別。如果 IterT 是 list::iterator，temp 就是 string 型別。因為 std::iterator_traits::value_type 是一個 nested dependent type name（巢狀依賴型別名）（value_type 巢狀在 iterator_traits 內部，而且 IterT 是一個 template parameter（模板引數）），我們必須讓它被 typename 前置。
如果你覺得讀 std::iterator_traits::value_type 令人討厭，就想象那個與它相同的東西來代表它。如果你像大多數程式設計師，對多次輸入它感到恐懼，那麼你就需要建立一個 typedef。對於像 value_type 這樣的 traits member names（特性成員名），一個通用的慣例是 typedef name 與 traits member name 相同，所以這樣的一個 local typedef 通常定義成這樣：
template<typename IterT>
void workWithIterator(IterT iter)
{
typedef typename std::iterator_traits<IterT>::value_type value_type;
value_type temp(*iter);
...
}
很多程式設計師最初發現 “typedef typename” 並列不太和諧，但它是涉及 nested dependent type names（巢狀依賴型別名）規則的一個合理的附帶結果。你會相當快地習慣它。你畢竟有著強大的動機。你輸入 typename std::iterator_traits::value_type 需要多少時間？
作為結束語，我應該 提及編譯器與編譯器之間對圍繞 typename 的規則的執行情況的不同。一些編譯器接受必需 typename 時它卻缺失的程式碼；一些編譯器接受不許 typename 時它卻存在的程式碼；還有少數的（通常是老舊的）會拒絕 typename 出現在它必需出現的地方。這就意味著 typename 和 nested dependent type names（巢狀依賴型別名）的互動作用會導致一些輕微的可移植性問題。
Things to Remember
·在宣告 template parameters（模板引數）時，class 和 typename 是可互換的。
·用 typename 去標識 nested dependent type names（巢狀依賴型別名），在 base class lists（基類列表）中或在一個 member initialization list（成員初始化列表）中作為一個 base class identifier（基類識別符號）時除外。