Groupe : Membres
|
Reprise du dernier message de la page précédente :
Constante ou pas?
|
The cake is a lie!
Groupe : Membres
|
Non constante
De toute façon il est impossible de modifier un std::type_info et toutes les méthodes accessibles sont déclarées constantes alors cela ne change rien à l'utilisation.
|
Geek un jour, geek toujours !
Groupe : Membres
|
5.2.8:1§
Citation : Pas de titre
The result of a typeid expression is an lvalue of static type const std::type_info (18.5.1) and dynamic type const std::type_info or const name where name is an implementation-defined class derived from std::type_info which preserves the behavior described in 18.5.1.61) The lifetime of the object referred to by the lvalue extends to the end of the program. Whether or not the destructor is called for the type_info object at the end of the program is unspecified.
Donc référence constante
|
Groupe : Membres
|
|
Euh..."a" ?
Groupe : Membres
|
virtual
Description : virtual permet de supplanter une fonction membre d'une classe parent depuis une classe dérivée.
Langage : C++
Exemple :
Code : C++ 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 | class ClasseA
{
public :
void Fonction1() { cout << "ClasseA::Fonction1\n"; }
virtual void Fonction2() { cout << "ClasseA::Fonction2\n"; }
}
class ClasseB : public ClasseA
{
public :
void Fonction1() { cout << "ClasseB::Fonction1\n"; }
virtual void Fonction2() { cout << "ClasseB::Fonction2\n"; }
}
int main()
{
ClasseA a;
a.Fonction1() // Affichera "ClasseA::Fonction1"
a.Fonction2() // Affichera "ClasseA::Fonction2"
ClasseB b;
b.Fonction1() // Affichera "ClasseB::Fonction1"
b.Fonction2() // Affichera "ClasseB::Fonction2"
// Copie polymorphique
ClasseA *pa = &b;
pa->Fonction1() // Affichera "ClasseA::Fonction1"
pa->Fonction2() // Affichera "ClasseB::Fonction2" (grâce à virtual)
// Note : on aurait pu aussi utiliser une copie par référence
return 0;
}
|
|
Geek un jour, geek toujours !
Groupe : Membres
|
nono212 >> Dans ce contexte. Faut aussi ajouter l'héritage virtuel.
Ce qui me gène avec une liste de mot clé du C++, c'est un mot clé a rarement un sens unique et celui ci varie subtilement en fonction de l'utilisation qu'on en fait.
Par exemple, virtual, static, ...
|
Apprenez à utiliser la STL !!
Groupe : Membres
|
Au début de la rédaction j'aurais dit le contraire. Mais plus je vais en avant plus je rejoins cette idée. C'est très difficile de définir les mots-clés.
|
Groupe : Membres
|
Ah! Hein?
Et plus vous comprendrez le C++, plus vous verrez que à quel point ce langage ne peut être résumé à sa syntaxe.
Édité
le 31/05/2008 à 22:56:14
par lmghs
|
Groupe : Membres
|
dynamic_cast
Description : Transtypage;L'opérateur dynamic_cast est spécialisé dans le polymorphisme : les downcasts (classe mère vers classe fille) et les crosscasts (classe mère vers une autre classe mère). Il effectue un test du type avant le transtypage, si le transtypage est impossible : on retourne NULL dans le cas de pointeurs, ou on lance une exception avec des référence. Il faut ABSOLUMENT du polymorphisme, donc des méthodes virtuelles.
Langage : C++
Exemple et/ou commentaire :Code : C++ 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 | class mere1
{
public:
mere1() {}
virtual ~mere1() {}
void methode1() {}
virtual void methode1_polymorphique() {}
};
class mere2
{
public:
mere2() {}
virtual ~mere2() {}
void methode2() {}
virtual void methode2_polymorphique() {}
};
class fille: public mere, public mere2
{
fille() {}
~fille() {}
virtual void methode1_polymorphique() {}
virtual void methode2_polymorphique() {}
};
int main()
{
mere1* a = new fille;
fille* b = dynamic_cast<fille*>(a);
if(b == NULL) // on n'a pas pu transtyper, dynamic_cast retourne NULL
return -1;
b->methode2_polymorphique(); // autorise car fille dérive de mere2
a->methode2_polymorphique(); // INTERDIT
// de même :
mere2* c = dynamic_cast<fille*>(a);
/* équivaut à :
fille* tmp = dynamic_cast<fille*>(a);
c = static_cast<mere2*>(tmp);
*/
if(c == NULL) // on n'a pas pu transtyper, dynamic_cast retourne NULL
return -1;
c->methode2_polymorphique(); // autorisé
a->methode2_polymorphique(); // INTERDIT
delete a;
}
|
|
return 0;
Groupe : Membres
|
Peut on utiliser un switch avec autre chose qu'un int, comme un double, un string... ?
|
Groupe : Membres
|
|
Groupe : Membres
|
|
Groupe : Membres
|
A quelques 's' et "méthode" (=> s/méthode/fonction membre/) près leurs propositions me paraissent pas mal (c'est tout con mais j'aime bien le fait qu'ils emploient 'downcast', 'crosscast', 'supplanter').
Ceci dit, pour dynamic_cast, c'est peut être un peu court si on n'a pas percuté les différences entre types réel et type officiel (/ "dynamique" et "statique" ? J'ai oublié les termes qui sont usuellement employés). Plus le fait qu'il y a des contraintes de présence de vtable. (FAQ developpez ? ... Arf! Je viens de relire ce que l'on avait écrit et ... des fois un lien c'est bien.)
Pour bien faire, pour virtual, il faudrait faire tout un cours sur le LSP... (sans parler des histoires d'héritage virtuel)
... car comme déjà dit plein de fois, le C++ ne peut pas être réduit à une succession de mots clés. Typiquement, le downcasting doit être la solution de dernier recours. Il est très utile, mais rarement où un débutant croit qu'il est utile.
|
Groupe : Membres
|
Merci.
Je tente de corriger le dynamic_cast :
Citation : -dynamic_cast
Description : Transtypage ; L'opérateur dynamic_cast est spécialisé dans le polymorphisme : les downcasts (classe mère vers classe fille) et les crosscasts (classe mère vers une autre classe mère). Il effectue un test du type avant le transtypage, si le transtypage est impossible : on retourne 0 ( NULL
) dans le cas de pointeurs, ou on lance une exception avec des références. Il faut ABSOLUMENT du polymorphisme, donc des fonctions membres virtuelles.
Langage : C++
Exemple et/ou commentaire :Code : C++ 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 | class mere1
{
public:
mere1() {}
virtual ~mere1() {}
void f1() {}
virtual void f1_polymorphique() {}
};
class mere2
{
public:
mere2() {}
virtual ~mere2() {}
void f2() {}
virtual void f2_polymorphique() {}
};
class fille: public mere, public mere2
{
fille() {}
~fille() {}
virtual void f1_polymorphique() {}
virtual void f2_polymorphique() {}
};
int main(int, char**)
{
mere1* a = new fille;
fille* b = dynamic_cast<fille*>(a);
if(b == NULL) // on n'a pas pu transtyper, dynamic_cast retourne NULL.
return EXIT_FAILURE;
b->f2_polymorphique(); // autorise car fille dérive de mere2.
a->f2_polymorphique(); /* INTERDIT. */
// De même :
mere2* c = dynamic_cast<fille*>(a);
/*
Équivaut à :
fille* tmp = dynamic_cast<fille*>(a);
c = static_cast<mere2*>(tmp);
*/
if(c == NULL) // On n'a pas pu transtyper, dynamic_cast retourne NULL.
return EXIT_FAILURE;
c->f2_polymorphique(); // autorisé.
a->f2_polymorphique(); /* INTERDIT */
delete a;
}
|
[ FAC C++ developpez.com]
Pour ce qui est de virtual, je viens de voir que developpez.com propose qqch : http://cpp.developpez.com/faq/cpp/inde [...] ITION_virtual
Est-ce suffisant pour proposer simplement une redirection ?
|
The cake is a lie!
Groupe : Membres
|
virtual >> La description est extrêmement courte, manque d'infos sur la v-table qui peut augmenter la taille et le temps de calcul d'une application (Minime mais c'est à prendre en compte sinon on écrirais virtual partout !). Manque d'infos sur l'héritage virtuel (pour l'héritage en diamant). Différences entre méthodes virtuelles et méthodes virtuelles pures, qu'est-ce que ça modifie dans le comportement de la classe ?
dynamic_cast >> Les méthodes sont virtuelles, pas polymorphiques. Peut-on parler de polymorphisme si on a qu'une classe fille ? Comme tout transtypage, dynamic_cast n'est pas une solution à un mauvais design d'application. L'exception lancée est de type std::bad_cast.
|
Groupe : Membres
|
Merci.
Je re-tente de corriger le dynamic_cast :
Citation : -dynamic_cast
Description : Transtypage ; L'opérateur dynamic_cast est spécialisé dans le polymorphisme : les downcasts (classe mère vers classe fille) et les crosscasts (classe mère vers une autre classe mère). Il effectue un test du type avant le transtypage, si le transtypage est impossible : on retourne 0 ( NULL
) dans le cas de pointeurs, ou on lance une exception ( std::bad_cast ) avec des références. Il faut ABSOLUMENT du polymorphisme, donc des fonctions membres virtuelles.
Langage : C++
Exemple et/ou commentaire :Code : C++ 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 | class mere1
{
public:
mere1() {}
virtual ~mere1() {}
void f1() {}
virtual void f1_virtuelle() {}
};
class mere2
{
public:
mere2() {}
virtual ~mere2() {}
void f2() {}
virtual void f2_virtuelle() {}
};
class fille: public mere, public mere2
{
fille() {}
~fille() {}
virtual void f1_virtuelle() {}
virtual void f2_virtuelle() {}
};
int main(int, char**)
{
mere1* a = new fille;
fille* b = dynamic_cast<fille*>(a);
if(b == NULL) // on n'a pas pu transtyper, dynamic_cast retourne NULL.
return EXIT_FAILURE;
b->f2_virtuelle(); // autorise car fille dérive de mere2.
a->f2_virtuelle(); /* INTERDIT. */
// De même :
mere2* c = dynamic_cast<fille*>(a);
/*
Équivaut à :
fille* tmp = dynamic_cast<fille*>(a);
c = static_cast<mere2*>(tmp);
*/
if(c == NULL) // On n'a pas pu transtyper, dynamic_cast retourne NULL.
return EXIT_FAILURE;
c->f2_virtuelle(); // autorisé.
a->f2_virtuelle(); /* INTERDIT */
delete a;
return EXIT_SUCCES;
}
|
- Comme tout transtypage, dynamic_cast n'est pas une solution à un mauvais design d'application.
Lien : [ FAC C++ developpez.com]
|
Groupe : Membres
|
Citation : MatteXdynamic_cast >> Peut-on parler de polymorphisme si on a qu'une classe fille ?
a- D'abord je pinaille beaucoup.
Le polymorphisme réunit 4 choses selon la taxinomie de Lucas (?) Cardelli (wikipedia est normalement votre ami). Rapidement: La surcharge, et les convertions implicites parmi les polymorphismes ad'hoc. Le polymorphisme paramétrique (i.e. généricité par template en C++ ; NB le plus vieux de tous) et le polymorphisme d'inclusion (ou d'héritage selon les gens) parmi les polymorphismes universels.
Il y a eu une sorte de glissement sémantique depuis l'hégémonie des langages bridés OO. Maintenant les gens disent juste "polymorphisme" pour en fait désigner uniquement le polymorphisme d'inclusion.
b- Et maintenant je réponds à cette petite question qui appelle à pinailler.
Ma vision du polymorphisme d'inclusion, c'est avant tout la substituabilité (au sens du Principe de Substitution de Liskov). C'est à dire: on peut utiliser un objet d'un type qui dérive d'un type là où un objet du type parent est attendu. "virtual" introduit la possibilité liaison tardive: c'est à l'exécution que l'on détermine la vrai fonction à appeler. Mais ... on peut très bien juste rajouter des fonctions à un type sans altérer le comportement de ses autres fonctions. Et utiliser un objet de ce type enrichi là où l'on attendait un objet parent .. sans qu'aucun des deux ne dispose d'une fonction virtuelle.
Nous sommes toujours dans une situation où nous pouvons parler de polymorphisme (d'inclusion).
(Il y a encore moyen d'en parler pendant des pages et des pages)
PS-EDIT: "do" seul n'est pas un mot clé valide.
Édité
le 19/06/2008 à 19:07:02
par lmghs
|
Euh..."a" ?
Groupe : Membres
|
Virtual ça englobe pleins de trucs, il faudrait un cours dessus (j'exagère ?  ).
Et puis, virtual a plusieurs significations selon où il est placé...
Il faudrait un cours sur le polymorphisme en fait 
|
Groupe : Membres
|
Je vous remercie beaucoup de votre attention. Mais là, je suis (plus ou moins complètement) largué. 
(Faut avouer que mon bagage en C++ est vraiment petit, voir microscopique par rapport à toi, lmghs, et bien d'autres.)
Je t'enterrais de m'instruire prochainement, quand j'aurais plus de temps.
Pour le "do" j'ai déjà demandé à ce qu'il soit supprimé. 
|
Groupe : Membres
|
(En fait, il y a très peu de particularités du C++ dans ce que j'ai dit ^^)
|
Groupe : Membres
|
nan, mais c'est la "culture ++" .
|
Geek un jour, geek toujours !
Groupe : Membres
|
|
Groupe : Membres
|
Il existe des ressources en français qui connaissent Object Mentor ?... C'est énorme!
|
Geek un jour, geek toujours !
Groupe : Membres
|
Euh Object Mentor c'est très bien mais c'est pas en francais.
|
Groupe : Membres
|
Un commentaire: Les définitions des mots clés pour les types primitif sont pour la plupart pas correctes. Je ne peux pas fournir de corrections exactes puisque je n'ai pas le document ISO C++ avec moi, mais par example, il est incorrect de dire qu'un char peut contenir une valeur entre -128 et 127. Selon la standard, un char peut être signed ou unsigned. Donc de 0 à 255 ou de -128 à 127. Un autre exemple: le type "double", si je me rapelle bien, n'a aucun minimum ou maximum défini. La seule chose qui est certain, c'est qu'un double à au moins autant de précision qu'un float, et un double double à au moins autant de précision qu'un double.
De plus, la description de int est aussi incorrecte- Un int est différent sur les architectures 64-bit, par exemple. Je crois que le standard définit int comme ayant le nombre de bits de l'architecture (ex. int sur Windows XP a 32-bit d'espace, sur Windows XP 64-bit, il en a 64-bit).
Je vais essayer de me rapeller de poster les corrections nécéssaires, mais n'importe qui qui a le document du standard C++ pourrait faire ces mêmes corrections.
Édité
le 12/08/2008 à 17:18:44
par gparent
|
Groupe : Membres
|
L'erreur a déjà été signalée dans les première pages...
Les seules certitudes, c'est les inégalités entre tous les types, et le fait qu'un int ait au moins 16bits.
|
Groupe : Membres
|
Oui, ce que vous dites est juste. Mais les valeurs exposées sont celles du tableau du tuto ( http://www.siteduzero.com/tuto-3-1224- [...] tml#ss_part_2 , un peu plus bas ). Après, soit on dit la même chose que dans le tuto, même si c'est pas tout à fait la réalité, soit on sort les valeurs de la norme, qui ne sont pas (si je me trompe pas) des valeurs numériques mais des tailles relatives. Mélanger les deux n'aurait pas vraiment de sens (ou bien?).
Je suis un peu mitigé : on est sur le sdz, donc il serait logique d'avoir une correspondance entre le cours proposé et ce topic, mais en même temps c'est de C++ qu'on parle. Quel est votre point de vue?
|
Groupe : Membres
|
Ce n'est pas parce qu'il y a une erreur dans le tuto qu'il faut continuer avec.
AMA, La bonne approche consiste à réunir tous les types ensemble, sortir les inégalités officielles, et dire : "voilà pour telle architecture les valeurs typiques sont:", "Vous pourrez toujours les obtenir via ces constantes ... (cf <limits.h> et <limits>)", "si vous voulez *toujours* plus précis, cf <stdint.h> (C99 et C++0x) (IIRC)"
|
apprenti
Groupe : Membres
|
Le C++ est un langage normalisé, si tu donnes une information sur le langage mieux vaux qu'elle soit conforme à la norme, Mateo donne dans le cour des valeurs car ce sont celles que l'on retrouve le plus souvent sur les architectures et implementations actuel de la norme (même si je me demande si l'avenement du 64 bits, ne va pas finir par faire quelques changement). Le mieux serait de donner les 2 informations, tu donnes la norme, puis tu précise que la plus part du temps ces valeurs sont : ..., et tu peut aussi indiquer où les vérifier (std::numric_limits<type>)
Edit : grillé par lmghs
Édité
le 12/08/2008 à 18:24:57
par Freedom
|
Groupe : Membres
|
Au taf, sur une "vieille" Solaris, j'ai "2*sizeof(int) == sizeof(long) == sizeof(long long) == 8". Ce qui ne correspond pas au tableau du tuto.
|
Groupe : Membres
|
D'accord, alors je verrais pour corriger ça prochainement (faut que je contacte l'auteur des post et toussa). Merci de votre intérêt. 
[Je prendrais sûrement un passage du "langage c++".]
PS : si vous avez un lien vers la norme ce serait pas mal comme complément d'information.
|
Tutoriels
Communauté
Mon compte
Recherche
Livre d'or
Publicité
Hiura
399 Zéros connectés |
8 requêtes |
0.2405s (0.2196s)
