首页 › UC › 自己封装vector

自己封装vector

第七根弦 2014 年 10 月 23 日 UC 发表评论 (0)

自己封装的vector

vector.h

C++
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
//vector.h
#ifndef _VECTOR_H_
#define _VECTOR_H_
#include <stdio.h>
template <typename T>
class Vector
{
private:
    typedef T value_type;
    typedef value_type* point_type;
    typedef const value_type* const_point_type;
    typedef value_type& ref_type;
    typedef const value_type& const_ref_type;
    typedef unsigned int size_type;
public://类型
    typedef point_type iterator;
    typedef const_point_type const_iterator;
    
public://构造函数、析构函数
    Vector();
    //构造n个空间
    Vector(int sizes);
    //构造n个空间，并且把n个空间都置为指定值
    Vector(int n,const_ref_type value);
    //拷贝构造函数
    Vector(const Vector<T>& rhs);
    ~Vector();
    
public://访问
    //返回一个迭代器
    iterator begin();
    iterator end();
    //返回一个引用
    ref_type at(int i) const;
    //返回大小
    size_type capacity() const; //返回总容量的大小
    size_type length() const;     //返回当前元素的大小
    
public://操作
    //清空内存
    void clearn();
    //清除某个范围内的元素 ,默认全部清除
    template<typename Iterator>
    void erase(const Iterator& b=NULL,const Iterator& e=NULL);
    //在向量的后面插入一个元素
    void push_back(const_ref_type value);
    //插入操作
    template<typename Iterator>
    void insert(const Iterator& it,const_ref_type value);
    //下标i 处插入一个值
    void insert(int i,const_ref_type value);
    //交换两个向量
    void swap(Vector<T>& rhs);
public://重载
    Vector<T>& operator = (const Vector<T>& rhs);
    ref_type operator [] (int i);
    
private:
    int _capacity;  //总容量的大小
    int _size;      //当前容量的大小
    value_type* _element; //元素
};
#if defined(_DEBUG)
    #include "vector.cpp"
#else
#endif //end if defined  _DEBUG
#endif

vector.cpp

