Discussion :

[mensoif]

Bonjours à tous, j'ai différentes questions que j'ai recherché dans la FAQ ou autres mais j'aurais aimé quelques réponses concises (mais pas trop non plus :p).

1er : Je n'ai pas trouvé d'indications sur l'opérateur -> et j'aimerais des précisions quant à son utilisation, sa signification et sa différence avec l'utilisation de * ou autre.

2em : le polymorphisme, j'aimerais bien savoir dans quel cas il doit être utilisé et pourquoi ? Ainsi que savoir pourquoi rendre les classes abstraites dans certains cas ?

3em : La notation friend ? Que permet-elle ? et quand l'utilisé ?

J'ai également croisé le paramètre ... (ailleurs que dans un catch) et je me demandais ce qu'il signifiait (et pour changer) quand devait-on l'utiliser ?

Je vous serrais très reconnaissant de m'éclairer sur ces points, car j'en aurais très bientôt besoin en interro..
Merci bcp d'avance.

[ZouBi]

1er : Je n'ai pas trouvé d'indications sur l'opérateur -> et j'aimerais des précisions quant à son utilisation, sa signification et sa différence avec l'utilisation de * ou autre.

L'opérateur -> cherche à remplacer cette écriture :

Code :

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

1
2
3
4
5
6
 
UneClasse * maClasse = new UneClasse;
 
(*maClasse).maMethode();
//Equivaut à
maClasse->maMethode();

J'en dis pas plus, tu devrais comprendre par toi même, sinon revoit tes bases sur les pointeurs.

2em : le polymorphisme, j'aimerais bien savoir dans quel cas il doit être utilisé et pourquoi ? Ainsi que savoir pourquoi rendre les classes abstraites dans certains cas ?

Alors là, expliquer le polymorphisme comme ça, c'est impossible.
Seul un livre, ou un tutorial pourra t'expliquer.

3em : La notation friend ? Que permet-elle ? et quand l'utilisé ?

Rendre une fonction "friend" à une classe, permettre à celle-ci d'avoir directement accès aux attributs sans passer par des accesseurs.

J'ai également croisé le paramètre ... (ailleurs que dans un catch) et je me demandais ce qu'il signifiait (et pour changer) quand devait-on l'utiliser ?

??? Quel paramètre ?

[koala01]

Salut, et bienvenue sur le forum.

(1) l'operateur -> permet d'accéder à un membre ou une méthode lorsqu'il faut y accéder depuis un pointeur.

(2) Le polymorphisme permet de définir des comportements spécifiques aux type réel des variable.

Tu peux alors faire cohabiter plusieurs variables dont le type de base est commun, en les considérant comme s'il s'agissait du type de base, mais t'assurer que leur comportement s'adaptera au type réel.

Par exemple, le comportement "manger" est commun à tous les animaux.

Mais une mouche et un lion ne mangent ni la même chose, ni de la même manière.

Comme la mouche et le lion sont tous les deux des "animaux" (sans précision), ils peuvent tous les deux hériter d'une classe "animal" qui se contenterait de savoir qu'il existe une fonction "manger".

Il te sera alors possible de gérer plusieurs mouches et plusieurs lions en même temps, en les considérant tous et toutes comme des animaux, et d'appeler le comportement "manger", qui correspondra alors réellement à ce que font les mouches ou les lions

Une classe abstraite est une classe dont on sait quel(s) compportement(s) on peut attendre d'elle, mais qui ne dispose pas (encore) de toutes les données qui permettent d'implémenter la manière dont ces comportements sont réalisés.

Ainsi, quand on parle d'un "animal", on a bien conscience du fait qu'il va manger, mais on ne sait pas encore dire comment il va s'y prendre.

On déclare alors la fonction comme étant virtuelle pure (comme n'ayant pas d'implémentation) dans la classe de base, ce qui rend de facto la classe de base abstraite.

