類pair提供了這樣一種機制,它把兩個(有序)值作為一個單元對待.在c++標準庫中,它被廣泛的應用.特別是在容器類map和multimap中大量的使用了pair來管理它們的元素.另外一個對于pair的廣泛使用就是在那些要返回兩個值的函數中.
結構pair被定義在<utility>中,如下:
namespace std {
template <class T1, class T2>
struct pair {
//type names for the values
typedef T1 first_type;
typedef T2 second_type;
//member
T1 first;
T2 second;
/* default constructor
* - T1 () and T2 () force initialization for built-in types
*/
pair()
: first(T1()), second(T2()) {
}
//constructor for two values
pair(const T1& a, const T2& b)
: first(a), second(b) {
}
//copy constructor with implicit conversions
template<class U, class V>
pair(const pair<U,V>& p)
: first(p.first), second(p.second) {
}
};
//comparisons
template <class T1, class T2>
bool operator== (const pair<T1,T2>&, const pair<T1,T2>&);
template <class T1, class T2>
bool operator< (const pair<T1,T2>&, const pair<T1,T2>&);
//similar: !=, <=, >, >=
//convenience function to create a pair
template <class T1, class T2>
pair<T1,T2> make_pair (const T1&, const T2&);
}
注意pair被定義為struct而不是class,這就是說訪問pair中任何一個單獨的值都是可以的.默認的構造函數會調用模板類型中默認的構造函數.當然,它也會初始化基本類型如int為默認的值.比如:
std::pair<int,float> p;
這樣的結果就是p.first=0,p.second=0
上面的帶模板的拷貝構造函數是在隱式類型轉換的時候使用的.如:
void f(std::pair<int,const char*>);
void g(std::pair<const int.std::string>);
void foo {
std::pair<int,const char*> p(42,"hello");
f(p); //OK: calls built-in default copy constructor
g(p); //OK: calls template constructor
}
上面的例子還不能說明問題,下面我自己實現一個pair:
template <class T1,class T2>
class MyPair
{
public:
T1 first;
T2 second;
MyPair():first(T1()),second(T2())
{
std::cout<<"first constructor"<<std::endl;
}
MyPair(const T1& a,const T2&b):first(a),second(b)
{
std::cout<<"second constructor"<<std::endl;
}
template<class U,class V>
MyPair(const MyPair<U,V> &myP):first(myP.first),second(myP.second)
{
std::cout<<"third constructor"<<std::endl;
}
};
相應f()和g()也進行一番改動:
void f(MyPair<int,const char*> arg)
{
std::cout<<arg.first<<","<<arg.second<<std::endl;
}
void g(MyPair<int,std::string> arg)
{
std::cout<<arg.first<<","<<arg.second<<std::endl;
}
這是調用過程:
int main()
{
MyPair<int,const char*> p(100,"Hello World");
f(p);
g(p);
}
這是調用結果:
second constructor
100,Hello World
third constructor
100,Hello World
可以看到f(p)的參數的模板類與之前構造的模板類相同,所以會調用默認的構造函數進行復制.
但是g(p)的參數的模板類與之前構造的模板類不同,所以會調用帶模板定義的拷貝構造函數進行復制.
序偶的比較
兩個序偶相同,當且僅當兩個序偶中對應的值相同.
namespace std {
template <class T1, class T2>
bool operator== (const pair<T1,T2>& x, const pair<T1,T2>& y) {
return x.first == y.first && x.second == y.second;
}
}
比較兩個序偶的大小,第一個元素有較高的優先級,第一個元素小的序偶小,如果第一個元素相等,則比較第二個.
namespace std {
template <class T1, class T2>
bool operator< (const pair<T1,T2>& x, const pair<T1,T2>& y) {
return x.first < y.first ||
(!(y.first < x.first) && x.second < y.second);
}
}
一個方便的構造序偶的函數make_pair
std::make_pair(42,'@')可以用來取代std::pair<int,char>(42.'@')
make_pair的定義:
namespace std {
//create value pair only by providing the values
template <class T1, class T2>
pair<Tl,T2> make_pair (const T1& x, const T2& y) {
return pair<T1,T2>(x, y);
}
}
但是在某些情況下,你可能需要顯式的定義類型,這個時候make_pair往往不會產生預期的結果:
std::pair<int,float>(42,7.77)
與
std::make_pair(42,7.77)
所產生的pair并不相同,因為后者等效于std::pair<int,
double>(42,7,77)
posted on 2007-07-03 23:49
littlegai 閱讀(310)
評論(0) 編輯 收藏 引用