?1
template?
<
typename?T1,typename?T2
>
?2
class
?mypair?:
public
?pair
<
T1,T2
>
?3
{
?4
public
:
?5
????inline?mypair?():pair()
{}
;
?6
????inline?mypair(
const
?T1
&
?a,
const
?T2?
&
?b):pair
<
T1,T2
>
(a,b)
{}
;
?7
????inline?mypair(
const
?mypair
<
T1,T2
>
?
&
?a):pair
<
T1,T2
>
(a)
{}
;
?8
????friend?ostream
&
?
operator
<<
?
<
T1,T2
>
(ostream
&
?os,mypair
<
T1,T2
>
?
&
?p);
?9
protected
:
10
private
:
11
}
;
12
template?
<
typename?T1,typename?T2
>
13
ostream
&
?
operator
<<
(ostream
&
?os,mypair
<
T1,T2
>&
?p)
14
{
15
????os
<<
"
\n?cout?pair?
"
;
16
????os
<<
endl
<<
"
?
"
<<
p.first;
17
????os
<<
endl
<<
"
?
"
<<
p.second;
18
????
return
?os;
19
}
20
?
21
22
int
?_tmain(
int
?argc,?_TCHAR
*
?argv[])
23
{
24
????f();
25
????mypair
<
int
,
float
>
?a(
1
,
2.0333
);
26
????mypair
<
int
,
float
>
?b(
2
,
6.04343
);
27
????mypair
<
int
,
float
>
?c(b);
28
????cout
<<
a;
29
????cout
<<
b;
30
????cout
<<
c;
31
????a.swap(b);
32
????cout
<<
a;
33
????cout
<<
b;
34
35
????cout
<<
(a
==
b);
36
37
????
return
?
0
;
38
}
39
#include <utility>
?2

?3



?4

?5



?6



?7



?8

?9

10

11

12

13

14



15

16

17

18

19

20

21

22

23



24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

template <typename T1,typename T2>
class pair
{
??? 1.空構造
??? 2.雙參數構造
???? 3.拷貝構造
????? 4.swap交換
5.內含2個T1,T2型 變量(first ,second);
}
pair 是struct ,所有成員公有
template <typename T1,typename T2>
??? pair<T1,T2> make_pair(const T1&,const T2&)
?? 操作符重載模版
make_pair(a,b);//按值返回個pair< >對象;
make_pair<int,float >(a,b);
auto_ptr<T> ptr(new int);//智能指針類???
輔助函數模板
max ,min, swap
template<class Type> void swap( Type& _Left, Type& _Right ); #include <algorithm>以上是.net 2003 中 iterator 和 allocator 的代碼
4個比較算子
#include <utility>
using namespace rel_ops;
就重載了這幾個算子template<Class Type> bool operator!=( const Type& _Left, const Type& _Right);template<class Type1, class Type2> bool operator!=( const pair<Type1, Type2>& _Left, const pair<Type1, Type2>& _Right );
非pair<> 的在 std::rel_ops中?1以下是迭代器基類
?2template<class?_Category,
?3????class?_Ty,
?4????class?_Diff?=?ptrdiff_t,
?5????class?_Pointer?=?_Ty?*,
?6????class?_Reference?=?_Ty&>
?7????????struct?iterator
?8????
{????//?base?type?for?all?iterator?classes
?9????typedef?_Category?iterator_category;
10????typedef?_Ty?value_type;
11????typedef?_Diff?difference_type;
12????typedef?_Diff?distance_type;????//?retained
13????typedef?_Pointer?pointer;
14????typedef?_Reference?reference;
15????};
16?1template<class?_Ty>
?2????class?allocator
?3//基類,是個空結構
?4????????:?public?_Allocator_base<_Ty>
?5????
{????//?generic?allocator?for?objects?of?class?_Ty
?6public:
?7????typedef?_Allocator_base<_Ty>?_Mybase;
?8????typedef?typename?_Mybase::value_type?value_type;
?9
10
11????typedef?value_type?_FARQ?*pointer;
12????typedef?value_type?_FARQ&?reference;
13????typedef?const?value_type?_FARQ?*const_pointer;
14????typedef?const?value_type?_FARQ&?const_reference;
15
16????typedef?_SIZT?size_type;
17????typedef?_PDFT?difference_type;
18
19????template<class?_Other>
20????????struct?rebind
21????????
{????//?convert?an?allocator<_Ty>?to?an?allocator?<_Other>
22????????typedef?allocator<_Other>?other;
23????????};
24
25????pointer?address(reference?_Val)?const
26????????
{????//?return?address?of?mutable?_Val
27????????return?(&_Val);
28????????}
29
30????const_pointer?address(const_reference?_Val)?const
31????????
{????//?return?address?of?nonmutable?_Val
32????????return?(&_Val);
33????????}
34
35????allocator()
36????????
{????//?construct?default?allocator?(do?nothing)
37????????}
38
39????allocator(const?allocator<_Ty>&)
40????????
{????//?construct?by?copying?(do?nothing)
41????????}
42
43????template<class?_Other>
44????????allocator(const?allocator<_Other>&)
45????????
{????//?construct?from?a?related?allocator?(do?nothing)
46????????}
47
48????template<class?_Other>
49????????allocator<_Ty>&?operator=(const?allocator<_Other>&)
50????????
{????//?assign?from?a?related?allocator?(do?nothing)
51????????return?(*this);
52????????}
53
54????void?deallocate(pointer?_Ptr,?size_type)
55????????
{????//?deallocate?object?at?_Ptr,?ignore?size
56????????operator?delete(_Ptr);
57????????}
58
59????pointer?allocate(size_type?_Count)
60????????
{????//?allocate?array?of?_Count?elements
61????????return?(_Allocate(_Count,?(pointer)0));
62????????}
63
64????pointer?allocate(size_type?_Count,?const?void?_FARQ?*)
65????????
{????//?allocate?array?of?_Count?elements,?ignore?hint
66????????return?(allocate(_Count));
67????????}
68
69????void?construct(pointer?_Ptr,?const?_Ty&?_Val)
70????????
{????//?construct?object?at?_Ptr?with?value?_Val
71????????_Construct(_Ptr,?_Val);
72????????}
73
74????void?destroy(pointer?_Ptr)
75????????
{????//?destroy?object?at?_Ptr
76????????_Destroy(_Ptr);
77????????}
78
79????_SIZT?max_size()?const
80????????
{????//?estimate?maximum?array?size
81????????_SIZT?_Count?=?(_SIZT)(-1)?/?sizeof?(_Ty);
82????????return?(0?<?_Count???_Count?:?1);
83????????}
84????};
可以看出 stl是借助allocate 模板來分配元素 空間的?
一個自定義迭代器,和自定義容器
??1
template<typename?item>
??2
class?maniter;
??3
??4
template?<typename?T>
??5
class?man
??6

