|
L'include de base :
1
2
3
4
5
6
7
8
9
10
11
12
13
|
#ifndef __PLIST__H__
#define __PLIST__H__
#include <list>
#include <vector>
#include "PElement.h"
#include "PIterator.h"
#include "PList_impl.h"
#endif
|
Les constructeurs et le destructeur :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
#ifndef __PLIST__H__
#define __PLIST__H__
#include <list>
#include <vector>
#include "PElement.h"
#include "PIterator.h"
template <class T>
class PList{
public:
PList();
PList(const T & el);
PList(const PList<T> & liste);
virtual ~PList();
};
#include "PList_impl.h"
#endif
|
Définition des opérateurs += :
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
|
#ifndef __PLIST__H__
#define __PLIST__H__
#include <list>
#include <vector>
#include "PElement.h"
#include "PIterator.h"
template <class T>
class PList{
public:
PList();
PList(const T & el);
PList(const PList<T> & liste);
virtual ~PList();
PList & operator = (const PList<T> & liste);
PList & operator += (const T & el);
PList & operator += (const PList<T> & liste);
};
#include "PList_impl.h"
#endif
|
Vous pouvez redéfinir les opérateurs -= si vous avez envie.
Normaliser la liste :
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
|
#ifndef __PLIST__H__
#define __PLIST__H__
#include <list>
#include <vector>
#include "PElement.h"
#include "PIterator.h"
template <class T>
class PList{
public:
PList();
PList(const T & el);
PList(const PList<T> & liste);
virtual ~PList();
PList & operator = (const PList<T> & liste);
PList & operator += (const T & el);
PList & operator += (const PList<T> & liste);
void normalise(const T & scal);
};
#include "PList_impl.h"
#endif
|
Récupérer le premier ou le dernier élément de la liste :
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
|
#ifndef __PLIST__H__
#define __PLIST__H__
#include <list>
#include <vector>
#include "PElement.h"
#include "PIterator.h"
template <class T>
class PList{
public:
PList();
PList(const T & el);
PList(const PList<T> & liste);
virtual ~PList();
PList & operator = (const PList<T> & liste);
PList & operator += (const T & el);
PList & operator += (const PList<T> & liste);
void normalise(const T & scal);
T front() const;
T back() const;
};
#include "PList_impl.h"
#endif
|
On renvoie des copies pour être sûre que la PList soit constante.
Récupérer un élément suivant sa position dans la liste :
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
|
#ifndef __PLIST__H__
#define __PLIST__H__
#include <list>
#include <vector>
#include "PElement.h"
#include "PIterator.h"
template <class T>
class PList{
public:
PList();
PList(const T & el);
PList(const PList<T> & liste);
virtual ~PList();
PList & operator = (const PList<T> & liste);
PList & operator += (const T & el);
PList & operator += (const PList<T> & liste);
void normalise(const T & scal);
T front() const;
T back() const;
T getAt(size_t index) const;
};
#include "PList_impl.h"
#endif
|
Changer la valeur d'un élément :
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
|
#ifndef __PLIST__H__
#define __PLIST__H__
#include <list>
#include <vector>
#include "PElement.h"
#include "PIterator.h"
template <class T>
class PList{
public:
PList();
PList(const T & el);
PList(const PList<T> & liste);
virtual ~PList();
PList & operator = (const PList<T> & liste);
PList & operator += (const T & el);
PList & operator += (const PList<T> & liste);
void normalise(const T & scal);
T front() const;
T back() const;
T getAt(size_t index) const;
void setAt(const T & value, size_t index);
};
#include "PList_impl.h"
#endif
|
L'opérateur [] :
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
|
#ifndef __PLIST__H__
#define __PLIST__H__
#include <list>
#include <vector>
#include "PElement.h"
#include "PIterator.h"
template <class T>
class PList{
public:
PList();
PList(const T & el);
PList(const PList<T> & liste);
virtual ~PList();
PList & operator = (const PList<T> & liste);
PList & operator += (const T & el);
PList & operator += (const PList<T> & liste);
void normalise(const T & scal);
T front() const;
T back() const;
T getAt(size_t index) const;
void setAt(const T & value, size_t index);
T operator [] (size_t index) const;
T & operator [] (size_t index);
};
#include "PList_impl.h"
#endif
|
Les fonctions qui renvoient les PIterator pour aller à l'endroit ou à l'envers :
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
|
#ifndef __PLIST__H__
#define __PLIST__H__
#include <list>
#include <vector>
#include "PElement.h"
#include "PIterator.h"
template <class T>
class PList{
public:
PList();
PList(const T & el);
PList(const PList<T> & liste);
virtual ~PList();
PList & operator = (const PList<T> & liste);
PList & operator += (const T & el);
PList & operator += (const PList<T> & liste);
void normalise(const T & scal);
T front() const;
T back() const;
T getAt(size_t index) const;
void setAt(const T & value, size_t index);
T operator [] (size_t index) const;
T & operator [] (size_t index);
PIterator<T> begin() const;
PIterator<T> end() const;
PIterator<T> rbegin() const;
PIterator<T> rend() const;
};
#include "PList_impl.h"
#endif
|
Les fonctions qui ajoutent un élément au début ou à la fin de la liste :
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
|
#ifndef __PLIST__H__
#define __PLIST__H__
#include <list>
#include <vector>
#include "PElement.h"
#include "PIterator.h"
template <class T>
class PList{
public:
PList();
PList(const T & el);
PList(const PList<T> & liste);
virtual ~PList();
PList & operator = (const PList<T> & liste);
PList & operator += (const T & el);
PList & operator += (const PList<T> & liste);
void normalise(const T & scal);
T front() const;
T back() const;
T getAt(size_t index) const;
void setAt(const T & value, size_t index);
T operator [] (size_t index) const;
T & operator [] (size_t index);
PIterator<T> begin() const;
PIterator<T> end() const;
PIterator<T> rbegin() const;
PIterator<T> rend() const;
bool pushBack(const T & el);
bool pushBack(const PList<T> & liste);
bool pushFront(const T & el);
bool pushFront(const PList<T> & liste);
};
#include "PList_impl.h"
#endif
|
Les fonctions qui dégomment le premier élément ou le dernier élément :
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
|
#ifndef __PLIST__H__
#define __PLIST__H__
#include <list>
#include <vector>
#include "PElement.h"
#include "PIterator.h"
template <class T>
class PList{
public:
PList();
PList(const T & el);
PList(const PList<T> & liste);
virtual ~PList();
PList & operator = (const PList<T> & liste);
PList & operator += (const T & el);
PList & operator += (const PList<T> & liste);
void normalise(const T & scal);
T front() const;
T back() const;
T getAt(size_t index) const;
void setAt(const T & value, size_t index);
T operator [] (size_t index) const;
T & operator [] (size_t index);
PIterator<T> begin() const;
PIterator<T> end() const;
PIterator<T> rbegin() const;
PIterator<T> rend() const;
bool pushBack(const T & el);
bool pushBack(const PList<T> & liste);
bool pushFront(const T & el);
bool pushFront(const PList<T> & liste);
bool popBack();
bool popFront();
};
#include "PList_impl.h"
#endif
|
La fonction qui efface toute la liste :
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
|
#ifndef __PLIST__H__
#define __PLIST__H__
#include <list>
#include <vector>
#include "PElement.h"
#include "PIterator.h"
template <class T>
class PList{
public:
PList();
PList(const T & el);
PList(const PList<T> & liste);
virtual ~PList();
PList & operator = (const PList<T> & liste);
PList & operator += (const T & el);
PList & operator += (const PList<T> & liste);
void normalise(const T & scal);
T front() const;
T back() const;
T getAt(size_t index) const;
void setAt(const T & value, size_t index);
T operator [] (size_t index) const;
T & operator [] (size_t index);
PIterator<T> begin() const;
PIterator<T> end() const;
PIterator<T> rbegin() const;
PIterator<T> rend() const;
bool pushBack(const T & el);
bool pushBack(const PList<T> & liste);
bool pushFront(const T & el);
bool pushFront(const PList<T> & liste);
bool popBack();
bool popFront();
void clear();
};
#include "PList_impl.h"
#endif
|
Les fonctions qui effacent un élément :
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
|
#ifndef __PLIST__H__
#define __PLIST__H__
#include <list>
#include <vector>
#include "PElement.h"
#include "PIterator.h"
template <class T>
class PList{
public:
PList();
PList(const T & el);
PList(const PList<T> & liste);
virtual ~PList();
PList & operator = (const PList<T> & liste);
PList & operator += (const T & el);
PList & operator += (const PList<T> & liste);
void normalise(const T & scal);
T front() const;
T back() const;
T getAt(size_t index) const;
void setAt(const T & value, size_t index);
T operator [] (size_t index) const;
T & operator [] (size_t index);
PIterator<T> begin() const;
PIterator<T> end() const;
PIterator<T> rbegin() const;
PIterator<T> rend() const;
bool pushBack(const T & el);
bool pushBack(const PList<T> & liste);
bool pushFront(const T & el);
bool pushFront(const PList<T> & liste);
bool popBack();
bool popFront();
void clear();
bool erase(PIterator<T> & it);
bool erase(int index);
};
#include "PList_impl.h"
#endif
|
La fonction qui renvoie la taille de la liste :
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
|
#ifndef __PLIST__H__
#define __PLIST__H__
#include <list>
#include <vector>
#include "PElement.h"
#include "PIterator.h"
template <class T>
class PList{
public:
PList();
PList(const T & el);
PList(const PList<T> & liste);
virtual ~PList();
PList & operator = (const PList<T> & liste);
PList & operator += (const T & el);
PList & operator += (const PList<T> & liste);
void normalise(const T & scal);
T front() const;
T back() const;
T getAt(size_t index) const;
void setAt(const T & value, size_t index);
T operator [] (size_t index) const;
T & operator [] (size_t index);
PIterator<T> begin() const;
PIterator<T> end() const;
PIterator<T> rbegin() const;
PIterator<T> rend() const;
bool pushBack(const T & el);
bool pushBack(const PList<T> & liste);
bool pushFront(const T & el);
bool pushFront(const PList<T> & liste);
bool popBack();
bool popFront();
void clear();
bool erase(PIterator<T> & it);
bool erase(int index);
size_t size() const;
};
#include "PList_impl.h"
#endif
|
Les fonctions de conversion en std::list et en std::vector :
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
|
#ifndef __PLIST__H__
#define __PLIST__H__
#include <list>
#include <vector>
#include "PElement.h"
#include "PIterator.h"
template <class T>
class PList{
public:
PList();
PList(const T & el);
PList(const PList<T> & liste);
virtual ~PList();
PList & operator = (const PList<T> & liste);
PList & operator += (const T & el);
PList & operator += (const PList<T> & liste);
void normalise(const T & scal);
T front() const;
T back() const;
T getAt(size_t index) const;
void setAt(const T & value, size_t index);
T operator [] (size_t index) const;
T & operator [] (size_t index);
PIterator<T> begin() const;
PIterator<T> end() const;
PIterator<T> rbegin() const;
PIterator<T> rend() const;
bool pushBack(const T & el);
bool pushBack(const PList<T> & liste);
bool pushFront(const T & el);
bool pushFront(const PList<T> & liste);
bool popBack();
bool popFront();
void clear();
bool erase(PIterator<T> & it);
bool erase(int index);
size_t size() const;
std::list<T> toStdList() const;
std::vector<T> toStdVector() const;
};
#include "PList_impl.h"
#endif
|
Les opérateurs amis de la classe PList :
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
|
#ifndef __PLIST__H__
#define __PLIST__H__
#include <list>
#include <vector>
#include "PElement.h"
#include "PIterator.h"
template <class T>
class PList{
public:
PList();
PList(const T & el);
PList(const PList<T> & liste);
virtual ~PList();
PList & operator = (const PList<T> & liste);
PList & operator += (const T & el);
PList & operator += (const PList<T> & liste);
void normalise(const T & scal);
T front() const;
T back() const;
T getAt(size_t index) const;
void setAt(const T & value, size_t index);
T operator [] (size_t index) const;
T & operator [] (size_t index);
PIterator<T> begin() const;
PIterator<T> end() const;
PIterator<T> rbegin() const;
PIterator<T> rend() const;
bool pushBack(const T & el);
bool pushBack(const PList<T> & liste);
bool pushFront(const T & el);
bool pushFront(const PList<T> & liste);
bool popBack();
bool popFront();
void clear();
bool erase(PIterator<T> & it);
bool erase(int index);
size_t size() const;
std::list<T> toStdList() const;
std::vector<T> toStdVector() const;
friend PList & operator << (PList<T> & liste, const T & el){
liste.pushBack(el);
return liste;
}
friend PList & operator << (PList<T> & liste, const PList<T> & list){
liste.pushBack(list);
return liste;
}
friend std::ostream & operator << (std::ostream & out, const PList<T> & list){
if(list.p_size == 0) return out;
for(PIterator<T> it(list.begin()); it != list.end(); ++it){
out << *it << ", ";
}
return out;
}
};
#include "PList_impl.h"
#endif
|
La fonction d'initialisation et la fonction de copie :
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
|
#ifndef __PLIST__H__
#define __PLIST__H__
#include <list>
#include <vector>
#include "PElement.h"
#include "PIterator.h"
template <class T>
class PList{
public:
PList();
PList(const T & el);
PList(const PList<T> & liste);
virtual ~PList();
PList & operator = (const PList<T> & liste);
PList & operator += (const T & el);
PList & operator += (const PList<T> & liste);
void normalise(const T & scal);
T front() const;
T back() const;
T getAt(size_t index) const;
void setAt(const T & value, size_t index);
T operator [] (size_t index) const;
T & operator [] (size_t index);
PIterator<T> begin() const;
PIterator<T> end() const;
PIterator<T> rbegin() const;
PIterator<T> rend() const;
bool pushBack(const T & el);
bool pushBack(const PList<T> & liste);
bool pushFront(const T & el);
bool pushFront(const PList<T> & liste);
bool popBack();
bool popFront();
void clear();
bool erase(PIterator<T> & it);
bool erase(int index);
size_t size() const;
std::list<T> toStdList() const;
std::vector<T> toStdVector() const;
friend PList & operator << (PList<T> & liste, const T & el){
liste.pushBack(el);
return liste;
}
friend PList & operator << (PList<T> & liste, const PList<T> & list){
liste.pushBack(list);
return liste;
}
friend std::ostream & operator << (std::ostream & out, const PList<T> & list){
if(list.p_size == 0) return out;
for(PIterator<T> it(list.begin()); it != list.end(); ++it){
out << *it << ", ";
}
return out;
}
private:
void intialisationPList();
void copyPList(const PList<T> & liste);
};
#include "PList_impl.h"
#endif
|
Et enfin les attributs de la classe PList :
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
|
#ifndef __PLIST__H__
#define __PLIST__H__
#include <list>
#include <vector>
#include "PElement.h"
#include "PIterator.h"
template <class T>
class PList{
public:
PList();
PList(const T & el);
PList(const PList<T> & liste);
virtual ~PList();
PList & operator = (const PList<T> & liste);
PList & operator += (const T & el);
PList & operator += (const PList<T> & liste);
void normalise(const T & scal);
T front() const;
T back() const;
T getAt(size_t index) const;
void setAt(const T & value, size_t index);
T operator [] (size_t index) const;
T & operator [] (size_t index);
PIterator<T> begin() const;
PIterator<T> end() const;
PIterator<T> rbegin() const;
PIterator<T> rend() const;
bool pushBack(const T & el);
bool pushBack(const PList<T> & liste);
bool pushFront(const T & el);
bool pushFront(const PList<T> & liste);
bool popBack();
bool popFront();
void clear();
bool erase(PIterator<T> & it);
bool erase(int index);
size_t size() const;
std::list<T> toStdList() const;
std::vector<T> toStdVector() const;
friend PList & operator << (PList<T> & liste, const T & el){
liste.pushBack(el);
return liste;
}
friend PList & operator << (PList<T> & liste, const PList<T> & list){
liste.pushBack(list);
return liste;
}
friend std::ostream & operator << (std::ostream & out, const PList<T> & list){
if(list.p_size == 0) return out;
for(PIterator<T> it(list.begin()); it != list.end(); ++it){
out << *it << ", ";
}
return out;
}
private:
void intialisationPList();
void copyPList(const PList<T> & liste);
///PElement qui permet d'accéder au autres
PElement<T> p_handle;
///nombre d’éléments de la PList
size_t p_size;
};
#include "PList_impl.h"
#endif
|
Voilà pour le fichier PList.h.
|