Discussion :

[Goten]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[loufoque]

Il manque un peu les insertions, ce qui est le plus dur.
Sans ça je comprends pas trop l'intérêt de clear par exemple.

[Goten]

Les insertions arrivent... je travaille sur la fonction qui permettra d'agrandir le vecteur au fur et à mesure.

Pour clear : ben il vide le contenu du vecteur.

[Sylvain Togni]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
    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;

Puisque tu utilise std::allocator, il serait mieux d'utiliser ses types.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
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);
}

Ce n'est pas exception safe.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
template <class T>
Cvector<T>& Cvector<T>::operator=(const Cvector<T> &v)
{
    Cvector<T> tempVector(v);
    std::swap(tempVector.data, this->data);
    return *this;
}

Il manque le swap des autres membres.

[Goten]

En effet pour le swap... une erreur de ma part. Quel exception il faut que je léve pour l'alloc?

[Sylvain Togni]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
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);
}

Le problème avec cette fonction est que si un constructeur de copie de T lance une exception pendant le std::uninitialized_fill(data, limit, value), la zone de mémoire data juste allouée est perdue => fuite mémoire, car la fonction create est appelée dans le constructeur de Cvector.