IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
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

 C++ Discussion :

This! j'aimerais comprendre ce fameux mot-clé


Sujet :

C++

  1. #1
    Membre averti
    Homme Profil pro
    Étudiant
    Inscrit en
    Juin 2015
    Messages
    27
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 42
    Localisation : Canada

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Juin 2015
    Messages : 27
    Par défaut This! j'aimerais comprendre ce fameux mot-clé
    Bonjour a tous,
    Je termine ma première session en programmation c++ et je dois remettre un travail dont l'un des numéro me cause beaucoup de problème.

    citation du travail pour mettre dans le contexte:" Écrire un programme qui utilise le mot-clé THIS dans la gestion d'une liste chaîné de 20 objets de même nature."

    J'ai plancher pas mal sur la partie liste chaîné et grâce a de l'aide je suis arriver à faire le code suivant qui est une liste doublement chaîné du moins sa fonction. voici le code:
    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
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    #include <iostream>
    #include <stdlib.h>
     
    using namespace std;
     
    struct Element
    {
        int valeur;
        Element* precedent;
        Element* suivant;
    };
     
    Element* premier = NULL;
    Element* dernier = NULL;
     
    void Ajouter(int valeur)
    {
        //Créer l'élément.
        Element* element = new Element;
        //Vérifier s'il y a un premier élément dans la liste.
        if(dernier == NULL)
        {
            Element* dernier=element;
        }
        //L'élément créer devient l'élément précédent du premier élément de la listeactuel.
        if(premier!=NULL)
        {
            premier->precedent=element;
        }
        //L'élément est placé en début de liste, le premier élément devien le suivant de cette élément.
        element->suivant=premier;
        premier=element;
        //Le nouvelle élément est le premier de la liste donc, précédent est null.
        element->precedent=NULL;
     
        element->valeur=valeur;
    }
     
    void Afficher()
    {
    Element* element = premier;
    while(element != NULL)
    {
    cout << element->valeur << "\t";
    element = element->suivant;
    }
    cout << endl;
    }
     
    int main()
    {
        cout << "Hello world!" << endl;
        Element* e;
     
        for(int i=1; i<=20; i++)
        {
            Ajouter(i);
        }
     
        Afficher();
        return 0;
    }
    Mon nouveau problème est que THIS est très simplement expliquer dans mon manuel du genre this est un pointeur sur objet et *this est l'objet lui-même. HA! oui y a pas vraiment plus que sa comme explication donc je vois pas pourquoi on l'utilise vraiment et comment je pourrais non plus l'inclure dans une fonction de mon code pour remplir les exigence de l'exercice. Sur le net, j'ai lu pas mal et je trouve jamais de texte qui en parle clairement comme on parle des variable ou tableau oû là le texte est très claire et les exemples aussi. Je ne demande pas à ce que l'on me termine mon TP, mais bien à ce qu'on m'ouvre l'esprit à comprendre ce que je ne vois pas ou comprend pas.

    merci à ceux qui prendront le temps de aider

    mathieu

  2. #2
    Expert confirmé
    Homme Profil pro
    Ingénieur développement matériel électronique
    Inscrit en
    Décembre 2015
    Messages
    1 599
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 62
    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 : 1 599
    Par défaut
    Bonjour,
    L'exemple que tu donnes est essentiellement du code C même s'il peut compiler en C++.
    Pour comprendre this, il faut d'abord créer un Objet. Les méthodes de cet objet pourront utiliser this.
    Exemple :
    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
    class MonObj
    {
    public:
       MonObj( int z ) { x = z; }
       int  x;
       void affiche();
    };
    void MonObj::affiche() {
        std::cout << this->x;   // affiche la valeur de x (1 s'il s'agit de var1, 2 s'il s'agit de var2)
        std::cout << x;         // le même x, pas besoin d'utiliser this
    }
    int main() {
       MonObj var1( 1 );
       MonObj var2( 2 );
       std::cout << var1.x;      // affiche 1
       var1.affiche();           // affiche 11
       var2.affiche();           // affiche 22
       std::cout << this->x;     // erreur, on est dans main() pas dans une méthode de MonObj
    }
    Tous les objets du type MonObj auront une variable appelée x, chacun la sienne. Pour un objet var1, on pourra faire var1.x pour accéder à x. A l'intérieur des méthodes de l'objet on pourra faire this->x, this désigne alors l'objet qui vient d'être appelé.

  3. #3
    Rédacteur/Modérateur


    Homme Profil pro
    Network game programmer
    Inscrit en
    Juin 2010
    Messages
    7 147
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : Canada

    Informations professionnelles :
    Activité : Network game programmer

    Informations forums :
    Inscription : Juin 2010
    Messages : 7 147
    Billets dans le blog
    4
    Par défaut
    Salut,
    ta définition est correct, et à vrai dire y'a pas grand chose à en dire de plus... c'est juste ça : c'est l'objet lui-même. Ca te donne l'adresse de lui-même, pour le passer en paramètre typiquement.
    Par exemple, pour l'exercice classique de la liste chaînée, tu peux avoir
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    struct Maillon {
      Maillon* prev;
      Maillon* next;
      Maillon(Maillon* _prev = nullptr)
        : prev(_prev)
        , next(nullptr)
      {}
      // this en paramètre
      Maillon* NewNext() { Maillon* n = new Maillon(this); return n; }
    };
    Maillon* maillon1 = new Maillon;
    // maillon1 en paramètre
    Maillon* maillon2 = new Maillon(maillon1);
    Maillon* maillon3 = maillon2->NewNext(); // identique à maillon3 = new Maillon(maillon2);
    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.

  4. #4
    Expert confirmé
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Février 2005
    Messages
    5 492
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Conseil

    Informations forums :
    Inscription : Février 2005
    Messages : 5 492
    Par défaut
    En plus du cas d'utilisation illustré par @Bousk, il reste le cas qui sert à résoudre une ambiguïté.
    On utilise très peu "this" car il est implicitement utilisé par défaut.
    Quand un nom "toto" est utilisé comme identifiant de variable, le compilateur cherche à voir s'il y a une variable locale ou un paramètre avec ce nom, si oui, il l'utilise, sinon, il regarde s'il existe un champ avec ce nom, si oui, il l'utilise, sinon, etc... (global tour ça tout ça).

    Si un paramètre porte le même nom qu'un champ de l'objet, pour indiquer que l'on veut utiliser le champ et non le paramètre, il faut préfixer le nom de la variable par "this->".

    Exemple :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    class A
    {
         int x;
     
    public :
        A(int x):x(x){}
        setX(int x){this->x = x;}
    }

  5. #5
    Membre averti
    Homme Profil pro
    Étudiant
    Inscrit en
    Juin 2015
    Messages
    27
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 42
    Localisation : Canada

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Juin 2015
    Messages : 27
    Par défaut
    Pour commencer merci pour votre aide!

    -J'ai fais quelques changement dans mon code. J'ai changer struct pour class avec quelques adaptations, sa marche mais je suis pas sur que ce soit politiquement correct.
    -J'ai utiliser le this dans une méthode quoi que c'est plus pour répondre au exigence du travail. Je croix que ce mot va m'en faire baver pas pire car, si j'ai bien compris c'est juste plus lisible comme code mais pas essentiel.

    Je vous montre ce que sa donne comme code:
    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
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
     
    #include <iostream>
    #include <stdlib.h>
     
    using namespace std;
     
    class Element
    {
        public:
            int Ajouter(int valeur);
            void Afficher();
            Element* Recherche(int valeur);
            void Supprimer(Element* element);
     
        private:
            int valeur;
            Element* precedent;
            Element* suivant;
    };
    //convertie la structure en class
    /**struct Element
    {
        int valeur;
        Element* precedent;
        Element* suivant;
    };**/
     
    Element* premier = NULL;
    Element* dernier = NULL;
     
    int Element::Ajouter(int valeur)
    {
        //Créer l'élément.
        Element* element = new Element;
        //Vérifier s'il y a un premier élément dans la liste.
        if(dernier == NULL)
        {
            Element* dernier=element;
        }
        //L'élément créer devient l'élément précédent du premier élément de la listeactuel.
        if(premier!=NULL)
        {
            premier->precedent=element;
        }
        //L'élément est placé en début de liste, le premier élément devien le suivant de cette élément.
        element->suivant=premier;
        premier=element;
        //Le nouvelle élément est le premier de la liste donc, précédent est null.
        element->precedent=NULL;
     
        element->valeur=valeur;
        return this->valeur;
    }
     
    void Element::Afficher()
    {
    Element* element = premier;
    while(element != NULL)
    {
    cout << element->valeur << "\t";
    element = element->suivant;
    }
    cout << endl;
    }
     
    Element* Element::Recherche(int valeur)
    {
        Element* element = premier;
        //On commence par le premier élément et tant qu'il y a un élément suivant on continue.
        //Jusqu'à ce qu'on trouver l'élément voulu.
        while(element !=NULL && element->valeur !=valeur)
        {
            element=element->suivant;
        }
        //on retourne l'élément trouvé.
        return element;
    }
     
    void Element::Supprimer(Element* element)
    {
        Element* precedent = premier;
        //Si l'élément a suprimer est le premier.
        if(element == premier)
            {
                premier = NULL;
                delete element;
                return;
            }
        //Sinon  il faut trouver l'élément précédent pour changer son pointeur suivant
        while(precedent != NULL && precedent->suivant != element)
        {
             precedent = precedent->suivant;
        }
     
        if(precedent == NULL)
        {
            return;
        }
     
        precedent->suivant = element->suivant;
        delete element;
    }
     
    int main()
    {
        cout << "Liste cha\x8cn\x82 " << endl;
        //Création de l'objet.
        Element a;
        Element* e;
     
        //Boucle pour obtenir 20 éléments.
        for(int i=1; i<=20; i++)
        {
            a.Ajouter(i);
        }
        //Afficher les éléments
        a.Afficher();
        //Choisir, trouver et supprimer un élément.
        cout<< "rechercher une valeur \x85 supprimer: ";
        int x;
        cin >> x;
        e = a.Recherche(x);
        a.Supprimer(e);
        cout << "Nouvelle liste cha\x8cn\x82" << endl;
        //Afficher les éléments
        a.Afficher();
     
        return 0;
    }
    J'ai essayé de créer un ficher class (si je dit sa de la bonne manière) Element.h mais, je ne sais pas ou aller mettre ces deux ... de ligne de code :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
    Element* premier = NULL;
    Element* dernier = NULL;
    J'aime bien apprendre, alors hésité pas pour critiquer ou me donner des conseils sur mon travail.

  6. #6
    Expert confirmé
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Février 2005
    Messages
    5 492
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Conseil

    Informations forums :
    Inscription : Février 2005
    Messages : 5 492
    Par défaut
    J'ai l'impression que vous mettez la charrue avant les bœufs.

    Vous vous fixez sur le mot-clés "this" mais vous n'avez toujours pas les bases de la POO (Programmation Orientée Objet).
    Avec de bonne base en POO, le concept derrière "this" vous serait plus évident.

    Votre code montre que vous ne maitrisez pas du tout la POO.
    Sinon, vous n'auriez pas fait des fonctions "Ajouter", "Recherche", 'Supprimer" des fonctions d'instance de la classe "Element".
    Quel que soit les détails d'implémentation, l'interface de la classe doit être logique.
    On ne demande pas à un élément d'ajouter un autre élément, ni d'en rechercher un autre ou de s'autodétruire.
    Il faut séparer la classe Element de la gestion de list.

    En C++, il y la STL, qui offre une classe paramétrée list<T>.
    En séparant les 2 aspects, Element n'est qu'un int.
    Donc, vous n'avez pas besoin de faire une classe mais juste utiliser la classe list<T>, qui vous offrira une interface d'utilisation bien plus cohérente que celle que vous avez conçue.

    si j'ai bien compris c'est juste plus lisible comme code mais pas essentiel.
    C'est totalement faux. On ne l'utilise surtout pas pour la lisibilité mais uniquement quand c'est nécessaire.
    - Pour passer l'objet en paramètre d'une fonction/méthode d'un autre objet ou d'une fonction libre.
    - Pour accéder à un champ de l'objet quand une variable locale ou un paramètre ont le même nom.

    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
     
    #include <iostream>
    #include <stdlib.h>
    #include <list>
     
    int main()
    {
        std::cout << "Liste cha\x8cn\x82 " << endl;
     
        //Création de l'objet.
        std::list<int> a(20);
     
        //initialisation des int
        std::iota(a.begin(), a.end(), 1);
     
        //afficher la liste
        for(auto n: a) std::cout << n << '\t';
     
        //Choisir, trouver et supprimer un élément.
        std::cout<< "rechercher une valeur \x85 supprimer: ";
        int x;
        std::cin >> x;
     
        a.remove(x);
     
        std::cout << "Nouvelle liste cha\x8cn\x82" << endl;
     
        //Afficher les éléments
        for(auto n: a) std::cout << n << '\t';
     
        return 0;
    }

  7. #7
    Membre averti
    Homme Profil pro
    Étudiant
    Inscrit en
    Juin 2015
    Messages
    27
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 42
    Localisation : Canada

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Juin 2015
    Messages : 27
    Par défaut
    J'ai commencé y a 10 semaine le cours sur le c++ à l'université par cours a distance. Le code :
    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
    struct Element
    {
        int valeur;
        Element* precedent;
        Element* suivant;
    };
     
    Element* premier = NULL;
    Element* dernier = NULL;
     
    void Ajouter(int valeur)
    {
        //Créer l'élément.
        Element* element = new Element;
        //Vérifier s'il y a un premier élément dans la liste.
        if(dernier == NULL)
        {
            Element* dernier=element;
        }
        //L'élément créer devient l'élément précédent du premier élément de la listeactuel.
        if(premier!=NULL)
        {
            premier->precedent=element;
        }
        //L'élément est placé en début de liste, le premier élément devien le suivant de cette élément.
        element->suivant=premier;
        premier=element;
        //Le nouvelle élément est le premier de la liste donc, précédent est null.
        element->precedent=NULL;
     
        element->valeur=valeur;
    }
    M'a été fournie par le charger de cours et j'ai fais avec sa. Tu me fais réaliser que j'ai mal compris le concept POO, va devoir plancher la dessus alors.

    merci pour le commentaire et l'aide

  8. #8
    Expert confirmé
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Février 2005
    Messages
    5 492
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Conseil

    Informations forums :
    Inscription : Février 2005
    Messages : 5 492
    Par défaut
    le charger de cours et j'ai fais avec sa
    Non, sans déconner, c'est une blague ???

    Ce code montre une complète ignorance du concept objet.

    Pour moi, c'est de la transcription "petit nègre" C++, d'un truc fait à l'arrache en C.

    Et C++ n'a plus grand chose à voir avec le C depuis fort longtemps.

    Le code que je vous ai fourni est bien plus simple et fait exactement la même chose (dans les intentions, parce que le code fourni est trop complexe inutilement pour que je m'esquinte les yeux avec).

    J'ai séparé la gestion de la liste d'objet du reste.
    Et comme il s'agit d'une gestion de liste standard, j'ai pu utiliser une classe standard : "std::list<T>".
    Pour la valeur, c'est un simple int => "std::list<int>".

    Une transcription C++ de cette horreur, (j'ai converti l'utilisation des 2 variables globales bien moisies par l'utilisation d'un champs statique de classe, c'est pas top mais comme on n'a pas les axes de conceptions on fait dans le simple) :

    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
     
    struct Element
    {
        int valeur;
        Element(int valeur):valeur(valeur){};
     
        static std::list<Element> ListeDesElements;
    };
     
    std::list<Element> Element::ListeDesElements = std::list<Element>();
     
    void Ajouter(int valeur)
    {
        Element::ListeDesElements.push_back(Element(valeur));
    }
    Ce code est un peu comme le précédent mais sans faire sauter la classe Element (qui sert pas à grand-chose quand même.

    Ligne 5 de ce code, il y a un constructeur : "Element(int valeur):valeur(valeur){};"
    J'utilise ce qu'on appelle une liste d'initialisation : ":valeur(valeur)".
    C'est la méthode à privilégier.

    Mais je te propose un petit exercice : changer le constructeur mais sans utiliser la liste d'initialisation :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    Element(int valeur)
    {
       ...
    };
    Comment écrire le code pour initialiser le champ valeur de l'objet dans ce constructeur ?
    Indice : "this->" est ton ami.

  9. #9
    Membre averti
    Homme Profil pro
    Étudiant
    Inscrit en
    Juin 2015
    Messages
    27
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 42
    Localisation : Canada

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Juin 2015
    Messages : 27
    Par défaut
    Je crois que j’ai bien compris l’exercice que tu m’as proposé. Je comprends mieux ce que tu veux m’expliquer sur le « this », je pense bien. L’objet du code sert pas à grand-chose, je sais.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
     
    #include <iostream>
    #include "A.h"
     
    using namespace std;
     
    int main()
    {
        A a(5);
        a.Afficher();
        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
     
    #ifndef A_H
    #define A_H
     
     
    class A
    {
        public:
            A(int valeur);
            void Afficher()const;
        private:
            int valeur;
    };
     
    #endif // A_H
    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
     
    #include <iostream>
    #include "A.h"
     
    using namespace std;
     
    A::A(int valeur)
    {
        this->valeur=valeur;
    }
     
    void A::Afficher()const
    {
        cout << "valeur: " << valeur << endl;
    }

  10. #10
    Expert confirmé
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Février 2005
    Messages
    5 492
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Conseil

    Informations forums :
    Inscription : Février 2005
    Messages : 5 492
    Par défaut
    Exercice parfaitement exécuté.
    En espérant que les cours de conception objet suivront, dans ton cursus.

  11. #11
    Expert éminent

    Femme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2007
    Messages
    5 202
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2007
    Messages : 5 202
    Par défaut
    Cela dit, il y a une raison à utiliser la liste d'initialisation:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    A::A(int valeur) : valeur(valeur) {}
    La raison est que l'affectation dans le corps n'est pas toujours possible, et surtout survient après la construction de chaque membre.

    Sans passer par la liste d'initialisation, le membre valeur est d'abord initialisé par défaut (c'est à dire pas du tout pour un int), puis affecté avec la valeur du parametre valeur.
    Si cela n'a pas d'impact pour un entier, c'est beaucoup plus génant pour un certain nombre de classes, comme un vector, un array ou un pointeur.
    C'est encore plus flagrant avec des types non modifiables, ou n'ayant aucun constructeur par défaut (comme les références ou certaines classes).

    PS: j'insiste, car c'est vraiment important.

  12. #12
    Expert confirmé
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Février 2005
    Messages
    5 492
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Conseil

    Informations forums :
    Inscription : Février 2005
    Messages : 5 492
    Par défaut
    PS: j'insiste, car c'est vraiment important.
    Je suis tout à fait d'accord avec toi.

    Ici, c'est un exercice sur l'utilisation de "this" pour résoudre les problèmes d’ambiguïté.

    La liste d'initialisation est la méthode à suivre avec les constructeurs.

    Mais, à la tête des exemples de code sortie par son encadrant, on est encore loin de ces considérations, malheureusement.

  13. #13
    Membre averti
    Homme Profil pro
    Étudiant
    Inscrit en
    Juin 2015
    Messages
    27
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 42
    Localisation : Canada

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Juin 2015
    Messages : 27
    Par défaut
    Gros merci pour votre aides et vos explications. Oui, je devrais revoir le concept objet dans mon cours d'introduction à Java, mais j'ai trouve de la documentation sur le sujet sur ce site et je vais la lire.

  14. #14
    Expert éminent

    Femme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2007
    Messages
    5 202
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2007
    Messages : 5 202
    Par défaut
    Attention, la manière de travailler avec les objets est différente en C++ et en Java.
    En C++, tu peux les manipuler par valeur, tu disposes d'un destructeur dont tu sais exactement quand il sera appelé.
    En Java, au contraire, tout objet est manipulé en référence, toute méthode est "virtuelle".

    Dans les deux langages, certaines pratiques de l'autre sont impossibles ou déconseillées. (je pense à RAII, par exemple)

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. [AC-2010] ODBC : USER DSN VS SYSTEM DSN, j'aimerais comprendre.
    Par Geache dans le forum Access
    Réponses: 3
    Dernier message: 18/12/2013, 09h47
  2. J'aimerais comprendre pourquoi ça ne fonctionne pas
    Par JamesBond002 dans le forum Débuter avec Java
    Réponses: 13
    Dernier message: 28/05/2013, 15h49
  3. J'aimerai comprendre ce qu'est VPN
    Par andrianiaina dans le forum Hardware
    Réponses: 2
    Dernier message: 02/10/2010, 08h12
  4. J'aimerais comprendre ces messages
    Par BuzzLeclaire dans le forum Débuter
    Réponses: 4
    Dernier message: 16/10/2008, 13h46
  5. J'aimerais comprendre ....
    Par barbarello dans le forum C++
    Réponses: 14
    Dernier message: 24/01/2006, 19h39

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