C-> C ++ Cast automatiquement le pointeur vide dans le pointeur Type en C ++ dans #define si le type n’est pas donné (style C)

Salut!

J’ai utilisé la macro C suivante, mais en C ++, il ne peut pas automatiquement convertir void* en type* .

 #define MALLOC_SAFE(var, size) { \ var = malloc(size); \ if (!var) goto error; \ } 

Je sais, je peux faire quelque chose comme ça:

 #define MALLOC_SAFE_CPP(var, type, size) { \ var = (type)malloc(size); \ if (!var) goto error; \ } 

Mais je ne veux pas réécrire une grande partie du code, où MALLOC_SAFE été utilisé.

Est-il possible de le faire sans donner le type à la macro? Peut-être que certains MSVC 2005 #pragma / __declspec / other?

ps: Je ne peux pas utiliser le compilateur C, car mon code fait partie (un des centaines de modules) du grand projet. Et maintenant, c’est en C ++. Je sais, je peux construire mon code séparément. Mais c’est du vieux code et je veux juste le porter rapidement.

La question concerne void * casting😉 Si ce n’est pas possible, je vais simplement remplacer MACRO_SAFE par MACRO_SAFE_CPP.

Je vous remercie!

Je ne recommande pas de faire cela; c’est un code terrible et si vous utilisez C, vous devez le comstackr avec un compilateur C (ou, en Visual C ++, sous forme de fichier C)

Si vous utilisez Visual C ++, vous pouvez utiliser decltype :

 #define MALLOC_SAFE(var, size) \ { \ var = static_cast(malloc(size)); \ if (!var) goto error; \ } 

Pour rendre la réponse de James encore plus sale, si vous n’avez pas de support decltype vous pouvez aussi le faire:

 template  class auto_cast_wrapper { public: template  friend auto_cast_wrapper auto_cast(const R& x); template  operator U() { return static_cast(mX); } private: auto_cast_wrapper(const T& x) : mX(x) {} auto_cast_wrapper(const auto_cast_wrapper& other) : mX(other.mX) {} // non-assignable auto_cast_wrapper& operator=(const auto_cast_wrapper&); const T& mX; }; template  auto_cast_wrapper auto_cast(const R& x) { return auto_cast_wrapper(x); } 

Ensuite:

 #define MALLOC_SAFE(var, size) \ { \ var = auto_cast(malloc(size)); \ if (!var) goto error; \ } 

J’ai développé cet utilitaire (en C ++ 11) sur mon blog . Ne l’utilisez pas pour autre chose que du mal.

Par exemple, comme ceci:

 template  void malloc_safe_impl(T** p, size_t size) { *p = static_cast(malloc(size)); } #define MALLOC_SAFE(var, size) { \ malloc_safe_impl(&var, size); \ if (!var) goto error; \ } 

Y at-il une raison pour laquelle personne jette simplement var , votre argument à SAFE_MALOC ()? Je veux dire, malloc () renvoie un pointeur. Vous le stockez dans un endroit qui accepte un pointeur … Il y a toutes sortes de choses propres à la sécurité du type que d’autres ont déjà signalées … Je me demande simplement pourquoi cela n’a pas fonctionné:

 #define MALLOC_SAFE(var,size) { \ (* (void **) & (var)) = malloc(size); \ if ( ! (var) ) goto error; \ } 

Ouais je sais. Il est malade et jette la police de sécurité par la fenêtre. Mais un straight ((void *) (var)) = cast ne fonctionnerait pas toujours.