Pointeur et objet

Version imprimable

02/03/2019, 18h34
haku972

Pointeur et objet

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 :)
03/03/2019, 08h50
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().
03/03/2019, 14h02
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 :aie: .

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++ ;)
03/03/2019, 17h02
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 :(

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:

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).
}

03/03/2019, 21h01
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 :D
03/03/2019, 21h35
dalfab

Citation:

Envoyé par 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 :D

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.
04/03/2019, 00h04
haku972

Ok je vous remercie énormément ;)

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:

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:

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:

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 */

08/03/2019, 15h29
Bousk
Code:

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.
08/03/2019, 20h11
haku972

je voulais utiliser les pointeurs pour faire que varSortie soit égale à m_sortie dans le main
09/03/2019, 17h10
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.)

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

Code:

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:

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 */

10/03/2019, 00h23
dalfab

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

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:

1 2 3 struct MaStruct{ int * ptr; }
et que tu l'utilises, par exemple, sous une forme qui pourrait être proche de
Code:

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 :question:

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 ;)

10/03/2019, 15h32
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() 8O
10/03/2019, 21h47
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) :question:
10/03/2019, 23h42
haku972

Citation:

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 :?)
11/03/2019, 00h55
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 :aie: :scarymov:

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 :question:

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 :question:
11/03/2019, 01h15
haku972

Citation:

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
11/03/2019, 01h42
koala01

Tu n'as pas l'impression de faire compliqué là où il serait si simple de faire :question:

Parce que là, tu commence à rajouter des points qui sont sensés t'aider à te dépétrer d'un problème qui n'aurais jamais du exister, mais qui, en réalité, ne font que t'enfoncer dans ta m...e :aie:

Einstien a dit[QUOTE = einstein]Il faut rendre les choses aussi complexes que possible, mais sans plus![/QUOTE]

Alors, pour répondre à ta question : oui, il est possible, à partir du moment où une classe dispose d'un pointeur ou d'une référence (non constante) vers une donnée de faire en sorte qu'une fonction membre de cette classe aille modifier la valeur de la donnée pointée / référencée.

Mais le fait que le langage accepte quelque chose ne veut pas forcément dire qu'il soit opportun de profiter de cette possibilité!

Et, en l'occurrence, il est très rarement opportun de faire en sorte qu'une donnée soit modifiée par les fonctions d'une classe qui n'est pas responsable de la donnée.

Cela occasionne ce que l'on appelle un "effet de bord", et, par nature, les effets de bords provoquent bien plus de problèmes que ce qu'ils ne permettent de résoudre :aie:

NOTA : il arrive, car rien n'est jamais simple, en programmation, que l'on n'ait pas vraiment le choix, et qu'il faille -- parfois -- se résoudre à occasionner un effet de bord. Mais cette solution ne devrait être envisagée qu'en toute dernière extrémité, quand toutes les autres solutions envisageables ont été écartées pour des raisons valables.
11/03/2019, 18h35
haku972

Citation:

Alors, pour répondre à ta question : oui, il est possible, à partir du moment où une classe dispose d'un pointeur ou d'une référence (non constante) vers une donnée de faire en sorte qu'une fonction membre de cette classe aille modifier la valeur de la donnée pointée / référencée.

si c'est possible quelle erreur ai-je fait ? je ne comprends pas pourquoi ce n'a pas réussi a modifier varSortie

Citation:

il arrive, car rien n'est jamais simple, en programmation, que l'on n'ait pas vraiment le choix, et qu'il faille -- parfois -- se résoudre à occasionner un effet de bord. Mais cette solution ne devrait être envisagée qu'en toute dernière extrémité, quand toutes les autres solutions envisageables ont été écartées pour des raisons valables.

Je ne vois pas vraiment d'autre solution pour résoudre mon problème, et je veux savoir quand même comment faire, quelle erreur j'ai fait, même si qu'après je change de solution :aie:
12/03/2019, 23h44
koala01
Citation:

Envoyé par haku972

si c'est possible quelle erreur ai-je fait ? je ne comprends pas pourquoi ce n'a pas réussi a modifier varSortie

Tout simplement : tu as transmis le paramètre par valeur, ce qui a provoqué une copie locale (au niveau du constructeur) de la variable transmise.

Or, cette copie locale est -- logiquement -- détruite au moment même l'exécution sort du constructeur, et, du coup, quand une fonction de ta classe essaye de modifier "ce qui est pointé" par le pointeur, il y a deux problèmes majeurs :
1. Le pointeur pointe vers une adresse mémoire qui ne correspond sans doute pas au type de donnée que l'on s'attend à modifier
2. et, surtout, la variable d'origine n'est pas modifiée, vu que ce n'est pas l'adresse mémoire de cette variable là que l'on a utilisée
Pour que cela puisse fonctionner, il faut impérativement que tu transmette la donnée
soit, directement sous forme de pointeur, en en prenant l'adresse mémoire lors de la transmission ( MaClasse c{&data};)
Soit en transmettant la donnée en question sous forme de référence

