Quand devrais-je utiliser typedef en C++ ?

Question

En programmation C++ (MFC), je n'ai jamais ressenti le besoin d'utiliser typedef, donc je ne sais pas vraiment à quoi ça sert. Où devrais-je l'utiliser? Y a-t-il des situations réelles où l'utilisation de typedef est préférée? Ou est-ce vraiment un mot-clé spécifique à C?

Answer 1

Méta-programmation avec modèles

typedef est nécessaire pour de nombreuses tâches de méta-programmation avec modèles -- chaque fois qu'une classe est traitée comme une "fonction de type de temps de compilation", un typedef est utilisé comme une "valeur de type de temps de compilation" pour obtenir le type résultant. Par exemple, considérons une simple métafonction pour convertir un type de pointeur en son type de base :

template
struct strip_pointer_from;

template
struct strip_pointer_from {   // Spécialisation partielle pour les types de pointeur
    typedef T type;
};

Exemple : l'expression de type strip_pointer_from::type évalue à double. Notez que la méta-programmation avec modèles n'est pas couramment utilisée en dehors du développement de bibliothèques.

Simplification des types de pointeur de fonction

typedef est utile pour donner un alias court et concis à des types de pointeurs de fonction compliqués :

typedef int (*my_callback_function_type)(int, double, std::string);

void RegisterCallback(my_callback_function_type fn) {
    ...
}

Answer 2

Dans le livre de Bjarne, il déclare que vous pouvez utiliser typedef pour résoudre les problèmes de portabilité entre des systèmes ayant des tailles d'entiers différentes. (c'est une paraphrase)

Sur une machine où sizeof(int) est de 4, vous pouvez

typedef int int32;

Utilisez ensuite int32 partout dans votre code. Lorsque vous passez à une implémentation de C++ où sizeof(int) est de 2, vous pouvez simplement changer le typdef

typedef long int32;

et votre programme fonctionnera toujours sur la nouvelle implémentation.

Answer 3

Utilisez avec un pointeur de fonction

Masquer les déclarations de pointeurs de fonction avec un typedef

void (*p[10]) (void (*)() );

Seuls quelques programmeurs peuvent dire que p est un "tableau de 10 pointeurs vers une fonction renvoyant void et prenant un pointeur vers une autre fonction qui renvoie void et ne prend aucun argument". La syntaxe lourde est presque indéchiffrable. Cependant, vous pouvez considérablement simplifier en utilisant des déclarations de typedef. Tout d'abord, déclarez un typedef pour "pointeur vers une fonction renvoyant void et ne prenant aucun argument" comme suit :

  typedef void (*pfv)();

Ensuite, déclarez un autre typedef pour "pointeur vers une fonction renvoyant void et prenant un pfv" basé sur le typedef que nous avons précédemment déclaré :

 typedef void (*pf_taking_pfv) (pfv);

Maintenant que nous avons créé le typedef pf_taking_pfv comme un synonyme du peu pratique "pointeur vers une fonction renvoyant void et prenant un pfv", déclarer un tableau de 10 de tels pointeurs est un jeu d'enfant :

  pf_taking_pfv p[10];

de

Answer 4

Just to provide some examples for the things said: STL containers.

 typedef std::map tFrobozMap;
 tFrobozMap frobozzes; 
 ...
 for(tFrobozMap::iterator it=frobozzes.begin(); it!=map.end(); ++it)
 {
     ...
 }

Il n'est pas rare d'utiliser aussi des typedefs comme

typedef tFrobozMap::iterator tFrobozMapIter;
typedef tFrobozMap::const_iterator tFrobozMapCIter;

Un autre exemple : utiliser des pointeurs partagés :

class Froboz;
typedef boost::shared_ptr FrobozPtr;

---

[mise à jour] Selon le commentaire - où les placer ?

Le dernier exemple - l'utilisation de shared_ptr - est facile : ce sont du matériel de type en-tête réel - ou du moins un en-tête anticipé. Vous avez de toute façon besoin de la déclaration anticipée pour shared_ptr, et l'un de ses avantages déclarés est qu'il est sûr de l'utiliser avec une déclaration anticipée.

Dit d'une autre manière : s'il y a un shared_ptr, vous devriez probablement utiliser le type uniquement à travers un shared_ptr, donc séparer les déclarations n'a pas beaucoup de sens.

(Oui, xyzfwd.h est pénible. Je ne les utiliserai que dans les points chauds - sachant que les points chauds sont difficiles à identifier. Blâmez le modèle de compilation+liaison C++...)

Les typedefs de conteneurs que j'utilise généralement là où la variable de conteneur est déclarée - par exemple localement pour une variable locale, en tant que membres de classe lorsque l'instance de conteneur réelle est un membre de classe. Cela fonctionne bien si le type de conteneur réel est un détail d'implémentation - ne causant aucune dépendance supplémentaire.

S'ils font partie d'une interface particulière, ils sont déclarés conjointement avec l'interface avec laquelle ils sont utilisés, par exemple

// FrobozMangler.h
#include "Froboz.h"
typedef std::map tFrobozMap;
void Mangle(tFrobozMap const & frobozzes); 

Cela devient problématique lorsque le type est un élément de liaison entre différentes interfaces - c'est-à-dire que le même type est nécessaire par plusieurs en-têtes. Quelques solutions :

• le déclarer conjointement avec le type contenu (adapté aux conteneurs fréquemment utilisés pour ce type)
• les déplacer dans un en-tête séparé
• les déplacer dans un en-tête séparé, et en faire une classe de données où le conteneur réel est à nouveau un détail d'implémentation

Je suis d'accord que les deux dernières options ne sont pas géniales, je ne les utiliserai que si je rencontre des problèmes (pas de manière proactive).

Answer 5

Typedef est utile dans de nombreuses situations.

Fondamentalement, cela vous permet de créer un alias pour un type. Lorsque vous devez changer le type, le reste du code pourrait rester inchangé (cela dépend bien sûr du code). Par exemple, disons que vous voulez itérer sur un vecteur C++

vector v;

...

for(vector::const_iterator i = v->begin(); i != v.end(); i++) {

// Des trucs ici

}

À l'avenir, vous pourriez penser à changer le vecteur par une liste, en fonction du type d'opérations que vous devez effectuer dessus. Sans typedef, vous devriez changer TOUTES les occurrences de vecteur dans votre code. Mais si vous écrivez quelque chose comme ceci :

typedef vector my_vect;

my_vect v;

...

for(my_vect::const_iterator i = v->begin(); i != v.end(); i++) {

// Des trucs ici

}

Maintenant, vous n'avez qu'à changer une ligne de code (c'est-à-dire de "typedef vector my_vect" à "typedef list my_vect") et tout fonctionne.

typedef vous fait également gagner du temps lorsque vous avez des structures de données complexes qui sont très longues à écrire (et difficiles à lire)