Exercice : création d'une classe vector std-like
Bonjour à tous, comme exercice (j'utilise accelerated c++) j'ai tenté de créer une classe vector std-like... J'aimerais votre avis notemment : sur l'utilisation d'un std::allocator ainsi que mon opérateur =. Il marche mais je suis pas sur de ma méthode vu que je copie que les donnés.
Ce qui m'intéresse surtout c'est de savoir si ma classe est robuste. (je cherche pas à faire quelque chose d'ultra complet mais à apprendre plus sur le code robuste).
voilà :
Code:
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
|
#ifndef CVECTOR_HPP
#define CVECTOR_HPP
#include <memory>
template <class T> class Cvector
{
public :
typedef T* iterator;
typedef const T* const_iterator;
typedef T& reference;
typedef const T& const_reference;
typedef size_t size_type;
typedef T value_type;
typedef std::ptrdiff_t difference_type;
Cvector() { create(); }
explicit Cvector(size_type size, const T& value = T()) { create(size, value); }
Cvector(const Cvector& v) { create(v.begin(), v.end()); }
~Cvector() { uncreate(); }
reference operator[](size_type i) { return data[i]; }
const_reference operator[](size_type i) const { return data[i]; }
Cvector& operator=(const Cvector&);
iterator begin() { return data; }
const_iterator begin() const { return data; }
iterator end() { return limit; }
const_iterator end() const { return limit; }
size_type size() const { return limit - data; }
bool isEmpty() { return data == limit; }
void clear() { uncreate(); }
private :
iterator data;
iterator avail;
iterator limit;
std::allocator<T> alloc;
void create();
void create(size_type, const T&);
void create(const_iterator, const_iterator);
void uncreate();
};
template <class T> void Cvector<T>::create()
{
data = limit = 0;
}
template <class T>
void Cvector<T>::create(size_type size, const T& value)
{
data = alloc.allocate(size);
limit = avail = data + size;
std::uninitialized_fill(data, limit, value);
}
template <class T>
void Cvector<T>::create(const_iterator begin, const_iterator end)
{
data = alloc.allocate(end - begin);
limit = avail = std::uninitialized_copy(begin, end, data);
}
template <class T> void Cvector<T>::uncreate()
{
if(data)
{
iterator iter = avail;
while(iter != data)
alloc.destroy(--iter);
alloc.deallocate(data, limit-data);
}
limit = avail = data = 0;
}
template <class T>
Cvector<T>& Cvector<T>::operator=(const Cvector<T> &v)
{
Cvector<T> tempVector(v);
std::swap(tempVector.data, this->data);
return *this;
}
#endif |
