1. bonjour les kheys.

J'ai compris ce que c'est qu'un pointeur mais dans quel cas dois-en utiliser?
vous n'aurez pas un exo à me donner pour que je puisse l'appliquer.

Un cas très simple : Une fonction qui donne plusieurs valeurs, bah le problème c'est qu'une fonction a une seule valeur de renvoi. Si tu passes des pointeurs en paramètre de la fonction, ça te permet d'y écrire les valeurs de retour si on veut. Imaginons une fonction qui donne l'aire et le périmètre d'un rectangle en fonction des longueurs des côtés (a et b), ça donnerait ça :

void calc_rect(int* aire, int* perimetre, int a, int b)
{
*aire = a*b;
*perimetre = 2*(a+b);
} 

Et tu l'appellerais comme ça :

main()
{
     int aire;
     int perim;
     int* ptAire;
     int* ptPerim;
     perim = 0;
     aire = 0;
     ptAire = &aire;
     ptPerim = &perim;

     calc_rect(ptAire, ptPerim, 2, 4);

}

Là, aire et perim valent respectivement 8 et 12.

Ok merci, je pars lire ce que tu as écris avec attention.

void calc_rect(int* aire, int* perimetre, int a, int b)
{
*aire = a*b;
*perimetre = 2*(a+b);
} 

cette partie là, ça me dit quelque chose en java, les méthodes je crois. cependant comme tu peux rentrer PTaire si l'a variable attendue est aire:ouch:

Oui, méthode ou fonction.

aire c'est juste le nom que je lui ai donné (un mauvais nom d'ailleurs puisqu'il indique pas clairement que c'est un pointeur, j'ai fais ça comme un goret). Tu peux donner le nom que tu veux dans les prototypes de fonctions, c'est le nom que tu utiliseras dans la fonction mais pas nécessairement le nom à utiliser lors de l'appel de la fonction.

Exemple :
la méthode/fonction :

int doubler(int nombreA)
{
     return 2*nombreA;
} 

L'appel :

main()
{
     int a = 3;
     doubler(a);
}

Tu remarques que dans le prototype on appelle le nombre "nombreA", et que c'est ce nom qui est utilisé dans le code de la fonction. Pourtant, dans le main, le nombre s'appelle "a", son nom n'est pas le même que celui de la fonction

Le seul impératif, c'est que ce qu'on donne en paramètre à la fonction corresponde à son prototype.

Exemple : une fonction int fonction(int 1, double b, char* c);
ne peut pas être appelée avec dans cet ordre : un char, un int*, un double.

Peu importe le nom des paramètres, le type doit correspondre.

BREF, j'ai peur que ce soit abstrait pour toi à ce stade. Concernant les pointeurs, les usages sont multiples et souvent trop complexes pour que tu les comprennes au vu du peu de connaissances que t'as en ce moment. L'exemple que j'ai donné me semble être le plus accessible : Comme une fonction a une seule valeur de retour mais peut avoir beaucoup de paramètres, on est bien embêté si on veut récupérer plusieurs valeurs avec une seule fonction. En donnant à cette fonction des pointeurs (adresse de variables), on lui permet de stocker les résultats dans les variables dont on lui a donné les adresses.

Ok merci khey ;) j'ai compris.

void calc_rect(int* aire, int* perimetre, int a, int b)
{

• aire = a*b;
• perimetre = 2*(a+b);

}

Petite précision car le titre du sujet est C++ et non C, en C++ l'utilisation des pointeurs a été simplifiée, on peut se contenter de mettre un "&" dans les parametre du prototype de la fonction et utiliser la variable "normalement" à l'interieur de la fonction, ex :
#include <iostream> using namespace std; void fonction(int &a); int main(){ int b = 0 ; cout << "b : " << b << endl; fonction(b); cout << "b : " << b << endl; return 0; } void fonction(int &a){ a += 2; }

Quand tu auras besoin des pointeurs, je pense que tu le sauras.

Un autre cas d'utilisation des pointeurs:

- Un pointeur n'a pas de durée de vie, se qui fait que tu peux accéder au pointeur n'importe ou dans le code. Et tu dois manuellement supprimer le pointeur avec l'opérateur delete.

