自己动手写STL中的vector

M0313-array_class_template.h

#ifndef DYNAMIC_ARRAY_H_
#define DYNAMIC_ARRAY_H_

#include <cstddef>
#include <stdio.h>

struct A {
A(int n = 0): i(n) {
printf("A(%d)\n", i);
}

~A() {
printf("~A(%d)\n", i);
}

int i;
};

// typedef int T;
//typedef A T;

template<typename T>
class DynamicArray {
public:
enum { DEFAULT_CAP = 16 };

explicit DynamicArray(size_t capactiy = DEFAULT_CAP);
DynamicArray(size_t count, T val);

DynamicArray(const DynamicArray& rhs);
DynamicArray& operator=(const DynamicArray& rhs);

~DynamicArray();

void push_back(T val);
void insert(size_t pos, T val);

void pop_back();
void erase(size_t pos);

T operator[](size_t index) const;
T& operator[](size_t index);

const T* data() const;
T* data();

size_t size() const;
size_t capacity() const;
bool empty() const;

private:
void destroy();

private:
T* ar;
size_t _capacity;
size_t _size;
};

#include "M0313-array_class_template.ipp"

#endif

#include <iostream>
#include <cstring>

template<typename T>
DynamicArray<T>::DynamicArray(size_t cap): _capacity(cap), _size() {
ar = static_cast<T*>(::operator new(sizeof(T) * _capacity));
}

template<typename X>
DynamicArray<X>::DynamicArray(size_t count, X val): _capacity(count), _size(count) {
ar = static_cast<X*>(::operator new(sizeof(X) * _capacity));

for (size_t i = 0; i < _size; ++i)
new (ar + i) X(val);
}

template<typename T>
DynamicArray<T>::DynamicArray(const DynamicArray<T>& rhs): _capacity(rhs._capacity), _size(rhs._size) {
ar = static_cast<T*>(::operator new(sizeof(T) * _capacity));
for (size_t i = 0; i < _size; ++i)
new (ar + i) T(*(rhs.ar + i));
}

template<typename T>
DynamicArray<T>& DynamicArray<T>::operator=(const DynamicArray<T>& rhs) {
if (this != &rhs) {
_capacity = rhs._capacity;
_size = rhs._size;

destroy();
for (size_t i = 0; i < _size; ++i)
new (ar + i) T(*(rhs.ar + i));
}

return *this;
}

template<typename T>
DynamicArray<T>::~DynamicArray() {

destroy();
}

template<typename T>
void DynamicArray<T>::push_back(T val) {
if (_size == _capacity) {
_capacity *= 2;

T* tmp = static_cast<T*>(::operator new(sizeof(T) * _capacity));
for (size_t i = 0; i < _size; ++i)
new (tmp + i) T(*(ar + i));

destroy();
ar = tmp;
}

new (ar + _size) T(val);
++_size;

}
// TODO
template<typename T>
void DynamicArray<T>::insert(size_t pos, T val) {
if (_size == _capacity) {
_capacity *= 2;
T* tmp = static_cast<T*>(::operator new(sizeof(T) * _capacity));
for (size_t i = 0; i < pos; ++i)
new (tmp + i) T(*(ar + i));

for (size_t i = pos + 1; i < _size; ++i)
new (tmp + i) T(*(ar + (i - 1)));

new (tmp + pos) T(val);

destroy();
ar = tmp;
} else {
for (size_t i = _size; i > pos; --i)
ar[i] = ar[i - 1];

new (ar + pos) T(val);
}

++_size;
}

template<typename T>
void DynamicArray<T>::pop_back() {
(ar + (_size - 1))->~T();
--_size;
}

template<typename T>
void DynamicArray<T>::erase(size_t pos) {
(ar + pos)->~T();

for (size_t i = pos; i < _size - 1; ++i)
ar[i] = ar[i + 1];

--_size;
}

template<typename T>
T DynamicArray<T>::operator[](size_t index) const {
return ar[index];
}

template<typename T>
T& DynamicArray<T>::operator[](size_t index) {
return ar[index];
}

template<typename T>
size_t DynamicArray<T>::size() const {
return _size;
}

template<typename T>
size_t DynamicArray<T>::capacity() const {
return _capacity;
}

template<typename T>
bool DynamicArray<T>::empty() const {
return (_size == 0);
}

template<typename T>
const T* DynamicArray<T>::data() const {
return ar;
}

template<typename T>
T* DynamicArray<T>::data() {
return ar;
}

template<typename T>
void DynamicArray<T>::destroy() {
for (size_t i = 0; i < _size; ++i)
ar[i].~T();
::operator delete(ar);
}

测试程序

#include "M0313-array_class_template.h"

#include <iostream>
#include <cstring>

std::ostream& operator<<(std::ostream& os, const A& a1) {
return os << a1.i;
}

template<typename T>
void print(const DynamicArray<T>& a) {
const size_t N = a.size();
for (size_t i = 0; i < N; ++i)
std::cout << a[i] << ' ';
std::cout << '\n';
}

int main() {
using namespace std;

DynamicArray<A> a1(6);
a1.push_back(A(120));
a1.push_back(A(190));
a1.push_back(A(123));
a1.push_back(A(129));
a1.push_back(A(620));
a1.push_back(A(890));

// print(a1);
cout << "1------------------------------\n";

a1.insert(3, A(1000));
print(a1);
cout << "a1.size(): " << a1.size() << endl;
cout << "2------------------------------\n";

a1.erase(3);
a1.pop_back();

cout << "a1.size(): " << a1.size() << endl;
print(a1);
cout << "3------------------------------\n";

return 0;
}