{
??7
public:
??8
????typedef?maniter<T>?iterator?;
??9
?????man()
?10
????
{
?11
????????array=NULL;
?12
????????size=0;
?13
????}
?14
????iterator?begin()
?15
????
{
?16
????????iterator?*pt?=new?iterator;
?17
????????pt->p=array;
?18
????????return?*pt;
?19
????}
?20
????iterator?end()
?21
????
{
?22
?????????iterator?*pt=new?iterator;
?23
?????????pt->p=array+sizeof(T)*size;
?24
?????????return?*pt;
?25
????}
?26
???????man(int?count)
?27
????
{
?28
????????
?29
????????array=new?T?[count];
?30
?31
????????size=count;
?32
????????for?(int?i=0;i<size;i++)
?33
????????
{
?34
?35
????????????*(array+i)=i;
?36
????????}
?37
????
?38
????}
?39
????man(const?man&?a)
?40
????
{
?41
?42
????????
?43
????????if(this!=&a)
?44
????????
{
?45
??????????????????????size=a.size;
?46
????????
?47
????????????try
{
?48
????????array=new?T[a.size];?
?49
????????????}
?50
????????????catch?(bad_alloc?e)?
{
?51
????????????????
?52
????????????}
?53
????????}
?54
????????for?(int?i=0;i<a.size;i++)
?55
????????
{
?56
????????????
?57
????????????*(array+i)=a.array[i];
?58
????????}
?59
????????
?60
????????
?61
????}
?62
????void?operator?=(const?man&?a)
?63
????
{
?64
????????
?65
????????
?66
????????delete?[]?array;
?67
????????array=new?T?[a.size];?
?68
????????size=a.size;
?69
????????for?(int?i=0;i<a.size;i++)
?70
????????
{
?71
????????????*(array+i)=a.array[i];
?72
????????}
?73
????????
?74
????????????//return?*this;
?75
????}
?76
????~man()
?77
????
{
?78
????????delete?[]?array;
?79
????????size=0;
?80
????}
?81
????man<T>&?operator++()
?82
????
{
?83
???????????this->array++;
?84
???????????return?*this;
?85
????}
?86
????const?man<T>?operator++(int?)
?87
????
{
?88
????????man<T>?temp=*this;
?89
????????????(this->array)++;
?90
????????????????return?temp;
?91
????}
?92
???
?93
protected:
?94
????friend?ostream&?operator<<?<T>(ostream&?os,const?man<T>?&?a);
?95
private:
?96
????T?*?array;
?97
????int?size;
?98
};
?99
template?<typename?T>
100
ostream&?operator<<(ostream&?os,?const?man<T>&?a)
101

