Discussion :

[kayzra]

Bonjour, j'apprend la programmation en autodidacte et j'ai pas mal de difficultés avec les pointeurs de C/C++, si j'avais appris un de ces 2 langages en 1er je m'y serais surement fais à la longue... Mais voilà c'est java que je pratique depuis 1 an!

Je souhaiterai savoir si il est indispensable de maîtriser les pointers pour faire du C++ ou si dans un premier temps on peut s'en passer, voir ne jamais les utiliser ?

[Pacorabanix]

euhh... en java tu arrives à te passer de pointeurs complètement ?



Pour répondre directement : oui, tu peux *dasn un premier temps* te passer des pointeurs. Mais ce serait comme acheter une voiture de course pour rouler toujours à 10 km/h ....


Les pointeurs permettent des manipulations assez complexes et qui seraient très lourdes autrement (voire impossible je pense pour certaines).

Ex : tu as un objet instancié. Avec des méthodes, des propriétés, des données internes, etc... Si tu as besoin de le manipuler, de le passer à des fonctions en paramètre, etc... c'est bien plus agréable d'avoir un pointeur vers cet objet (simple variable numérique, très petite), que de manipuler une copie complète de l'objet à chaque fois.


De plus, c'est le seul moyen d'allouer dynamiquement de la mémoire ! Or il arrive quand meme fréquemment en programmation que tu ne saches pas forcément combien (ni quoi) créer pendant la compilation.

[yakamoneye]

"les pointeurs", y'a que le nom qui fait peur une fois que tu as compris comment cela foctionne le code s'ecrit tout seul ...enfin presque
http://cpp.developpez.com/cours/polyCpp/
et au pire tu est sur le bon site si tu as des doutes ou des questions, c'est ici que je resout la majorité de mes petits soucis.

[Luc Hermitte]

En utilisant les structures qui vont bien (std::vector<>, std::string, boost::shared_ptr<>), tu peux les masquer en grande partie.
Mais seulement en C++, pas en C.

[ram-0000]

C'est vrai qu'en java, la notion de pointeur n'existe pas. Par contre, la notion de référence existe et une référence n'est jamais qu'un pointeur qui se déguise un peu.

Je pense que dans un premier temps, on peu s'en passer mais que très vite, on se rend compte que c'est utile pour réaliser des choses un peu plus puissantes.

[kayzra]

En fait mon plus gros soucis est que j'ai tendance à faire du C++ avec les règle du java.
exemple :je me limite par habitude à la transmission par valeur pour les types de bases (comme avec java) alors que je pourrais aussi le faire par référence !

En fait peut on faire du C++ avec les règles de Java?

[ram-0000]

Il ya a certains passages par valeurs qui coûtent très cher car il faut créer/copier un nouvel objet sur la pile avec appel des constructeur de copie et des destructeurs en final sans compter la place inutile occupée sur la pile.

Par principe, dès que je sais qu'un objet fait plus de 4 octets (c'est donc un objet relativement complexe à construire), j'essaie de la passer par référence constante.

[Davidbrcz]

Je ne parlerais que pour le C++.

Pour moi la réponse est mitigé.
On peut si on utilise de bon outils dès le début, s'en sortir sans trop (rien ?) connaitre aux pointeurs.

Mais il y un moment où malgré nes outils, les pointeurs sont une obligation.

[MatteX]

En fait mon plus gros soucis est que j'ai tendance à faire du C++ avec les règle du java.
exemple :je me limite par habitude à la transmission par valeur pour les types de bases (comme avec java) alors que je pourrais aussi le faire par référence !

En fait peut on faire du C++ avec les règles de Java?

Oui mais il faut comprendre les différences : Java par défaut c'est du passage par référence sauf si la fonction modifie l'objet alors se sera automatiquement par valeur. À moins bien sur que le paramètre ai été explicitement déclaré en référence bien sur*.

Java fait ce genre d'optimisation automatiquement : pas C++.

