Discussion :

[haku972]

Bonjour à tous, je débute en c++, et je suis arrivé au chapitre objet et pointeur, et je voudrais savoir si c'est possible d'orienter le pointeur de l'objet vers une variable dans le main ? Merci de votre aide dans ma compréhension

[dalfab]

Oui.
Un pointeur c'est justement fait pour pointer sur une variable ou une zone dynamiquement allouée.
Tous les exemples simples de code avec pointeurs utilisent souvent un pointeur sur une variable de la fonction main().

[koala01]

Salut,

Il faut déjà comprendre ce qu'est un pointeur : ce n'est rien d'autre qu'une variable numérique entière (généralement) non signée qui représente ... l'adresse mémoire à laquelle on (est sensé / espère) pouvoir trouver une donnée du type indiqué.

Une fois que tu as compris cela, le reste coule presque de source:

1. Dés qu'une information est en mémoire, il peut y avoir un pointeur dont la valeur correspond à l'adresse mémoire à laquelle cette information se trouve
2. dés que tu es en mesure de désigner clairement cette information au travers d'un nom (d'un identifiant), tu peux demander au compilateur de fournir l'adresse à laquelle elle se trouve.
3. dés que tu peux demander l'adresse mémoire à laquelle se trouve une information quelconque, tu peux affecter cette adresse à un pointeur

Notes cependant que les pointeurs posent énormément de problèmes, entre autres, parce qu'il n'y a rien qui ressemble d'avantage au contenu d'une adresse mémoire donnée ... que le contenu d'une autre adresse mémoire au niveau du processeur.

