Discussion :

[cquilgars]

Bonjour à tous,

Est-il possible d'obtenir le nom d'une classe par une variable contextuelle à l'image de __LINE__ (ou autre méthode) ?

Pour illustrer mon besoin, voici un bout de 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
 
class MaClasse {
  public:
    MaClasse();
    ~MaClasse();
 
    void* operator new(size_t Taille) {
      printf("Allocation [%d] pour <%s>\n",Taille,__CLASSNAME__);
      return (malloc(Taille));
    };
 
    void operator delete(void* Handle) {
      printf("Liberation <%x> pur <%s>\n",Handle,__CLASSNAME__);
      free(Handle);
    };
}

L'objectif est de faire profiter les classes héritant de "MaClasse" et permettre de superviser les new et delete sur ces dernières ...

Par avance merci

[Laurent Gomila]

Ce dépend du compilo. A ma connaissance certains définissent une macro pour connaître la fonction courante, mais pas la classe.

Par ailleurs, tes surcharges de new et delete devraient être statiques.

[cquilgars]

Ce dépend du compilo.

Mon compilateur est gcc... J'ai fait lecture du man gcc mais je ne trouve pas mon bonheur (ou je passe à côté de l'info )

Merci encore pour ton aide

[cquilgars]

Pour toute personne concernée, j'ai trouvé mon bonheur...

La variable est la suivante : __PRETTY_FUNCTION__ sous gcc

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
 
extern "C" {
extern int printf (char *, ...);
}
class a {
public:
void sub (int i)
{
printf ("__FUNCTION__ = %s\n", __FUNCTION__);
printf ("__PRETTY_FUNCTION__ = %s\n", __PRETTY_FUNCTION__);
}
};
int
main (void)
{
a ax;
ax.sub (0);
return 0;
}

Le resultat est la suivant :

Code :

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

1
2
3
 
__FUNCTION__ = sub
__PRETTY_FUNCTION__ = void a::sub(int)

[Laurent Gomila]

Oui, mais cela donne quoi dans le cas d'une fonction héritée, comme dans ton code initial ?

[Luc Hermitte]

Tu as des trucs propriétaires avec GCC:
- backtrace te permet d'obtenir le contexte d'exécution ; il faut obligatoirement compiler avec -E, et penser à filtrer les fonctions utilitaires utilisées pour l'analyse dynamique du contexte courant
- __cxx_abi::demangle (ou un nom comme cela) que tu devras utiliser sur les symbôles obtenus avec le backtrace (et auxquels tu auras supprimé ce qui dépasse à partir du signe '+') pour obtenir un nom lisible.

Faire attention à la mémoire, on manipule des char* à gérer à la main. Cela vaut le coup de tout encapsuler (gestion des erreurs d'utilisation de ses fonctions) avec des std::string. Comme d'hab.

Pas me demander le code, ne me balladant pas avec.


Autre solution: un demangle appliqué sur le type exact des objets (-> typeid) que tu alloues. Ce qui va impliquer de ne jamais pouvoir passer par new/delete, mais de devoir utiliser une factory.