C++
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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
//vector.cpp
#include "vector.h"
#include <algorithm>
#include <stdexcept>
#include <functional>
#include <iterator>
using std::copy;
using std::copy_backward;
using std::fill;
using std::runtime_error;
using std::out_of_range;
//Vector class defined
//_size _capacity 按定义的顺序初始化
template<typename T>
Vector<T>::Vector():_size(0),_capacity(1)
{
    _element=new value_type[_capacity];
}
template<typename T>
Vector<T>::Vector(int sizes):_size(0),_capacity(sizes)
{
    _element=new value_type[_capacity];
}
template<typename T>
Vector<T>::Vector(int n,const_ref_type value):_size(n),_capacity(n)
{
    _element=new value_type[_capacity];
    fill(begin(),end(),value);
}
template<typename T>
Vector<T>::Vector(const Vector<T>& rhs)
{
    //防止自复制
    if( this != &rhs )
    {
        _capacity=rhs.capacity();
        if ( !(_element=new value_type[_capacity]) )
            throw runtime_error("申请内存失败");  
        _size=rhs.length();
        for( int i=0; i < rhs.length(); i++ )
            _element[i]=rhs._element[i];
    }
}
template<typename T>
Vector<T>::~Vector()
{
    delete []_element;
}
template<typename T>
typename Vector<T>::size_type Vector<T>::length() const
{
    return _size;
}
template<typename T>
typename Vector<T>::size_type Vector<T>::capacity() const
{
    return _capacity;
}
template<typename T>
typename Vector<T>::iterator Vector<T>::begin()
{
    return _element;
}
template<typename T>
typename Vector<T>::iterator Vector<T>::end()
{
    return _element+_size;
}
template<typename T>
void Vector<T>::clearn()
{
    _size=0;
}
//在元素最后插入一个值
template<typename T>
void Vector<T>::push_back(const_ref_type value)
{
    //内存不够的情况下
    if( _size == _capacity )
    {
        _capacity*=2;
        point_type news=new value_type(_capacity);
        if( !news )
            throw runtime_error("申请内存失败");
            
        copy(begin(),end(),news);
        delete []_element;
        _element=news;
    }
    _element[_size++]=value;
}
//在迭代器的指向处插入一个值
template<typename T>
template<typename Iterator>
void Vector<T>::insert(const Iterator& it,const_ref_type value)
{
    Iterator _it=it;
    
    point_type news;
    if( _size == _capacity )//内存不够的情况下
    {
        _capacity*=2;
        news=new value_type[_capacity];
        if( !news )
            throw runtime_error("申请内存失败");
    }
    else //内存足够的情况下
        news=new value_type[_capacity];
    //先拷贝后面的元素到目标中（从后开始拷贝）
    copy_backward(_it,end(),news+_size+1);
    //std::cout<<std::endl;
    //计算插入位置与开始位置的距离
    int dis=_it-begin();
    //保存老位置
    Iterator tit=_it;
    //将it指向新内存的插入位置
    _it=news+dis;
    //插入元素
    *_it=value;
    //复制剩下的元素
    copy(begin(),tit,news);
    //释放旧内存
    delete []_element;
    //交换内存
    _element=news;
    ++_size;
}
//在下标位置i处插入元素
template<typename T>
inline void Vector<T>::insert(int i,const_ref_type value)
{
    iterator it=_element+i;
    insert(it,value);
}
template<typename T>
void Vector<T>::swap(Vector<T>& rhs)
{
     std::swap(rhs._capacity,_capacity);
     std::swap(rhs._size,_size);
     std::swap(rhs._element,_element);
}
template<class T>
Vector<T>& Vector<T>::operator = (const Vector<T>& rhs)
{
    if( _capacity <= rhs.capacity() )
    {
        delete []_element;
        _element=NULL;
        iterator news=new value_type[rhs.capacity()];
        std::swap(_element,news);
    }
    Vector<T>(rhs).swap(*this);
}
template<typename T>
typename Vector<T>::ref_type Vector<T>::operator [] (int i)
{
    if( i >= _size )
    {
        if( i <= _capacity )
            _size=i+1;
        else//越界报错返回
            return _element[_capacity];
    }      
    return _element[i];
}
template<typename T>
typename Vector<T>::ref_type Vector<T>::at(int i) const
{
    if( i >= _size )
        throw out_of_range("访问越界");
    return _element[i];
}
template<typename T>
template<typename Iterator>
void Vector<T>::erase(const Iterator& b,const Iterator& e)
{
    //计算删除的距离
    int dis=e-b+1;
    copy(e,end(),b);
    _size=(_size-dis < 0 ? 0:(_size-dis+1) );
}

test.cpp

C++
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
//test.cpp
#include <iostream>
#include <cstdlib>
#define _DEBUG
#include "vector.h"
#include <stdexcept>
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
int main(int argc, char *argv[]) {
    Vector<int> vec(100);
    for( int i=0; i < 100; i++ )
    {
        vec[i]=i;
        //int x=vec[i];
        //cout<<"vec["<<i<<"]="<<x<<" ";
    }
    Vector<int> vecCopy;
    vecCopy=vec;
    cout<<endl;
    cout<<"元素大小"<<vec.length()<<endl;
    Vector<int>::iterator it;
    it=vec.begin();
    vec.erase(vec.begin(),vec.begin()+5);
    cout<<"删除后的元素大小"<<vec.length()<<endl;
    
    while( it != vec.end() )
    {
        cout<<*it<<" ";
        it++;
    }
    cout<<endl;
    cout<<"在下标2处插入了一个元素31"<<endl;
    vec.insert(2,31);
    for( int i=0; i < vec.length(); i++ )
    {
        cout<<vec[i]<<" ";
    }
    cout<<endl;
    
    cout<<endl;
    cout<<"通过at函数访问元素"<<vec.at(0)<<endl;
    try
    {
        cout<<vec.at(101)<<endl;
    }catch(exception &err)
    {
        cout<<err.what()<<endl;
    }
    cout<<endl;
    vec.clearn();
    cout<<"清空后的元素大小为"<<vec.length()<<endl;
    
    cout<<"复制的向量对象:"<<endl;
    for( int j=0; j < vecCopy.length(); j++ )
        cout<<vecCopy[j]<<" ";
    cout<<endl;
    
    system("pause");
    return 0;
}

|

发表评论