Citation:

Je ne vois pas vraiment d'autre solution pour résoudre mon problème, et je veux savoir quand même comment faire, quelle erreur j'ai fait, même si qu'après je change de solution :aie:

Des solutions potentielles, il y en a des dizaines, en fonction de la situation exacte dans laquelle tu te trouves.

Le problème, c'est que, tant que nous ne saurons pas dans quelle situation tu te trouves, ce qui te pousse à envisager de modifier une variable externe depuis l'intérieur d'une fonction membre, il nous sera particulièrement difficile de te proposer une solution réellement adaptée :aie:
13/03/2019, 20h06
haku972

Ah d'accord j'ai compris merci, je vais changé de façon de faire, merci pour votre aide :)
20/03/2019, 12h54
Grool

Bonjour

Bien que la discussion soit marquée "résolue" et en mettant de côté les mises en garde de koala01 sur l'utilisation des pointeurs, je pense qu'il faut que tu travailles ton cours aux chapitres sur les variables, les appels de fonctions et la programmation orientée Objet.

Ton problème montre que tu dois te poser quelques questions basiques :
- Quelle est la différence entre la valeur d'une variable et l'adresse d'une variable ?

- Que se passe-t-il si je copie cette variable, ou si je copie son adresse ?

- Quelle est la différence entre passer un paramètre par valeur ou par référence à une fonction ?

- Quelle est la portée d'une variable locale (ex : string varEntree ) ?

- As-tu compris la différence entre les notions de classe (ex : Testm ) et d'instances de classes (ex : david et goliath ) ?

- As-tu remarqué que la fonction passerInfo() a le même comportement pour les deux instances?

- As-tu compris que tes deux instances david et goliath ont trois attributs membres m_objet, m_entree et m_sortie et que, de la façon dont tu les as construits, seul m_objet a une valeur différente ?

- As-tu compris que tu construis david et goliath, mais que tu ne t'en sers plus après (et donc que leur état ne peut plus changer) ? La fonction passerInfo() ne va pas s'exécuter par magie.

Tant que tu n'es pas au point sur ces questions, c'est que tu n'as pas encore compris des notions de base sur la programmation procédurale et la programmation objet.
Les pointeurs sont un outil très puissant mais très périlleux à utiliser. Le niveau de difficulté pour les manipuler correctement est encore un cran au-dessus.

Heureusement, un débutant n'a pas besoin de les utiliser dès le départ, et même il peut s'en servir sans s'en rendre compte.
Un bon exemple, c'est que tu utilises un objet de la bibliothèque standard de type std::string que tu as déclaré en variable locale de ton main().
Cet objet est donc créé sur la pile et son adresse ( &varEntree ) ne change pas, Tu as de la chance, c'est un cas particulier.
Pas contre, std::string est un objet dynamique. Tu définis varEntree comme une chaîne vide, puis tu lui affectes une valeur et une taille imprévisibles avant l'exécution de ton programme.

std::string gère lui-même un pointeur vers une zone de mémoire dynamique (allouée sur le tas). Et si cette zone ne convient plus, il est capable d'en allouer une autre plus grande, de recopier les caractères et de libérer l'ancienne zone tout seul et proprement.

En "C++ Moderne", il est conseillé de bannir l'emploi direct des pointeurs et de s'appuyer sur ces classes qui font le travail à ta place.

Maintenant, pour en revenir à ton problème de base, tu souhaites qu'un modifiant un objet de main(), cela provoque automatiquement une action sur tes instances de Testm.
Première remarque : modifier la valeur de varEntree, ne modifie pas son adresse &varEntree, donc les instances david et goliath ne sont pas modifiées.
Seconde remarque : même si tu modifiais l'adresse de varEntree, david et goliath contiennent des pointeurs qui sont des copies de l'ancienne adresse. Et donc david et goliath ne seraient pas modifiées non plus.
Troisième remarque : en C++, aucun comportement n'est "automatique" ou "magique". C'est à toi de les coder.

Pour que la modification d'un objet entraîne un comportement sur d'autres objets indépendants, il faut programmer ce qu'on appelle un Design pattern Observer ou Observateur.

Je suis d'accord avec koala01 pour le reste. Conceptuellement tu cherches à réaliser des effets de bords. Ça doit être voulu et correctement organisé.
Il faut donc, avant même de se mettre au code, faire un minimum de conception avec un crayon et un bout de papier pour définir les comportements que tu attends.
20/03/2019, 14h53
haku972

Bonjour, et merci pour ton message, comme koala01 me l'a montré il me faut encore du travail d'apprentissage pour comprendre certaine chose, j'essaie d'aller trop vite et comme j'apprends seul je m'égare, donc merci de me remettre dans les bonnes lignes. J'ai réussi a répondre a certaine de tes questions mais il en reste encore qui sont troubles, donc je vais continuer mon apprentissage. Merci à vous :)