Discussion :

[persé]

Bonjour ;

ma question est dans le titre, est ce que on peut développer sans avoir recours aux pointeurs, je viens de l'environnement java " la ou y'a pas de pointeurs"
j'ai eu un projet en c++ j'ai bossé dessus en utilisant les vectors.

est ce que c'est une obligations , et quel sont les avantage de l'utilisation des pointeurs.

Merci d'avance.

[Invité]

Oui il y a moyen, il suffise que tu n'utilises que des références. (Comme en java quoi, et rien allouer sur le tas en dehors de classes)
Je pense que java n'utilise que des pointeurs constant.

Et tu dois t'arranger pour convertir ce qui est alloué avec new en pointeur constant pour le passer à la référence.

[TiranusKBX]

Tu peut très bien faire des programmes complexes en C++ sans utiliser de pointeur mais pour ce faire
tu doit utiliser une lib qui te ferais ce genre de manipulation perso pour des liste j'utilise du Qt en C++
mais à toi de voir qu'elle lib tu veut utiliser

[ternel]

Les pointeurs sont dans l'âme de C++, qu'ils soient pleinement visibles, encapsulé dans les smart pointers, ou remplacé par des références.

Le fait de manipuler une valeur via plusieurs noms est nécessaire.
Et le fait que le polymorphisme ne soit accessible que via les références et pointeurs est une autre raison.

En C++, les références seront tes meilleures amies, bien plus que les pointeurs, en temps général.

Il faut bien voir qu'en Java, tu n'as que des pointeurs (sauf type de base), ce qui permet de s'affranchir des notations & et *.
Ce n'est pas pour rien que chaque valeur est créée via new.

En C++, tu va pouvoir créer des valeurs directement dans la pile.

[the Hound]

Techniquement oui, il est possible de développer des projets entiers sans toucher aux pointeurs.

Mais si par "développer [...] en C++" tu entends développer "en général", càd pas dans le cadre d'un projet spécifique, c'est plus compliqué ...
Je considère que développer ce n'est pas seulement savoir écrire du code mais aussi le lire, et arrivera tôt ou tard (très tôt je pense) le moment où tu auras besoin de comprendre un code faisant usage de pointeurs.

[ternel]

est ce que c'est une obligations , et quel sont les avantage de l'utilisation des pointeurs.

Le pointeur permet des choses un peu particulière:

Le pointeur de fonction, qui permet de ne pas créer une classe autour de la fonction, et un objet de cette classe.
Même si on lui préfère une classe surchargeant l'opérateur (), ce qu'on appelle un foncteur.

Les sous tableaux. En effet, un tableau est presque un pointeur, et un pointeur peut être manipulé comme un tableau
Ainsi, si int tab[] = {0, 1, 2, 3, 4, 5}; déclare un tableau de six entiers, tab est un aussi un pointeur vers le premier élément, et tab+1 un pointeur vers le second.

Du coup, il est possible de donner tab+1 et tab+4 comme argument à la fonction suivante:

Code :

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

1
2
3
4
5
6
7
8
//somme de begin à end (exclus)
int sum_range(int *begin, int *end) {
    int sum= 0;
    for (int * p = begin, p < end; ++p) {
        sum += *p;
    }
    return sum;
}

Stocker des objets dans une collection, en préservant le polymorphisme.
un vector<Vehicule> découpera chaque Voiture en Vehicule lors de l'insertion (slicing)
tandis qu'un vector<Vehicule*> demandera d'être attentif à la mémoire (il faudra savoir quand faire un delete, si les pointeurs sont obtenus par new), mais une Voiture sera correctement manipulée.


Pour te rassurer, j'ai déjà codé des applications sans utiliser de pointeur du tout, seulement des références. Et sans bibliothèques type Qt.
Il ne faut pas en avoir peur, il faut juste comprendre ce qu'ils sont, ce qu'ils permettent, et comment ils se manipulent.
Il existe d'ailleurs un petit tuto sur le sujet: les pointeurs en C et C++

[Bousk]

Salut,

JAVA t'a toujours menti, c'est pas qu'il n'y a "pas de pointeur", mais qu'il y a "que des pointeurs".
Seulement ils sont cachés, et par-dessus tout ça on rajoute un garbage collector pour faire ton boulot (création, libération, durée de vie, qui est propriétaire, ..).

Un pointeur ça devient obligatoire dans un cas simple, et qui survient finalement assez souvent : garder un objet en vie hors scope, via le tas (la HEAP).

[stendhal666]

Pourquoi te poses-tu cette question-là?

