C++重写vector
int main()
{ Vector<int> vec;
//添加元素
vec.push_back(1);
vec.push_back(2);
vec.push_back(3);
vec.push_back(3);
vec.toString();
//弹出最后一个元素
vec.pop_back();
vec.toString();
//直接取某个元素
const int a = vec[0];
cout<<"vec[1]:"<<vec[1]<<endl;
return 0;
} |
|
1
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
|
#include "stdafx.h"#include <iostream>using namespace std;
//template 关键字后接模板形参表,表明这里定义的Vector是一个类模板,而不是一个类,//Vector<int>才是一个类.函数模板也是一样,它们都只是一个"公式".template <typename Object>
class Vector
{public:
static const int SPARE_CAPACITY = 16;
//将构造函数声明为explicit ,是为了抑制由构造函数定义的隐式转换
/*
构造函数的初始化列表.关于构造函数的初始化列表, 有两个要点.第一, 即使列表为空, 没有初始化式,
构造函数也会先初始化每个成员再进入函数体, 这时初始化的规则与初始化变量相同,
由此得知第二个要点:如果类的成员本身是一个没有默认构造函数的类类型, 或者成员是const、引用类型,
这样的成员必须在构造函数初始化列表中进行初始化
*/
explicit Vector(int initSize = 0) :theSize(initSize), theCapacity(initSize + SPARE_CAPACITY)
{
//new返回一个指向Object类型数组的指针
objects = new Object[theCapacity];
}
Vector(const Vector& rhs) :objects(NULL)
{
operator=(rhs);
}
~Vector()
{
delete[] objects;
}
const Vector& operator=(const Vector& rhs)
{
if (this != &rhs)
{
delete[] objects;
theSize = rhs.theSize;
theCapacity = rhs.theCapacity;
objects = new Object[theCapacity];
for (int k = 0; k < theSize; k++)
{
objects[k] = rhs.objects[k];
}
}
return *this;
}
/*
由于成员函数的定常性是(即函数名后是否有const关键字)是签名的一部分,
因此我们可以使用访问函数的operator[]版本返回const引用,而修改函数版本返回一般引用
*/
Object& operator[](int index)
{
if (index < 0 || index >= theSize)
{
return objects[0];
}
cout << "--Object& operator[](int index)"<<endl;
return objects[index];
}
const Object& operator[](int index)const
{
cout << "** const Object& operator[](int index)const" << endl;
return objects[index];
}
//检测是否需要扩容
void reserve()
{
reserve(theSize);
}
void reserve(int newSize)
{
if (theCapacity > newSize)
{
return;
}
int newCapacity = theCapacity * 2 + 1;
Object* oldArr = objects;
objects = new Object[newCapacity];
for (int k = 0; k < theSize; k++)
{
objects[k] = oldArr[k];
}
theCapacity = newCapacity;
delete[] oldArr;
}
int size()const
{
return theSize;
}
int capacity()const
{
return theCapacity;
}
bool empty()const
{
return theSize == 0;
}
void resize(int newSize)
{
reserve(newSize);
theSize = newSize;
theCapacity = newSize;
}
void push_back(const Object& obj)
{
reserve(); //检测容器大小
objects[theSize++] = obj;
}
void pop_back()
{
theSize--;
}
const Object & back()const
{
return objects[theSize - 1];
}
Object* begin()
{
return &objects[0];
}
Object* end()
{
return &objects[theSize];
}
const Object* end()const
{
return&objects[theSize];
}
void toString()
{
cout << "Vecot长度:" << size() << ",容量：" << capacity() << endl;
for (int i = 0; i < theSize; i++)
{
cout << "objects[" << i << "]:" << objects[i] << endl;
}
}
typedef Object* iterator;
typedef const Object* const_iterator;
private:
int theSize;
int theCapacity;
Object* objects;
}; |