Exemple:

int fonction()
{
    int *ptr = NULL;     // Je déclare le pointeur
    return 0;
} 
int nb = 5;
ptr  = &nb;    // J'accède au pointeur hors du bloc d'instruction dans lequel il a été déclaré, un pointeur peut donc servir de variable globale

debianthrax >> Tu parles des "références", et ce ne sont pas exactement des "pointeurs".

Une référence est constante, c'est-à-dire qu'une fois définie, elle va toujours référencer le même espace mémoire. A l'inverse d'un pointeur qu'on peut réutiliser pour pointer ailleurs (et donc on peut parfaitement utiliser les pointeurs en C++)
Il y a d'autres différences encore, plus ou moins techniques.
Mais ton exemple est correct : on utilise les références en C++ pour les paramètres de fonction, entre autres.

rangerprice >> Tu confonds les pointeurs avec l'espace mémoire qu'ils pointent.

Les allocations mémoires "statiques" ont une durée de vie délimitée par le bloc où elles sont déclarées.
Les allocations mémoires "dynamiques" (avec new/delete) peuvent effectivement exister aussi longtemps qu'on le souhaite.
Et un pointeur, lui, pointe vers un espace mémoire, alloué statiquement ou dynamiquement. Mais le pointeur lui-même est une variable comme les autres, et donc si il est alloué statiquement, il disparait à la fin du bloc (dans ton exemple, *ptr n'existe que dans fonction() )

ce soir, je vais continuer d'apprendre le C++
happy

debianthrax >> Tu parles des "références", et ce ne sont pas exactement des "pointeurs".

Une référence est constante, c'est-à-dire qu'une fois définie, elle va toujours référencer le même espace mémoire. A l'inverse d'un pointeur qu'on peut réutiliser pour pointer ailleurs (et donc on peut parfaitement utiliser les pointeurs en C++)
Il y a d'autres différences encore, plus ou moins techniques.
Mais ton exemple est correct : on utilise les références en C++ pour les paramètres de fonction, entre autres.

Ah d'accord

Ça fait plaisir de voir autant de solidarité

#include <iostream>

using namespace std;
void fonction(int &a);
int main(){
int b = 0 ;
cout << "b : " << b << endl;
fonction(b);
cout << "b : " << b << endl;
return 0;
}

void fonction(int &a){
a += 2;
}

c'est bon, j'ai bien compris avec celui-çi. vous n'aurez pas d'idées sur un mini projet qui m'aiderai à tester tout ce que j'ai fait.

Le 15 décembre 2014 à 01:31:05 Genzai_Kawakami a écrit :
debianthrax >> Tu parles des "références", et ce ne sont pas exactement des "pointeurs".

Une référence est constante, c'est-à-dire qu'une fois définie, elle va toujours référencer le même espace mémoire. A l'inverse d'un pointeur qu'on peut réutiliser pour pointer ailleurs (et donc on peut parfaitement utiliser les pointeurs en C++)

Je me permets de faire une petite correction, ça fait enculeur de mouche, mais c'est à mon sens primordial.

Un pointeur peut pointer sur une unique adresse mémoire, c'est le cas des pointeurs constants, tout en proposant de modifier ce qui pointe sur cette adresse.

ex :

int main(int a, char **av)
{
    char c = 'c';
    char * const d = &c;

    *d = 'a';
    printf("%c", c);
    return 0;
}

est valide, cependant.

int main(int a, char **av)
{
    char c = 'c';
    char * const d = &c;

    d = nullptr;
    return 0;
}

Va irrémédiablement avoir une erreur à la compilation.

La véritable différence, à mon sens, entre les pointeurs et les références, pour le programmeur, c'est que les références fonctionnent comme un alias à une variable existante, tu es donc sûr de l'intégrité de tes données, là où un pointeur, peut potentiellement pointer n'importe où dans ta mémoire.

Si tu veux modifier un objet indirectement t'utilise soit une référence soit un pointeur, peu importe.

Si tu veux "posséder" un objet t'utilise un pointeur, dans ce cas, la vie de ton objet sera défini par le pointeur et il faudra faire attention quand il est détruit etc.. Renseigne toi sur unique_ptr, shared_ptr etc..