En C++ on doit toujours explicitement passer nos objets en référence constantes (C'est une bonne habitude). Sauf en cas de manipulation des valeurs dans l'environnement local -> passage par valeur et de manipulation de l'objet dans l'environnement extérieur -> passage par référence.

Le seul moment où les pointeurs doivent être utilisés c'est pour la création, la conservation et l'utilisation de mémoire réservée dynamiquement... Ensuite les fonctions appelées peuvent utiliser des références constantes sur l'objet. Tant qu'on conserve l'adresse à un endroit logique pour pouvoir la libérer. En plus, c'est sécuritaire à l'utilisation.

Dès qu'on parle de quelque chose instancié ou utilisé dynamiquement on a besoin des pointeurs (ex. polymorphisme)

[kayzra]

Merci pour toute vos réponses elles m'éclairent beaucoup sur les principes du C++ comparais à java.

j'aurais une autre question, C++ étant plus souple au sens des règles d'écritures et à de la possibilité d'atteindre beaucoup + facilement le système qu'avec une machine virtuelle, y a -t-il des règles de base à respecter ou des choses à éviter ?

[Luc Hermitte]

Oui mais il faut comprendre les différences : Java par défaut c'est du passage par référence sauf si la fonction modifie l'objet alors se sera automatiquement par valeur.

Quoi ?
Java ne connait qu'un seul passage de paramètre, c'est par valeur -- ecrivez donc un swap en Java.
Le truc est que les références sont passées par valeur. Les références du java sont des sortes de super-pointeur, alors que celles du C++ ne sont que des alias.
Bref, en Java, c'est exactement comme en C, pour les passages de paramètres.

(Bon, maintenant, des choses ont pu changer depuis Java 5, j'ai moins bien suivi)


Sinon, oui, il y a énormément de choses à savoir. En faire la liste ... là, comme ça ? Non.
Commence par jeter un oeil à la FAQ, puis aux (More) Effective C++ et (More) eXceptional C++ (www.gotw.ca/gotw/). Quand tu auras assimilé tout cela, cela sera déjà pas mal.

[koala01]

Salut,

Pour répondre à ta première question, je dirais que, si tu décide d'utiliser les classes de la S(T)L telles que les std::string ou les std::vector en codant "à la manière C" (comprend: en considérant tous les types personnalisés comme étant des structure de données, sans intention de travailler en "orienté objet"), il y a de fortes chances que tu n'aie pour ainsi dire jamais besoin des pointeurs.

Seulement, le revers de la médaille, c'est que du même coup, tu vas passer à côté de toutes les capacités fournies par les langages orienté objets, dont, entre autres, tout ce qui peut avoir trait à l'utilisation d'objets polymorphes.

En effet, l'utilisation d'objet polymorphes est le domaine par excellence dans lequel tu auras besoin de pointeurs.

Et comme on peut estimer qu'après avoir développé pendant un an en java, il y a de fortes chances pour que tu te sois habitué au confort que représente la POO... il est à craindre que cette approche restrictive du C++ ne te laisse vraiment sur ta faim

Par contre, il est fort vraisemblable que tu puisse le plus souvent te passer de tout ce qui est "arithmétique des pointeurs", car, sous réserve d'utiliser les classes de la S(T)L ou d'autres bibliothèques "classiques" (telles que boost, par exemple), tu pourra te contenter de l'allocation dynamique pour un seul élément polymorhpe sous une forme proche de

Code :

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

Personnage *lui=new Marsien();

voir, pourquoi pas d'un

Code :

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

1
2
3
 
/* avec tab étant un std::vector<Personnage*> */
tab.push_back(new Martien());

et, la seule chose à laquelle il te faudra songer, ce sera de libérer toi-même cette mémoire avant de perdre toute trace de l'endroit où elle se trouve. (autrement dit: de sortir de la portée de lui, ou, pour le deuxième exemple, au plus tard dans le destructeur de la classe à laquelle appartient tab).

Et puis, finalement, à bien y réfléchir, il est aussi fortement probable que, si tu éprouve du mal avec les pointeurs, c'est sans doute que tu n'as jamais trouvé le texte, ou la manière de t'expliquer qui t'aurais permis de "percuter" dessus...

Personnellement, j'ai eu "l'illumination" qui m'a permis de tout comprendre "d'un seul coup" sur les pointeurs en relisant pour la énieme fois mon cours dans le train, le jour où je présentais mon examen... de C sur les pointeurs

Pour répondre à la deuxième question, comme on peut considérer que tu as déjà un bagage certain en POO, il n'y aura vraisemblablement qu'une série d'ajustements à effectuer, certains importants, d'autres beaucoup moins, et quelques horizons à explorer

[zais_ethael]

Bon sang mais c'est quoi toutes ces bétises que j'entends sur le Java???
En Java tout est passé par réfèrence, mais cela n'a rien à voir avec les réfèrences du C++, il s'agit de réfèrences au sens d'un garbage collector. On peut donc considérer qu'une variable xxx en Java est l'équivalent d'un shared_ptr<xxx> en C++ (moins le problème des réfèrences cycliques). Néanmoins gardez à l'esprit que, bien qu'il soit utilisé par le Java et plusieurs autres langages très connus, le comptage de réfèrence n'est pas l'unique moyen d'implémenter un garbage collector.

Oui mais il faut comprendre les différences : Java par défaut c'est du passage par référence sauf si la fonction modifie l'objet alors se sera automatiquement par valeur.

Ca c'est à n'y rien comprendre, tu confonds peut-être avec les objets non mutables? En tout cas ça n'a rien à voir.

Le seul cas où le Java utilise du passage par valeur, c'est pour les types de base. Et encore, il existe des alias objet pour tous ces types au cas où on aurait besoin d'utiliser le même mode de fonctionnement que pour les objets.

[Luc Hermitte]

Que nenni.

Code :

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

1
2
3
4
5
6
7
void f(IToto toto) {
    toto = new TotoImpl();
}
 
void swap(I a, I b) {
   T c=a; a=b; b=c;
}

Par référence tu disais ....? Pourquoi cela ne marche pas alors ?

Tout, et absolument tout, est passé par valeur en Java. Parce que la référence est un type au même titre que les pointeurs en C. Les pointeurs sont passés par valeur en C, les références sont passées par valeur en Java. C'est tout.

[nikko34]

dans mes projets C++ je le résume comme ça:

1) Pas de pointeurs
( pour une donnée membre par exemple, pas besoin de faire un new dans le constructeur et un delete dans le destructeur quand tout peut être géré automatiquement )

2) Utiliser les références ( passage de paramètres etc.. )

