Exercice : création d'une classe vector std-like

**Goten** · 25/11/2008, 12h45

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** · 25/11/2008, 20h51

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** · 26/11/2008, 10h56

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** · 26/11/2008, 15h53

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** · 26/11/2008, 18h38

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

**Sylvain Togni** · 27/11/2008, 18h07

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.

**Goten** · 27/11/2008, 22h04

Arf... pas sur de voir une solution là. Faut que je léve une exception?

**Sylvain Togni** · 28/11/2008, 14h53

Non, le problème est la fuite mémoire.
La solution impliquant le moins de changements au code serait un try catch :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
template <class T>
void Cvector<T>::create(size_type size, const T& value)
{
    data = alloc.allocate(size);
 
    limit = avail = data + size;
    try {
        std::uninitialized_fill(data, limit, value);
    } catch(...) {
        alloc.deallocate(data, size);
        throw; // on relance l'exception
    }
}

Une solution plus propre serait d'appliquer le principe RAII.

**Goten** · 28/11/2008, 16h23

D'accord pour cette méthode. Je vais approfondir l'idiome du RAII (je n'est vu que les grandes lignes pour l'instant) pour l'intégrer à cette class... ça me fera un bon entrainement. Merci

**Goten** · 29/11/2008, 15h10

Est ce qu'une implémentation du RAII tel quelle suffirait :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
template <class T>
class autoDelete
{
    public :
    autoDelete (T *ptr = 0) : pData(ptr) {}
    ~autoDelete () { delete pData; }
 
    private :
 
    T *pData;
};

Seulement je vois pas réellement en quoi ça contournerait le problème :

est ce que un :

Code :

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

autoDelete autoDel(data);

dans le constructeur de mon vector remplirait bien l'affaire.?

Au moins comme ça j'apprends un peu plus sur le RAII..

**Médinoc** · 29/11/2008, 15h46

Dans l'état actuelle, ta classe est dangereuse. Tu dois soit gérer la copie, soit l'interdire.

**Goten** · 29/11/2008, 16h01

Tu parles bien de la class autoDelete? Je suis pas sur de comprendre pourquoi ne pas interdire la copie de la class autoDelete est dangereux? pourrait tu donner un exemple qui tournerai à la catastrophe?

Pour répondre à la problèmatique que tu poses je comprends comment l'interdire:
hérité d'une class nonCopiable qui implémenterait son constructeur de recopie et l'opérateur d'affectation en privée.

Pour la gérer je ne vois pas de solution n'ayant pas encore la réponse à la question de la dangerosité ^^.

**Médinoc** · 29/11/2008, 16h33

Code C++ :

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

1
2
3
4
5
6
7
8
9
void UneFonction()
{
	int pi = new int;
	autodelete ad1(pi);
 
	autodelete ad2(ad1);
 
	//Boum! pi est deleté deux fois!
}

Pour interdire la copie, généralement je mets directement un constructeur de copie et un opérateur d'affectation privés et non-définis, je ne passe jamais par une classe spéciale pour ça.

Quant à la gérer, il n'y a pas trente-six solutions: Absorption de la ressource, comptage de références non-intrusif, ou copie complète.

**Goten** · 29/11/2008, 16h49

hum... dans un premier temps je pense me limiter à l'interdire... ne sachant même pas ce qu'est l'absorption de ressources...

La classe mettant en oeuvre le RAII deviendrait donc :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
template <class T>
class autoDelete
{
    public :
    autoDelete (T *ptr = 0) : pData(ptr) {}
    ~autoDelete () { delete pData; }
 
    private :
    autoDelete(const autoDelete&);
    autoDelete& operator=(const autoDelete&);
 
    T *pData;
};

**Médinoc** · 29/11/2008, 16h55

C'est parfait, tu as maintenant l'équivalent basique d'un boost::scoped_ptr<>.
La seule chose, c'est que je serais du genre à ajouter une fonction detach(), et une seconde version de la classe pour les tableaux (scoped_array<>)

**Goten** · 29/11/2008, 17h11

Une question avant d'aller plus loin :

dans le template vector de la STL est-ce que c'est la classe vector_base (dont hérite vector) qui implémente le RAII?

**Sylvain Togni** · 08/12/2008, 17h12

Cela dépend de l'implémentation. La STL fournie avec VC++ par exemple utilise des try/catch, tandis que celle fournie avec gcc implémente le RAII.

Ce qu'il faut bien comprendre avec le RAII c'est qu'une classe ne doit s'occuper que d'une seule ressource à la fois. Hors dans le cas d'une classe vector il y a deux ressources (au sens large du terme) à gérer : la gestion de la mémoire et la construction/destruction des objets. Les mettre dans deux classes séparées permet une implémentation plus propre, en se passant notamment de try/catch.

C'est ce qui est fait dans la STL de gcc, où la gestion de la mémoire est laissée à une classe de base.

**Goten** · 08/12/2008, 17h54

Hum d'accord... j'ai lu un papier de BS justement la dessus entre temps. Il arrivait au final à une implémentation de la stl très proche de celle de la stl. Mais je suis encore entrain d'étudier car il y'a quelques passages notemment de la classe vector_base que je comprends pas.

pour information le papier en question :
http://www.research.att.com/~bs/except.pdf

Exercice : création d'une classe vector std-like

C++

Discussions similaires

Partager

Partager