Discussion :

[deubelte]

Bonjour

J'ai du mal à comprendre le prototype suivant:

Code :

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

_obj((int(*)(const size_t &))::hash),

Il s'agit d'une assignation.

_objest égal à (int(*)(const size_t &))::hash.

Mais je ne comprends pas (int(*)(const size_t &))::hash.

(int(*)(const size_t &)) est la signature d'un pointeur sur fonction.
qui prend comme comme argument une référence constante de type size_t, et qui renvoie un objet de type unsigned.

mais que signifie la résolution de portée?
En gros, c'est quoi:
(int(*)(const size_t &))::hash

Merci

[Arzar]

Bonjour,

Je pense que le but est de caster la fonction globale hash() en une fonction de type (unsigned (*)(const size_t &)).

Pour rappel "::" devant une fonction permet de forcer la résolution vers le namespace global, par exemple :

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
20
21
22
23
24
25
26
27
28
29
void toto()
{
   std::cout << "global namespace" << std::endl;
}
 
 
namespace n
{
   void toto()
   {
      std::cout << "namespace n" << std::endl;
   }
 
   void foo1()
   {
      toto();
   }
 
   void foo2()
   {
      ::toto();
   }
}
 
int main()
{
   n::foo1();
   n::foo2();
}

Maintenant, pourquoi un tel cast ?
Je miserais sur le fait que le code vient peut être d'une bibliothèque très cross-plateforme (boost ?) et que l'auteur du code a peut-être eu envie de faire taire un warning d'un compilo un peut trop chatouilleux.

[deubelte]

ok merci pour la réponse.
J'en ai un autre, bcp plus générale sur les macros:
Je sais ce que signifie:

#define T int ;

mais pas:

Code :

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

1
2
 
#define T int,double ;

avec la virgule.


J'ai un exemple concret issu de la librairie RogueWave:

Code :

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

#    define RW_ALLOCATOR_PARAMETER(type)             ,class A = RW_SL_STD(allocator)< type >

Je ne comprend pas la macro suivante.
Merci

[Fabllot]

Bonjour,
Tout d'abord attention ! Pas de ";" à la fin de tes macros tu vas avoir des problèmes sinon !

Une macro (nom complet: "macro-préprocesseur") est appliquée avant la compilation du code. Ce qui signifie que toutes les macros sont remplacées par leur signification avant que le compilateur essaie de comprendre le code...

Si tu veux comprendre une macro un peu complexe, une idée serait de remplacer dans le code la macro par sa valeur, et tu verras le code que le compilateur voit...
Pour ton exemple concret, je pense que la macro doit être utilisé dans un cas très précis... Peut-être si tu as le code qui utilise la macro cela sera plus facile à t'expliquer.

[deubelte]

Voici l'ensemble:

Code :

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

1
2
template <class K, class T, class H, class EQ RW_ALLOCATOR_PARAMETER(K) >
class RWTExport RWTValHashMap

Code :

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

#    define RW_ALLOCATOR_PARAMETER(type)             ,class A = RW_SL_STD(allocator)< type >

Code :

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

#  define RW_SL_STD(RW_NAME)             std::RW_NAME

[deubelte]

En fait, j'ai compris.
Mais ces processeurs, c'est quand même se compliquer la vie.

Par exemple ceci:

Code :

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

#define RW_NAMESPACE(x) namespace x

Je vois vraiment pas ce que ça apporte. Comme si c'était plus rapide ou plus clair.

[Fabllot]

En fait, j'ai compris.

C'est cool alors !

Mais ces processeurs, c'est quand même se compliquer la vie.

Par exemple ceci:

Code :

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

#define RW_NAMESPACE(x) namespace x

Je vois vraiment pas ce que ça apporte. Comme si c'était plus rapide ou plus clair.

Les macros sont bien utiles dans certains cas... Elles sont généralement plus utilisées en C qu'en C++, mais on en retrouve pas mal en C++ tout de même.

Une macro peut rendre un code plus "rapide"... dans certains cas, c'est un peu l'équivalent de "inline", ce qui évite un appel de fonction.
En C, je les utilise pas mal pour définir des structures et fonctions proches les unes des autres (qui ne varient par exemple que par les types)... Dans ce cas c'est un peu l'équivalent des templates C++.
Et on peut donner beaucoup d'autres exemples de l'utilité des macros...

Après il est vrai que certain en abuse et qu'un code avec (beaucoup de) macros peut être plus compliqué à débugger, surtout dans les codes des macros...

[3DArchi]

C'est cool alors !

Les macros sont bien utiles dans certains cas... Elles sont généralement plus utilisées en C qu'en C++, mais on en retrouve pas mal en C++ tout de même.

Une macro peut rendre un code plus "rapide"... dans certains cas, c'est un peu l'équivalent de "inline", ce qui évite un appel de fonction.
En C, je les utilise pas mal pour définir des structures et fonctions proches les unes des autres (qui ne varient par exemple que par les types)... Dans ce cas c'est un peu l'équivalent des templates C++.
Et on peut donner beaucoup d'autres exemples de l'utilité des macros...

Après il est vrai que certain en abuse et qu'un code avec (beaucoup de) macros peut être plus compliqué à débugger, surtout dans les codes des macros...

Ce sont surtout des exemples C. Les fonctions inline, les const, etc. permettent d'éviter les macros en C++ là où en C elles sont classiquement utilisées.
Ceci dit les projets C++ que j'ai croisé utilisent des macros.
Sinon, pour jongler avec des macros comme un pro : Boost.Preprocessor.