Il nous appartient ensuite de définir cette fonction pour chaque classe "concrète" (la mouche et le lion, dans l'exemple ci-dessus)

(3) friend représente l'amitié d'une classe (ou d'une fonction) envers une autre classe.

Cela permet à une classe de dire "telle classe (ou fonction) est mon amie. Comme j'ai toute confiance en cette classe (ou fonction), je lui laisse libre accès à tout ce qui m'appartient, y compris à mes membres et méthodes privé(e)s"

Tu trouvera la réponse à la plupart des questions que tu peux te poser sur le sujet sur la page de la FAQ qui y est consacrée

Enfin, le paramètre ... est ce que l'on appelle l'ellipse.

Son role est de permettre de fournir un nombre inconnu de paramètres dont le type n'est pas connu à l'avance.

Quand il apparait dans un bloc catch, c'est généralement pour signaler "toute exception qui n'aurait pas été gérée", et c'est sensiblement le seul cas où il soit réellement opportun de l'utiliser.

Dans tous les autres cas, on préférera souvent le chainage de fonction, agrémenté, pourquoi pas, de la surcharge de celles-ci

Je te conseille de lire cette intervention qui date de quelques jours à peine sur le sujet

[mensoif]

Merci à vous deux pour vos réponses rapides et complètes. Cela m'a éclairé sur les questions que je me posais (notament le friend et le polymorphisme) quant à l'élipse je pense qu'il devait s'agir simplement d'un exemple pédagogique vus que je l'avais trouvé dans une fonction (ne me rappelle plus laquelle ).

Mais (il en fallait bien un ) j'ai encore du mal avec la notation -> (les pointeurs n'étant pas vraiment mes amis), j'ai consulté le tuto (sur ce même site). Et lorsque il s'agit de simplement contenir l'adresse mémoire d'une variable ca va.

Mais dès lors qu'on rentre dans les choses plus complexes je suis perdus. Je n'ai pas compris l'exemple de Zoubi (je ne critique pas, non non..), je n'arrive pas à me répresenter les valeurs des variables. Regarder par exemple ce bout de code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 typedef UneClasse * Ptr_t; (classe qui contient en donné membre int m_Info; UneClasse * m_Suivant; constructeur UneClasse (const int & Info, UneClasse * const Suivant = 0) ( je n'ai mis que le minimum )
 
Ptr_t Find (Ptr_t Ptr, int Val, bool Trie = false)
{
    for ( ; Ptr ; Ptr = Ptr->GetSuivant())
    {
        if (Trie && Ptr->GetInfo() > Val ) return 0;
        if (Ptr->GetInfo() == Val ) return Ptr;
    }
    return 0;
}

Vous l'aurez compris, cela parle des listes chaînées (simple en l'occurence).

Et bien dans ce code je n'arrive pas à visualiser sur quoi pointe quoi et encore moins lorsque '->' apparait. Si vous pouviez m'éclairer un peu la dessus.

ps : dsl de ne peut m'être présenté, mais j'ai un peu la pression
Et pour ce qui est du tuto liste chaine et pointeur, certaines chose méchappe, ne connaissant pas vraiment le language C.

Merci encore aux âmes généreuses

[Pierre.M]

Salut,

Dans ton exemple Ptr est un pointeur qui pointe sur un objet de type UneClasse. Cet objet possède un attribut lui-même pointeur sur un autre objet de type UneClasse: l'élément suivant de la liste. C'est ce qui permet de chainer la liste. Chaque élément à un attribut qui contient l'adresse de l'élément suivant dans la liste et cet attribut c'est m_suivant.

Pour l'opérateur ->, il n'implique pas vraiment de difficulté supplémentaire. Il te permets d'accéder aux méthodes et attributs (à condition qu'ils soient accessibles ) lorsque tu manipules un pointeur vers un objet.

(*m_suivant).getInfo();
Tu déréférences m_suivant pour accéder à la méthode getInfo() de l'objet qu'il pointe. Là tu fais l'appel depuis l'objet contenu à l'adresse stockée dans m_suivant.
m_suivant->getInfo();
Tu appels directement la méthode getInfo() de l'objet pointé par m_suivant. Là tu fais l'appel depuis l'adresse contenu dans m_suivant.

[mensoif]

olrit olrit !! merci pour toutes vos réponses, j'vais me remettre au boulot

Pit-être à une autre fois sur le fofo !!