Bon ben , là j'ai un autre soucis. C'est à dire, qu'après avoir voulu retrouver le nom de la fonction, j'aimerai retrouver le type d'une structure.
par exemple:
j'ai deux type de structures, struct1 & struct2.
suivant si c'est l'une ou l'autre, j'aimerai y appliqué une opération différente.
en fait une fonction du type sizeof, qui s'appellerai typeof, et qui renverrais le type de la donnée passée en paramètre.
Une telle fonction exixte-t-elle ?.
Merci pour votre aide passée et future.
kanze
GaHweL wrote:
Bon ben , là j'ai un autre soucis. C'est à dire, qu'après avoir voulu retrouver le nom de la fonction, j'aimerai retrouver le type d'une structure.
par exemple:
j'ai deux type de structures, struct1 & struct2.
suivant si c'est l'une ou l'autre, j'aimerai y appliqué une opération différente.
en fait une fonction du type sizeof, qui s'appellerai typeof, et qui renverrais le type de la donnée passée en paramètre.
Une telle fonction exixte-t-elle ?.
Elle existe. Elle s'appelle typeid, et elle renvoie un std::type_info. (En fait, comme sizeof, c'est un opérateur, et non une fonction.) Et la classe type_info a bien une fonction name, ce qui veut dire que tu peut écrire des choses comme:
std::cout << typeid( *p ).name() << std::endl ;
Si le type pointé par p est polymorphique, tu aurais même le nom du type de l'objet réel, et non le type déclaré.
La norme ne dit rien sur comment la chaine renvoyée est formattée. Certains compilateurs te donnent quelque chose d'utiles, d'autres non.
-- James Kanze GABI Software Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
GaHweL wrote:
Bon ben , là j'ai un autre soucis. C'est à dire, qu'après
avoir voulu retrouver le nom de la fonction, j'aimerai
retrouver le type d'une structure.
par exemple:
j'ai deux type de structures, struct1 & struct2.
suivant si c'est l'une ou l'autre, j'aimerai y appliqué une
opération différente.
en fait une fonction du type sizeof, qui s'appellerai typeof,
et qui renverrais le type de la donnée passée en paramètre.
Une telle fonction exixte-t-elle ?.
Elle existe. Elle s'appelle typeid, et elle renvoie un
std::type_info. (En fait, comme sizeof, c'est un opérateur, et
non une fonction.) Et la classe type_info a bien une fonction
name, ce qui veut dire que tu peut écrire des choses comme:
std::cout << typeid( *p ).name() << std::endl ;
Si le type pointé par p est polymorphique, tu aurais même le nom
du type de l'objet réel, et non le type déclaré.
La norme ne dit rien sur comment la chaine renvoyée est
formattée. Certains compilateurs te donnent quelque chose
d'utiles, d'autres non.
--
James Kanze GABI Software
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Bon ben , là j'ai un autre soucis. C'est à dire, qu'après avoir voulu retrouver le nom de la fonction, j'aimerai retrouver le type d'une structure.
par exemple:
j'ai deux type de structures, struct1 & struct2.
suivant si c'est l'une ou l'autre, j'aimerai y appliqué une opération différente.
en fait une fonction du type sizeof, qui s'appellerai typeof, et qui renverrais le type de la donnée passée en paramètre.
Une telle fonction exixte-t-elle ?.
Elle existe. Elle s'appelle typeid, et elle renvoie un std::type_info. (En fait, comme sizeof, c'est un opérateur, et non une fonction.) Et la classe type_info a bien une fonction name, ce qui veut dire que tu peut écrire des choses comme:
std::cout << typeid( *p ).name() << std::endl ;
Si le type pointé par p est polymorphique, tu aurais même le nom du type de l'objet réel, et non le type déclaré.
La norme ne dit rien sur comment la chaine renvoyée est formattée. Certains compilateurs te donnent quelque chose d'utiles, d'autres non.
-- James Kanze GABI Software Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Fabien LE LEZ
On 1 Aug 2005 06:11:38 -0700, "GaHweL" :
j'ai deux type de structures, struct1 & struct2.
Note en passant : il n'y a pas de structures en C++, il n'y a que des classes. Les mots-clefs "struct" et "class" sont quasiment équivalents ; la différence est que "struct" indique que tout est public par défaut.
Les deux codes suivants font la même chose :
struct Machin: public Truc { private: int n; };
class Machin: public Truc { private: int n; };
suivant si c'est l'une ou l'autre, j'aimerai y appliqué une opération différente.
Généralement, la fonction en question est membre (éventuellement virtuel) de la classe struct1 (ou struct2).
Une autre possibilité :
void f (struct1 const& machin) { ... }
void f (struct2 const& machin) { ... }
Un cas courant :
class struct_base { ... }; class struct1: public struct_base { ... }; class struct2: public struct_base { ... };
void f (struct_base const& machin);
int main() { struct1 s1; struct2 s2; f (s1); f (s2); }
void f (struct_base const& machin) { /* Ici, on cherche à savoir si machin est un "struct1". Comme je l'ai dit, l'idéal est d'avoir une fonction virtuelle de struct_base, qui indique que faire -- ou, mieux, qui fait l'action voulue.
Il y a toutefois une possibilité : dynamic_cast<> */ if (dynamic_cast<struct1 const*>(machin) != 0) { cerr << "machin est un struct1" << endl; } else { cerr << "machin n'est pas un struct1" << endl; } }
Note qu'il existe un typeof en C++ (enfin, je crois), mais j'avoue ne l'avoir jamais utilisé, ni même être sûr de savoir à quoi il sert.
Note aussi que si struct1d dérive de struct1, alors un objet de type struct1d _est_ un objet de type struct1.
On 1 Aug 2005 06:11:38 -0700, "GaHweL" <gahwel@gmail.com>:
j'ai deux type de structures, struct1 & struct2.
Note en passant : il n'y a pas de structures en C++, il n'y a que des
classes.
Les mots-clefs "struct" et "class" sont quasiment équivalents ; la
différence est que "struct" indique que tout est public par défaut.
Les deux codes suivants font la même chose :
struct Machin: public Truc
{
private: int n;
};
class Machin: public Truc
{
private: int n;
};
suivant si c'est l'une ou l'autre, j'aimerai y appliqué une opération
différente.
Généralement, la fonction en question est membre (éventuellement
virtuel) de la classe struct1 (ou struct2).
Une autre possibilité :
void f (struct1 const& machin)
{
...
}
void f (struct2 const& machin)
{
...
}
Un cas courant :
class struct_base { ... };
class struct1: public struct_base { ... };
class struct2: public struct_base { ... };
void f (struct_base const& machin);
int main()
{
struct1 s1;
struct2 s2;
f (s1);
f (s2);
}
void f (struct_base const& machin)
{
/*
Ici, on cherche à savoir si machin est un "struct1".
Comme je l'ai dit, l'idéal est d'avoir une fonction virtuelle de
struct_base, qui indique que faire -- ou, mieux, qui fait l'action
voulue.
Il y a toutefois une possibilité : dynamic_cast<>
*/
if (dynamic_cast<struct1 const*>(machin) != 0)
{
cerr << "machin est un struct1" << endl;
}
else
{
cerr << "machin n'est pas un struct1" << endl;
}
}
Note qu'il existe un typeof en C++ (enfin, je crois), mais j'avoue ne
l'avoir jamais utilisé, ni même être sûr de savoir à quoi il sert.
Note aussi que si struct1d dérive de struct1, alors un objet de type
struct1d _est_ un objet de type struct1.
Note en passant : il n'y a pas de structures en C++, il n'y a que des classes. Les mots-clefs "struct" et "class" sont quasiment équivalents ; la différence est que "struct" indique que tout est public par défaut.
Les deux codes suivants font la même chose :
struct Machin: public Truc { private: int n; };
class Machin: public Truc { private: int n; };
suivant si c'est l'une ou l'autre, j'aimerai y appliqué une opération différente.
Généralement, la fonction en question est membre (éventuellement virtuel) de la classe struct1 (ou struct2).
Une autre possibilité :
void f (struct1 const& machin) { ... }
void f (struct2 const& machin) { ... }
Un cas courant :
class struct_base { ... }; class struct1: public struct_base { ... }; class struct2: public struct_base { ... };
void f (struct_base const& machin);
int main() { struct1 s1; struct2 s2; f (s1); f (s2); }
void f (struct_base const& machin) { /* Ici, on cherche à savoir si machin est un "struct1". Comme je l'ai dit, l'idéal est d'avoir une fonction virtuelle de struct_base, qui indique que faire -- ou, mieux, qui fait l'action voulue.
Il y a toutefois une possibilité : dynamic_cast<> */ if (dynamic_cast<struct1 const*>(machin) != 0) { cerr << "machin est un struct1" << endl; } else { cerr << "machin n'est pas un struct1" << endl; } }
Note qu'il existe un typeof en C++ (enfin, je crois), mais j'avoue ne l'avoir jamais utilisé, ni même être sûr de savoir à quoi il sert.
Note aussi que si struct1d dérive de struct1, alors un objet de type struct1d _est_ un objet de type struct1.
Falk Tannhäuser
GaHweL wrote:
j'ai deux type de structures, struct1 & struct2.
suivant si c'est l'une ou l'autre, j'aimerai y appliqué une opérati on différente.
Il semblerait que tu cherches les fonctions membres virtuelles ?
