C++ C->；C++；在C++；在#未给出类型时定义（C样式）[MSV]

你好

我使用了以下C宏，但在C++中，它无法自动将

void*

强制转换为

type*

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

我知道，我可以这样做：

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

template <class T>
void malloc_safe_impl(T** p, size_t size)
{
    *p = static_cast<T*>(malloc(size));
}

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

但是我不想重写大部分的代码，因为使用了

MALLOC\u SAFE

有没有办法在不给宏指定类型的情况下执行此操作？也许是一些MSVC 2005

#pragma

/

\uu declspec

/其他

p、 我不能使用C编译器，因为我的代码是这个大型项目的一部分（数百个模块之一）。现在它在C++上。我知道，我可以单独构建代码。但它是旧代码，我只想快速移植它

问题是关于void*casting；）如果不可能，我将用MACRO\u SAFE\u CPP替换MACRO\u SAFE

---

谢谢我不建议这样做；这是一个可怕的代码，如果你使用C，你应该用C编译器（或者在Visual C++中作为C文件）编译< <强> > /p>

如果使用Visual C++，可以使用<代码> DeCyty< /C> >：

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

#定义MALLOC#u安全（变量、大小）\
{                                                   \
var=静态_铸造（malloc（尺寸））\
如果（！var）转到错误\
}

为了让James的答案更脏，如果您没有

decltype

支持，您也可以这样做：

template <typename T>
class auto_cast_wrapper
{
public:
    template <typename R>
    friend auto_cast_wrapper<R> auto_cast(const R& x);

    template <typename U>
    operator U()
    {
        return static_cast<U>(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 <typename R>
auto_cast_wrapper<R> auto_cast(const R& x)
{
    return auto_cast_wrapper<R>(x);
}

---

我在上扩展了这个实用程序（在C++11中）。不要用它来做坏事。

例如：

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

template <class T>
void malloc_safe_impl(T** p, size_t size)
{
    *p = static_cast<T*>(malloc(size));
}

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

模板
void malloc\u safe\u impl（T**p，尺寸\u T尺寸）
{
*p=静态_铸造（malloc（尺寸））；
}
#定义MALLOC_SAFE（var，size）{\
malloc_safe_impl（&var，size）\
如果（！var）转到错误\
}

有没有理由没有人直接将您的参数var转换为SAFE_MALOC（）？我的意思是，malloc（）返回一个指针。您将它存储在接受指针的某个位置。。。其他人已经指出了各种类型的整洁安全的东西。。。我只是想知道为什么这不起作用：

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

---

嗯。。。我知道。它病了，把类型安全抛到了窗外。但是一个直接的（（void*）（var））=转换并不总是有效。

你的内存是如何释放的？直接使用

free

或宏？为什么不能将代码编译为C程序？VisualC++将编译C.@ ZXCAT:哪种版本的MSVC？C++编译器，我熟悉C编译，如果文件被指定为C。同时，如果你正在替换宏，你可以考虑改为<代码>新< /代码> />代码>删除< /C> >而不是<代码> Malc /CuffyFux/Cuff>。我知道你说你不想这样做，这就是为什么我不提供它作为一个答案，只是一个考虑。重写代码真的那么糟糕吗？我的意思是，即使是C代码也很糟糕。它当然不属于C++程序。如果是我，即使花了整整几天的时间重写，我也会去做。“如果有必要的话，在我休息的时候。谢谢你，”詹姆斯。这就是我寻找的答案。糟糕，vs2010只是另一个注意事项，宏永远不应该是

{…}

，使用

do{…}而（0）

更安全。使用任何拖尾

，它的性能都会更好 >和> <代码>如果是“<代码>块”。+ 1，我看到的第一个真正的解决方案是C++被破坏的代码>空隙*/Cuth>行为。@：C++中的代码< >空> */COD>行为？考虑到它是静态类型的语言，我必须批准任何类型安全的移动，而且无论如何，C++中很少需要<代码>空白>代码>。我赞成它，它太变态了，不能投票。如果你投了反对票，我们可以平分分歧，说我们双方各投了半票；）正如David所说，我看不出静态类型语言要求您尊重静态类型系统有什么“缺陷”。我知道有些人不喜欢听这个，但语言有可能不同于C语言，同时也不会被破坏。作为个人规则，我从不遵循名为“多么变态”的链接。这是互联网；我甚至不想去想在那个链接上会发生什么。。。