Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Discussion: Pointeur et objet

  1. #1
    Nouveau membre du Club
    Homme Profil pro
    autodidacte
    Inscrit en
    décembre 2018
    Messages
    60
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 25
    Localisation : France, Gironde (Aquitaine)

    Informations professionnelles :
    Activité : autodidacte

    Informations forums :
    Inscription : décembre 2018
    Messages : 60
    Points : 30
    Points
    30

    Par défaut 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

  2. #2
    Expert confirmé
    Homme Profil pro
    Ingénieur développement matériel électronique
    Inscrit en
    décembre 2015
    Messages
    892
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Ingénieur développement matériel électronique
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : décembre 2015
    Messages : 892
    Points : 4 567
    Points
    4 567

    Par défaut

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

  3. #3
    Expert éminent sénior
    Avatar de koala01
    Homme Profil pro
    Consultant informatique
    Inscrit en
    octobre 2004
    Messages
    10 999
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : Belgique

    Informations professionnelles :
    Activité : Consultant informatique

    Informations forums :
    Inscription : octobre 2004
    Messages : 10 999
    Points : 26 719
    Points
    26 719

    Par défaut

    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++
    A méditer: La solution la plus simple est toujours la moins compliquée
    Ce qui se conçoit bien s'énonce clairement, et les mots pour le dire vous viennent aisément. Nicolas Boileau
    Compiler Gcc sous windows avec MinGW
    Coder efficacement en C++ : dans les bacs le 17 février 2014
    mon tout nouveau blog

  4. #4
    Nouveau membre du Club
    Homme Profil pro
    autodidacte
    Inscrit en
    décembre 2018
    Messages
    60
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 25
    Localisation : France, Gironde (Aquitaine)

    Informations professionnelles :
    Activité : autodidacte

    Informations forums :
    Inscription : décembre 2018
    Messages : 60
    Points : 30
    Points
    30

    Par défaut

    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

  5. #5
    Expert confirmé
    Homme Profil pro
    Ingénieur développement matériel électronique
    Inscrit en
    décembre 2015
    Messages
    892
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Ingénieur développement matériel électronique
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : décembre 2015
    Messages : 892
    Points : 4 567
    Points
    4 567

    Par défaut

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

  6. #6
    Nouveau membre du Club
    Homme Profil pro
    autodidacte
    Inscrit en
    décembre 2018
    Messages
    60
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 25
    Localisation : France, Gironde (Aquitaine)

    Informations professionnelles :
    Activité : autodidacte

    Informations forums :
    Inscription : décembre 2018
    Messages : 60
    Points : 30
    Points
    30

    Par défaut

    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

  7. #7
    Expert confirmé
    Homme Profil pro
    Ingénieur développement matériel électronique
    Inscrit en
    décembre 2015
    Messages
    892
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Ingénieur développement matériel électronique
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : décembre 2015
    Messages : 892
    Points : 4 567
    Points
    4 567

    Par défaut

    Citation Envoyé par haku972 Voir le message
    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.

  8. #8
    Nouveau membre du Club
    Homme Profil pro
    autodidacte
    Inscrit en
    décembre 2018
    Messages
    60
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 25
    Localisation : France, Gironde (Aquitaine)

    Informations professionnelles :
    Activité : autodidacte

    Informations forums :
    Inscription : décembre 2018
    Messages : 60
    Points : 30
    Points
    30

    Par défaut

    Ok je vous remercie énormément

  9. #9
    Nouveau membre du Club
    Homme Profil pro
    autodidacte
    Inscrit en
    décembre 2018
    Messages
    60
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 25
    Localisation : France, Gironde (Aquitaine)

    Informations professionnelles :
    Activité : autodidacte

    Informations forums :
    Inscription : décembre 2018
    Messages : 60
    Points : 30
    Points
    30

    Par défaut

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

  10. #10
    Rédacteur/Modérateur

    Homme Profil pro
    Network game programmer
    Inscrit en
    juin 2010
    Messages
    5 679
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 31
    Localisation : Canada

    Informations professionnelles :
    Activité : Network game programmer

    Informations forums :
    Inscription : juin 2010
    Messages : 5 679
    Points : 24 974
    Points
    24 974

    Par défaut

    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.
    Pensez à consulter la FAQ ou les cours et tutoriels de la section C++.
    Un peu de programmation réseau ?
    Aucune aide via MP ne sera dispensée. Merci d'utiliser les forums prévus à cet effet.

  11. #11
    Nouveau membre du Club
    Homme Profil pro
    autodidacte
    Inscrit en
    décembre 2018
    Messages
    60
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 25
    Localisation : France, Gironde (Aquitaine)

    Informations professionnelles :
    Activité : autodidacte

    Informations forums :
    Inscription : décembre 2018
    Messages : 60
    Points : 30
    Points
    30

    Par défaut

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

  12. #12
    Expert confirmé
    Homme Profil pro
    Ingénieur développement matériel électronique
    Inscrit en
    décembre 2015
    Messages
    892
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Ingénieur développement matériel électronique
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : décembre 2015
    Messages : 892
    Points : 4 567
    Points
    4 567

    Par défaut

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

  13. #13
    Nouveau membre du Club
    Homme Profil pro
    autodidacte
    Inscrit en
    décembre 2018
    Messages
    60
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 25
    Localisation : France, Gironde (Aquitaine)

    Informations professionnelles :
    Activité : autodidacte

    Informations forums :
    Inscription : décembre 2018
    Messages : 60
    Points : 30
    Points
    30

    Par défaut

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

  14. #14
    Expert confirmé
    Homme Profil pro
    Ingénieur développement matériel électronique
    Inscrit en
    décembre 2015
    Messages
    892
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Ingénieur développement matériel électronique
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : décembre 2015
    Messages : 892
    Points : 4 567
    Points
    4 567

    Par défaut

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

  15. #15
    Expert éminent sénior
    Avatar de koala01
    Homme Profil pro
    Consultant informatique
    Inscrit en
    octobre 2004
    Messages
    10 999
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : Belgique

    Informations professionnelles :
    Activité : Consultant informatique

    Informations forums :
    Inscription : octobre 2004
    Messages : 10 999
    Points : 26 719
    Points
    26 719

    Par défaut

    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
    A méditer: La solution la plus simple est toujours la moins compliquée
    Ce qui se conçoit bien s'énonce clairement, et les mots pour le dire vous viennent aisément. Nicolas Boileau
    Compiler Gcc sous windows avec MinGW
    Coder efficacement en C++ : dans les bacs le 17 février 2014
    mon tout nouveau blog

  16. #16
    Nouveau membre du Club
    Homme Profil pro
    autodidacte
    Inscrit en
    décembre 2018
    Messages
    60
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 25
    Localisation : France, Gironde (Aquitaine)

    Informations professionnelles :
    Activité : autodidacte

    Informations forums :
    Inscription : décembre 2018
    Messages : 60
    Points : 30
    Points
    30

    Par défaut

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

  17. #17
    Expert éminent sénior
    Avatar de koala01
    Homme Profil pro
    Consultant informatique
    Inscrit en
    octobre 2004
    Messages
    10 999
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : Belgique

    Informations professionnelles :
    Activité : Consultant informatique

    Informations forums :
    Inscription : octobre 2004
    Messages : 10 999
    Points : 26 719
    Points
    26 719

    Par défaut

    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)
    A méditer: La solution la plus simple est toujours la moins compliquée
    Ce qui se conçoit bien s'énonce clairement, et les mots pour le dire vous viennent aisément. Nicolas Boileau
    Compiler Gcc sous windows avec MinGW
    Coder efficacement en C++ : dans les bacs le 17 février 2014
    mon tout nouveau blog

  18. #18
    Nouveau membre du Club
    Homme Profil pro
    autodidacte
    Inscrit en
    décembre 2018
    Messages
    60
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 25
    Localisation : France, Gironde (Aquitaine)

    Informations professionnelles :
    Activité : autodidacte

    Informations forums :
    Inscription : décembre 2018
    Messages : 60
    Points : 30
    Points
    30

    Par défaut

    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 )

  19. #19
    Expert éminent sénior
    Avatar de koala01
    Homme Profil pro
    Consultant informatique
    Inscrit en
    octobre 2004
    Messages
    10 999
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : Belgique

    Informations professionnelles :
    Activité : Consultant informatique

    Informations forums :
    Inscription : octobre 2004
    Messages : 10 999
    Points : 26 719
    Points
    26 719

    Par défaut

    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
    A méditer: La solution la plus simple est toujours la moins compliquée
    Ce qui se conçoit bien s'énonce clairement, et les mots pour le dire vous viennent aisément. Nicolas Boileau
    Compiler Gcc sous windows avec MinGW
    Coder efficacement en C++ : dans les bacs le 17 février 2014
    mon tout nouveau blog

  20. #20
    Nouveau membre du Club
    Homme Profil pro
    autodidacte
    Inscrit en
    décembre 2018
    Messages
    60
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 25
    Localisation : France, Gironde (Aquitaine)

    Informations professionnelles :
    Activité : autodidacte

    Informations forums :
    Inscription : décembre 2018
    Messages : 60
    Points : 30
    Points
    30

    Par défaut

    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

+ Répondre à la discussion
Cette discussion est résolue.
Page 1 sur 2 12 DernièreDernière

Discussions similaires

  1. Réponses: 4
    Dernier message: 27/10/2006, 18h03
  2. Perte du pointeur à mon objet
    Par Maxou22 dans le forum C++
    Réponses: 1
    Dernier message: 11/03/2006, 06h42
  3. Tableau de pointeurs sur objets
    Par bassim dans le forum C++
    Réponses: 11
    Dernier message: 13/12/2005, 20h45
  4. [TTreeView] Problème avec les pointeurs d'objet
    Par BlackWood dans le forum Composants VCL
    Réponses: 2
    Dernier message: 02/07/2004, 15h31
  5. [Debutant VC++.net] Obtenir un pointeur sur objet
    Par SteelBox dans le forum MFC
    Réponses: 6
    Dernier message: 17/06/2004, 19h36

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo