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.