Si c'est parce que les pointeurs te semblent ardus, mieux vaut ne pas te lancer dans le C++, parce que ce n'est vraiment pas le point le plus difficile du langage...

De plus, si, comme d'autres l'ont souligné, il est techniquement possible de se passer de pointeurs en utilisant les références, les deux ne sont pas interchangeables et les références ont leur propre complexité (surtout depuis c++11 et les rvalue references).

Enfin, un des intérêts du C++ est de pouvoir manipuler des librairies anciennes, entre autres des librairies C, dans lesquelles les pointeurs sont un passage obligé.

P.S: les pointeurs, ce n'est pas si compliqué...

[Invité]

En c++14 je pense que il n'y a même plus de pointeurs, tout est géré en interne avec des classes comme par exemple std::unique_ptr et son compagnon std::make_unique.

Pour les tableau statiques il y a std::array qui encapsule aussi tout ça, et std::vector pour les tableaux dynamique.

Pour les pointeurs de fonctions il y a std::function et son compagnon std::bind.

Et il y a std::reference_wrapper si tu ne veux pas stocker des pointeurs dans une liste mais des références. (En général j'évite les rvalue et je préfère faire un wrapper qui me permet de tout stocker (références, pointeurs, et simple valeurs))

Code cpp :

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
 
template<class T>
struct IRefVal {
	IRefVal()=default;
	virtual T& get() =0;
	virtual IRefVal* clone() const = 0;
	virtual void set(const T& v) = 0;
	virtual ~IRefVal(){}
 
protected:
	IRefVal(const IRefVal&){}
	IRefVal& operator=(const IRefVal&)
	{ return *this; }
};
 
template<class T>
struct Ref : IRefVal<T> {
	Ref(const std::reference_wrapper<T>& r)
		: ref(r)
	{}
	T& get()
	{ return ref.get(); }
	IRefVal<T>* clone() const
	{ return Ref<T>(*this); }
    void set(const T& v) {
        ref = v;
    }
private:
	std::reference_wrapper<T> ref;
};
 
template<class T>
struct Val : IRefVal<T> {
	Val(const T& t)
		: val(t)
	{}
    void set(const T& v) {
        val = v;
    }
	T& get()
	{ return val; }
	IRefVal<T>* clone() const
	{ return new Val(*this); }
 
private:
	T val;
};
template<class T>
struct Pointer : IRefVal<T> {
	Pointer(const T* t)
		: val(t)
	{}
    void set(const T& v) {
        val = &v;
    }
	T& get()
	{ return val; }
	IRefVal<T>* clone() const
	{ return new Pointer<T>(*this); }
 
private:
	T val;
};
template<class T>
struct RefVal {
    RefVal() = default;
	RefVal(const T& t)
	{
        rv = new Val<T>(t);
	}
	RefVal(const std::reference_wrapper<T>& r)
	{
        rv = new Ref<T>(r);
	}
	RefVal(const T*& p)
	{
        rv = new Pointer<T>(p);
	}
	RefVal(const RefVal& rhs)
    {
        rv = rhs.rv->clone();
    }
	RefVal& operator=(const RefVal& rhs)
	{ rv=rhs.rv->clone(); return *this; }
	void operator= (const T& t) {
        rv->set(t);
	}
	T& get() const
	{ return rv->get(); }
 
private:
	IRefVal<T>* rv;
};

Et encore là je n'ai pas utilisé std::unique_ptr.
Au niveau mémoire tu n'as donc plus rien à gérer et tu peux te passer facilement des pointeurs, sinon, pour le c++ plus ancien et le c, là tu es obligé d'utiliser des pointeurs si tu as besoin que les variables soient aussi accessible en dehors du bloc dans lequel elles sont déclarée. (et pour le polymorphisme également)

Les pointeurs n'ont donc plus qu'à être déclaré et il faut juste savoir ce que c'est et qu'il permettent de faire, il n'y a plus vraiment de manipulations de pointeurs en c++14 je trouve.

[ternel]

Bref, tu dis qu'il n'y en a plus, mais qu'il faut quand même en déclarer.

La meilleure réponse n'est pas "c'est caché", mais "il faut comprendre comment ils fonctionnent et comment ne pas les utiliser directement".

On est tous d'accord pour dire que faire n'importe quoi avec les pointeurs, c'est se faire du mal pour rien.
Par contre, plus on comprend les pointeurs, plus ils sont utiles.

[the Hound]

[...]
Les pointeurs n'ont donc plus qu'à être déclaré et il faut juste savoir ce que c'est et qu'il permettent de faire, il n'y a plus vraiment de manipulations de pointeurs en c++14 je trouve.

Mouais ... unique_ptr c'est un type pointeur aussi hein, mais encapsulé dans une classe ... pointeur ne veut pas forcément dire pointeur natif.
Ces types (unique_ptr, shared_ptr, weak_ptr) sont très semblables dans l'utilisation et la sémantique aux pointeurs natifs, avec des particularités pour chacun d'eux, mais globalement, qu'on fasse : *p quand p est un unique_ptr<int> ou *p quand p est int*, c'est grosso modo la même chose. Or c'est justement l'utilisation et la sémantique des pointeurs qui rebutent les débutants ...
(Au passage, même si on ne gère plus directement la mémoire (pas d'allocation ou de libération de la mémoire 'explicite'), les pointeurs 'encapsulés' rajoutent même une valeur sémantique à la donnée pointée, par rapport à un pointeur natif : un passage de paramètre via unique_ptr a sémantiquement la valeur de transfert de propriété (de l'objet), càd que la fonction qui attend ce pointeur 'possède' l'objet pointé. Pas sûr que ça simplifie la compréhension ...)

[Médinoc]

Meilleure question: Est ce que on peut développer sans utiliser des pointeurs nus en c++?
La réponse est probablement oui.

[ternel]

Je suis totalement d'accord avec toi.
Mais ça n'empêche pas qu'il faut comprendre ce qu'est un pointeur.

Je mets le pointeur nu avec la macro (hors constante) et volatile: si je ne vois pas une très bonne raison de l'utiliser, je m'en passe.

[_zzyx_]

Pour débuter tu ne couperas pas forcément aux pointeurs, car les techniques pour les habiller ne sont pas forcément évidentes pour un débutant (et surtout tu trouvera 100 tutos sur les poineturs nus, et un sur comment les habiller)

Justes quelques points :

* Il y a un mythe autour de la difficulté des pointeurs car souvent tu galères à comprendre à quoi ca sert, pourquoi il faut s'embetter avec des * et des & et puis un jour ca te semble tellement simple que ca te parrait naturel et que t'arrives pas à l'expliquer.

* Les pointeurs, ca permet de faire pleins choses moches. Donc quand tu peux éviter évites (par exemple un passage par référence). Des l'instant ou tu commence à jouer avec des new et a retourner/passer des pointeurs, il faut que tu saches qui sera responsable d'effacer le pointeur (Risque de fuite de mémoire, risque de lire/écrire des objets effacés)

* Pour éviter ca, il y a des techniques pour "habiller" les pointeurs. En gros tu as un pointeur nu qui est crée dans une classe et qui y reste. avec la norme cpp11 tu as des objets standard pour "habiller" un pointeur voir l'effacer lorsque la dernière copie est détruite.

* Même si tu n'utilises pas de pointeurs ça ne te dispense pas d'avoir constructeur et destructeurs (Imaginons une classe qui est l'interface sur un flux d'entrée sortie, il faudra que le destructeur écrive les données et ferme les fichiers). C'est une évidence mais ça va mieux en le disant

[ternel]

Je rajoute un mot clé pour t'aider par la suite: RAII, qui consiste à créer quelque chose dans un destructeur, et le libérer dans le destructeur.

RAII s'applique à beaucoup de chose: les connexions à une base de donnée, les fichiers (les std::fstream), les chaines de caractères (std::string), les listes et autres vecteurs, et bien sûr, les pointeurs eux-mêmes (avec les nouveaux std::unique_ptr et std::shared_ptr)

Comprendre RAII (et l'utiliser) est pour moi la partie la plus importante de C++.

En très résumer, là ou en java, on utilise un try-with et closeable, ou encore le try-finally

Code :

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

1
2
3
4
5
6
7
8
void fonction() {
    Bidule bidule = new Bidule(...);
    try {
       //...
    } finally {
        bidule.close();
    }
}

En C++, on aura ceci:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Bidule {
private:
    Ressource ressource;
public:
    Bidule(...) : ressource(...) {}
    ~Bidule() {
        //libération de ressource;
    }
};
 
void fonction() {
    Bidule bidule(...)
    //...
}

Il n'y a aucun code de gestion à écrire dans le code utilisateur.
C'est la manière la plus sure qui soit de protéger une ressource.

La "magie" étant que puisque la variable bidule est locale à la fonction, son destructeur sera appelé dès qu'on quittera la fonction, par un return ou par une exception, ou tout autre moyen.

C'est aussi valable dans une boucle, ou même une paire d'accolades faites justement pour limiter la portée (scope) de la variable.