3) Si vraiment on doit utiliser les pointeurs ( polymorphisme, etc.. ):
utiliser des smart pointers ( boost::shared_ptr )


( évidemment il y a toujours des cas où tu as besoin de pointeurs à bas niveau, ce n'est pas rigide )

[JolyLoic]

La difficulté de parler du passage d'argument en Java quand on vient du C++ vient pour moi (qui ne m'y connais pas vraiment en Java) du fait que Java mélange deux concepts : Le pointeur, et l'objet pointé.

Quand on passe un argument de fonction, on passe le pointeur par copie (donc d'une certaine manière, on passe l'objet pointé par référence).

Quand on appelle une fonction membre, c'est l'objet pointé qui est concerné.

Quand on appelle l'opérateur =, c'est le pointeur et non pas l'objet pointé qui est concerné.

Donc, un swap en Java s'écrirait :

Code :

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

1
2
3
4
5
6
void swap(I a, I b) {
   I c;
   c.clone(a);
   a.clone(b);
   b.clone(c);
}

[Médinoc]

En effet, ce que Java appelle "référence" n'a rien à voir avec le passage par référence.

En .Net, on a les deux:

• On a la distinction entre type valeur et type référence:
  
  • Un type valeur est comme les types primitifs de Java, comme int ou float (mais en .Net, on peut créer de nouveaux types valeur, ce qui est impossible en Java).
  • Un type référence est comme les classes de Java: On ne peut le créer que sur le tas (avec new), et on ne peut le manipuler que par des "références", d'où le nom.
• Et on a aussi le passage de paramètres par référence, comme en C# avec les mots-clé ref et out.

En C#, la signification d'une variable d'un certain type dépend selon que ce soit un type valeur ou un type référence:

Code C# :

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
struct UnTypeValeur
{
	public int a;
}
 
class UnTypeReference
{
	public int a;
}
 
static class Program
{
	static int Main()
	{
		//Ici, la variable objetValeur représente directement l'objet,
		//Car il est d'un type valeur.
		UnTypeValeur objetValeur;
		objetValeur.a = 42; //pas besoin de new
 
		//Ici, la variable objetReference ne représente pas l'objet,
		//mais une référence vers l'objet,
		//car il est d'un type référence.
		UnTypeReference objetReference;
		objetReference = new UnTypeReference();
		objetReference.a = 28;
 
		return 0;
	}
}

[Médinoc]

La distinction se voit mieux en C++/CLI, où les "références" .net sont appelées "handles managés" (à ne pas confondre avec les HANDLE de Windows: On manque de mots, donc on se retrouve à les réutiliser)

Code C++/CLI :

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
value class UnTypeValeur
{
public:
	int a;
};
 
ref class UnTypeReference
{
public:
	int a;
};
 
int main()
{
	//Ici, la variable objetValeur représente directement l'objet,
	//Car il est d'un type valeur.
	UnTypeValeur objetValeur;
	objetValeur.a = 42; //pas besoin de new
 
	//Ici, la variable objetReference ne représente pas l'objet,
	//mais une référence vers l'objet (un "handle managé"),
	//car il est d'un type référence.
	//Noter le '^', sans lequel il y aurait une erreur de compilation.
	UnTypeReference^ objetReference;
	objetReference = gcnew UnTypeReference();
	objetReference->a = 28;
 
	return 0;
}

[loufoque]

Je souhaiterai savoir si il est indispensable de maîtriser les pointers pour faire du C++ ou si dans un premier temps on peut s'en passer, voir ne jamais les utiliser ?

Avec les bons outils, tu n'en as jamais besoin. (Et c'est même bien de les éviter)

[Davidbrcz]

Loufoque >> Je suis d'accord avec toi. Avec de bon outils, on peut s'en passer . Mais il faut au moins les connaitres car si on doit maintenir un code qui en utilise, on est dans la loose