{
102
????cout<<"\n?in?printing?man"<<endl;
103
????if?(!a.size)
104
????
{
105
????????cout<<"\n"<<"?array?is?null";
106
????}
107
???????for?(int?i=0;i<a.size;i++)
108
???????
{
109
???????????
110
??????????os<<"?"<<a.array[i];
111
???????}
112
???????cout<<endl;
113
???????return?os;
114
?}
115
116
template?<typename?it,typename?T>
117
it?myfind(it?begin,?it?end?,?const?T&?a)
118

{
119
????for?(;begin!=end&&*begin!=a;++begin)
120
????
{}
121
????return?begin;
122
}
123
?
124
template<typename?item>
125
class?maniter
126

{
127
public:
128
????item*?p;
129
????maniter():p(0)
130
????
{
131
132
????}
133
????item&?operator*()
{return?*p;};
134
????item*?operator->()
{return?p;};
135
????item&?operator++()
{p++;return?*p;};
136
????item?operator++(int)
{item?temp=*this;this++;return?temp;}
137
????bool?operator==(const?maniter?&?ele)
138
????
{
139
????????return?*p==*(ele.p);
140
????}
141
????bool?operator!=(const?maniter?&?ele)
142
????
{
143
????????return?*p!=*(ele.p);
144
????}
145
146
protected:
147
private:
148
????
149
};
150
int?_tmain(int?argc,?_TCHAR*?argv[])
151

{
152
/**//*
153
????vector<man<int>?>?a;
154
for?(int?i=1;i<10;++i)
155
????{
156
????????cout<<"\n?"<<i;
157
?????????man<int>*?manb=new?man<int>?(i);
158
????????a.push_back(*manb);
159
?????????delete?manb;
160
????????
161
????}
162
??*/
163
????man<int?>?b(5);
164
????cout<<(*myfind(b.begin(),b.end(),3));//very?perfect,自定義迭代器成功實現
165
?????//迭代器就是包含容器節點指針的類模板對象,提供?*,->,++,--,==,!=?(essential)操作的,這些操作需要迭代器
166
????//對容器結構了解,如本列中maniter?就清楚知道man?類中的節點結構是個1維數組
167
return?0;
168
}
169
170
類型萃取技術(迭代器中廣泛使用的技術)
??2

??3

??4

??5

??6



??7

??8

??9

?10



?11

?12

?13

?14

?15



?16

?17

?18

?19

?20

?21



?22

?23

?24

?25

?26

?27



?28

?29

?30

?31

?32

?33



?34

?35

?36

?37

?38

?39

?40



?41

?42

?43

?44



?45

?46

?47



?48

?49

?50



?51

?52

?53

?54

?55



?56

?57

?58

?59

?60

?61

?62

?63



?64

?65

?66

?67

?68

?69

?70



?71

?72

?73

?74

?75

?76

?77



?78

?79

?80

?81

?82



?83

?84

?85

?86

?87



?88

?89

?90

?91

?92

?93

?94

?95

?96

?97

?98

?99

100

101



102

103

104



105

106

107

108



109

110

111

112

113

114

115

116

117

118



119

120



121

122

123

124

125

126



127

128

129

130



131

132

133



134



135



136



137

138



139

140

141

142



143

144

145

146

147

148

149

150

151



152


153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

? template <typename T>
?? struct iterator
{
??? typedef T? value_type;
};
template <typename T>
?struct iterator_trait
{
?????typedef? T ?typename? T::iterator::value_type?? value_type;
};
template <typename T>
typename iterator_trait<T>::value_type
?f(T)
{};
???萃取機 iterator_trait<迭代器〉??快速的從迭代器中 取出 迭代器實際類型
(very important)
???????