Si on essaye d'accéder au contenu d'une adresse mémoire (au travers d'un pointeur) qui, pour une raison ou une autre, ne contient pas l'information espérée, cela provoquera immanquablement des catastrophes .

Or, C et C++ sont très différents à ce point de vue, car, si l'on est pour ainsi dire obligés d'apprendre à manipuler des pointeurs en C dés le deuxième chapitre, C++ nous offre énormément de possibilités de "faire autrement", et de ne devoir réellement s'intéresser à la notion de pointeurs qu'une fois que l'on aborde les problèmes liés au polymorphisme

Je ne sais pas quel cours ou tutoriel tu es occupé à suivre, mais, de manière générale, le simple fait que tu poses ta question me laisse à penser que le chapitre qui parle des pointeurs est le deuxième ou le troisième de ton cours.

Si je peux te donner un conseil, c'est sans doute de fuir ce cours ou ce tutoriel comme la peste, car il suit -- de toutes évidences -- "l'approche historique" de l'apprentissage du C++, et qu'il risque très fort de te donner un tas de (très) mauvaises habitudes, dont tu auras sans doute le plus grand mal à te défaire par la suite, afin de commencer à réellement coder en C++

[haku972]

Merci de votre aide, mais en gros c'est sur l'utilisation des pointeurs par rapport aux objets, je voulais savoir si c'est possible de déclarer un pointeur dans un objet et le faire pointer vers une variable déclaré dans le main, car ils ont montré comment faire le pointeur d'un objet pointer vers un autre objet ou un pointeur dans le main pointer vers une variable du main, mais je souhaitais faire le pointeur d'un objet pointer vers une variable déclaré dans le main, j'ai l'impression que ce n'est pas possible

[dalfab]

Je ne vois pas ce qui te bloque. Il faudrait un exemple.
Quand on n'est pas dans dans le main, on n'a pas accès aux variables dans main(). Mais on a pu prendre leur adresse avant.

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 UnObjet {
public:
   int*  unPointeurSurUnEntierQuelconque;
};
 
void uneFonction( int* adresseDUneVariable ) {
   UnObjet  monObjet;
   monObjet.unPointeurSurUnEntierQuelconque = adresseDUneVariable;  // L'objet a un pointeur sur une variable du main()
}
 
int main() {
   int  variableDansMain = 2;
   uneFonction( &variableDansMain );  // appel de fonction, on lui passe l'adresse de la variable (donc un pointeur).
}

[haku972]

Ah d'accord c'est que je le faisais mal, j'avais déclaré le pointeur dans privée, et dans le constructeur j'avais mis que le pointeur=&variable Donc par la fonction je passe l'adresse de la variable ? Ok je vous remercie énormément

[dalfab]

Ah d'accord c'est que je le faisais mal, j'avais déclaré le pointeur dans privée, et dans le constructeur j'avais mis que le pointeur=&variable Donc par la fonction je passe l'adresse de la variable ? Ok je vous remercie énormément

On peut tout à fait avoir le pointeur en privé, et on peut tout à fait l'initialiser dans le constructeur en prenant une adresse, à voir de quoi on prend l'adresse.

[haku972]

Ok je vous remercie énormément

[haku972]

Bonjour, et désolée de revenir mais j'ai encore un problème avec mon pointeur ça me met l'erreur : Thread 1: EXC_BAD_ACCESS (code=1, address=0x0), j'ai tout essayer mais rien ne fonctionne, j'ai encore besoin d'aide sur ce coup

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
 
 
#include <iostream>
#include <stdio.h>
#include <string>
#include <chrono>
#include <istream>
#include <ostream>
#include <sstream>
#include <iterator>
#include <algorithm>
#include <vector>
#include <ctime>
#include "testm.hpp" //Ne pas oublier
 
 
using namespace std;
 
int main()
{
    string varEntree;
    string varSortie;
 
    Testm david(1, varSortie, varEntree), goliath(2, varSortie, varEntree);
 
    do
    {
 
        cout << "entrer quelque chose" << endl;
        getline(cin, varEntree);
 
 
        cout << varSortie << endl;
 
    } while (varEntree != "stopm"); 
 
 
    return 0;
}

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
 
 
#include "testm.hpp"
#include <iostream>
#include <string>
#include <istream>
#include <ostream>
#include <sstream>
#include <iterator>
#include <algorithm>
#include <vector>
#include <ctime>
 
 
using namespace std;
 
Testm::Testm(int numero, string sortie,  string entree): m_objet(0)
{
    m_objet = numero;
    m_sortie = &sortie;
    m_entree = &entree;
 
  }  
 
void Testm::passerInfo()
{
    if (*m_entree == "chien")  
    {
        *m_entree = "dog";
        *m_sortie = *m_entree;
    }
 
    else{
        *m_sortie = "";
    }
 
}
 
Testm::~Testm()
{
 
}

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
 
 
#ifndef testm_hpp
#define testm_hpp
 
#include <stdio.h>
#include <string>
 
 
class Testm
{
public:
 
    Testm(int numero, std::string sortie,  std::string entree); //Constructeur
    void passerInfo();
    ~Testm();
 
private:
 
    int m_objet;
    std::string *m_entree;// l'entrée
    std::string *m_sortie; // la sortie
 
};
 
 
#endif /* testm_hpp */

[Bousk]

Code :

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

1
2
3
4
5
6
7
Testm::Testm(int numero, string sortie,  string entree): m_objet(0)
{
    m_objet = numero;
    m_sortie = &sortie;
    m_entree = &entree;
 
  }

Ton code prend des pointeurs vers des variables temporaires.
Ces variables sont détruites, le pointeur devient invalide.
Les pointeurs semblent pas super utiles ici.

[haku972]

je voulais utiliser les pointeurs pour faire que varSortie soit égale à m_sortie dans le main

[dalfab]

Quand on écrit : int ma_variable; on va créer une variable qui peut contenir un entier. Elle ne peut pas se souvenir d'où vient cet entier, elle ne peut qu'en mémoriser la valeur. Cette règle s'applique aussi aux paramètres des fonctions et des constructeurs.
Le constructeur tel que tu l'as défini ne peut que recevoir des valeurs, donc il peut pas suivre des variables à l'extérieur bien que passée en paramètre. On n'en a reçu que la valeur.
Les moyens d'accéder à une variable plutôt qu'à une simple valeur sont :
- les pointeurs : int* adr_d_une_variable; peut mémoriser la variable initiale dont on a pris l'adresse par &var_initiale, et on pourra en modifier la valeur par *adr_d_une_variable.
- les références : int& reference_une_variable qui est un véritable alias d'une autre variable. C'est dans la plupart des cas plus simple et plus fiable qu'utiliser un pointeur. Un paramètre de type référence va directement se comporter comme s'il était la variable initiale (en prendre l'adresse revient prendre l'adresse de la variable initiale, la lire ou l'écrire revient à lire ou écrire la variable initiale.)

[haku972]

ok, donc comme ça ? Mais mon m_sortie ne modifie toujours pas ma varSortie

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
 
#include "testm.hpp"
#include <iostream>
#include <string>
#include <istream>
#include <ostream>
#include <sstream>
#include <iterator>
#include <algorithm>
#include <vector>
#include <ctime>
 
 
using namespace std;
 
Testm::Testm(int numero, string& sortie,  string& entree): m_objet(0)
{
    m_objet = numero;
    m_sortie = &sortie;
    m_entree = &entree;
 
 
}
 
void Testm::passerInfo()
{
    if (*m_entree == "chien")  
    {
        *m_sortie = "dog";
    }
 
    else{
        *m_sortie = "";
    }
 
}
 
Testm::~Testm()
{
 
}

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
 
#ifndef testm_hpp
#define testm_hpp
 
#include <stdio.h>
#include <string>
 
 
class Testm
{
public:
 
    Testm(int numero, std::string& sortie,  std::string& entree); //Constructeur
    void passerInfo();
    ~Testm();
 
private:
 
    int m_objet;
    std::string *m_entree;// l'entrée
    std::string *m_sortie; // la sortie
 
};
 
 
#endif /* testm_hpp */

[dalfab]

C'est passerInfo() qui fait la modification, quand est-elle appelée?

[koala01]

Il faut faire TRES ATTENTION quand on manipule des pointeurs, et surtout lorsqu'on décide de prendre l'adresse d'une variable pour en indiquer la valeur (ce que tu fais).

Car, il faut bien te dire que les pointeurs n'ont aucun moyen de mettre l'adresse qu'ils contiennent à jour (à moins de le faire de manière explicite), si bien que, si tu as une structure (ou une classe, cela revient au même) proche de

Code :

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

1
2
3
struct MaStruct{
    int * ptr;
}

et que tu l'utilises, par exemple, sous une forme qui pourrait être proche de

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
int main(){
    std::vector<int> tab;
    /* pré-remplicage de tab */
    for(int i = 0;i <8; ++i){
        tab.push_back(i);
    }
    MaStruct s;
    /* définition de ptr de telle manière à ce qu'il pointe vers le premier élément du tableau */
    s.ptr = &tab[0];
    /* la vérification fonctionne : */
    std::cout<<s->ptr<<"\n";
    /* l'ajout et la suppression d'élément d'un tableau risquent de provoquer une réallocation 
     * de la mémoire allouée au contenu de ce tableau.
     * ==> toutes les adresses mémoires deviennent invalides
     */
   tab.push_back(8); // CRACK : le premier élément du tableau ne se trouve plus à l'adresse mémoire
                     //         représentée par s->ptr
    std::cout<<<s->ptr<<"\n"; // BOUM : accès à une adresse mémoire (celle représentée par ptr)
                              // est invalide ==> erreur de segmentation
 
}

La bonne question est donc : pourquoi voudrais tu utiliser des pointeurs dans ta classe

Il existe, effectivement, des situaitons dans lesquelles l'utilisation de pointeurs est utile, voire indispensable. Mais, de manière générale, cela devrait être considéré comme le dernier recours

[haku972]

Parce que je voulais que la classe modifie directement la variable qu'il y a dans le main, et je pensais que la solution était d'utiliser un pointeur;
Avec l'aide du pointeur je ne pensais pas qu'il me fallait appeler encore la fonction passerInfo()

[koala01]

Alors, la règle, quand on crée une classe (en dehors de réfléchir à cette classe en termes de services, s'entend) c'est:

1. Dans la mesure du possible, éviter que plusieurs éléments soient "co responsables" de certaines données
2. de ne fournir comme donnée membre à une classe que les données dont elle est responsable
3. de donner la préférence au fait de transmettre les données dont la classe n'est pas responsable, mais dont une fonction a besoin, sous forme d'un paramètre à donner à la fonction en question
4. de préférer, autant que possible, faire en sorte que la fonction ne puisse / doive pas modifier les paramètres qu'elle a reçus

Bien sur, ces règles ne sont pas absolument rigides, et il y a de très nombreuses situations dans lesquelles elles deviennent purement et simplement inapplicables. Mais il n'empêche que plus tu respecte ces règles, plus tu te simplifies la vie par la suite:

(1) Lorsque deux éléments (appelons les A et B) sont "co responsables" de l'existence d'un troisième élément (nommons le C), il arrive le plus souvent que C doive être créé "en même temps" que premier élément (de A ou de B) qui sera créé, et qu'il doive continuer à exister jusqu'à ce que le dernier élément (de A ou de B) soit détruit.

Il y a moyen de s'assurer, par différents biais, que ce sera bel et bien le cas. Mais il est aussi très (trop) facile de se planter en essayant d'y arriver.

En s'organisant pour qu'il n'y ait jamais qu'un seul responsable du maintient en mémoire d'une donnée bien particulière, on évite bien des problèmes qui pourraient survenir "simplement" parce que, pas de bol, on s'est vautré en réfléchissant à ce qui devait être détruit en premier

(2) Lorsqu'une instance particulière d'une classe est détruite, son destructeur est appelé, et ses membres sont normalement détruits (dans l'ordre inverse de leur déclaration).

En s'assurant qu'une classe ne dispose que des données dont elle est effectivement responsable, on s'assurer -- de facto -- que seules les données qui sont effectivement susceptibles d'être détruites le seront lorsque l'instance de la classe devra être détruite

(3) Si, pour une raison ou une autre, tu décides de transmettre une donnée par paramètre à une fonction, le compilateur peut au moins s'assurer que la donnée en question est bel et bien sensée exister au moment où tu fais appel à la fonction.

Cela ne résout pas tous les problèmes, mais cela peut en éviter pas mal

De plus, cela permet -- en cas de besoin -- de fournir plusieurs données différentes lors de différents appels à la fonction

(4) Ce n'est pas toujours faisable, mais le simple fait de s'assurer qu'une donnée ne sera pas modifiée par la fonction à laquelle on souhaite faire appel évite bien des mauvaises surprises, lorsque l'on essaye de réfléchir, après coup, à la valeur de la donnée en question .

Et, donc..

La véritable question est donc : pourquoi voudrais tu qu'une instance puisse modifier la valeur d'une donnée créée dans la fonction principale (ou pire : que plusieurs instances de la même classe risquent de modifier la même donnée de la fonction principale)

[haku972]

Et, donc..

La véritable question est donc : pourquoi voudrais tu qu'une instance puisse modifier la valeur d'une donnée créée dans la fonction principale (ou pire : que plusieurs instances de la même classe risquent de modifier la même donnée de la fonction principale)

En gros je voulais que chaque instance en fonction de son contenu puisse modifier la variable varSortie dans le main selon ce qui est entrée par varEntree, genre si varEntree est égale à ce que tu as en toi alors modifie varSortie, sinon ne fait rien (c'est impossible on dirait )

[koala01]

Oh, que voilà une excellente idée!!!

Surtout si tu veux ne plus jamais pouvoir prévoir la valeur de la variable en question

Parce que, mettons que j'aie deux instances de la classe en question. Que ces deux instances doivent modifier la même variable de la fonction principale. Et que ces deux instances modifient différemment la variable.

Pour faire simple, mettons que l'instance A donne la valeur 15 à la variable de la fonction principale, et que l'instance B lui donne la valeur ... 36.

Comment tu fais, toi, en lisant ton code, pour savoir si la variable de ta fonction principale vaut 15 ou 36

Il faut comprendre que, le propre des fonctions, c'est de présenter des comportements prédictibles (pour une ou plusieurs information(s) spécifique donnée(s) en entrées nous aurons un résultat spécifique) et reproductible (pour les mêmes informations fournies en entrées, nous aurons toujours le même résultat).

Vu que ta fonction principale n'a absolument aucun contrôle sur la valeur utilisée comme référence par ta classe, tu ne peux absolument pas garantir ces deux spécificités!

Et donc, je repose la question : pourquoi voudrais tu qu'une instance de ta classe soit en mesure de modifier la valeur d'une variable de ta fonction principale

[haku972]

Parce que, mettons que j'aie deux instances de la classe en question. Que ces deux instances doivent modifier la même variable de la fonction principale. Et que ces deux instances modifient différemment la variable.

Pour faire simple, mettons que l'instance A donne la valeur 15 à la variable de la fonction principale, et que l'instance B lui donne la valeur ... 36.

Comment tu fais, toi, en lisant ton code, pour savoir si la variable de ta fonction principale vaut 15 ou 36

Il faudra faire en sorte que l'instance ne modifie la varSortie que si la varEntree est égale à une valeur d'entrée propre à l'instance, sachant que cette valeur ne peut être que dans une seule instance (une valeur d'entrée unique pour chaque instance)
Après je n'est pas encore tout fait, pour le moment j'essaie juste de modifier depuis une instance, une variable dans le main, voir si c'est possible et comment on fait