为了让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);
}

字符串
然后：

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

型
别用它做坏事。

我不建议这样做;这是一段糟糕的代码，如果你使用的是C，你应该用C编译器编译它（或者，在Visual C++中，作为C文件）

如果你使用的是Visual C++，你可以使用decltype：

#define MALLOC_SAFE(var, size)                      \
{                                                   \
    var = static_cast<decltype(var)>(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; \
}

字符串

为什么没有人把你的参数 * var* 强制转换为SAFE_MALOC（）？我的意思是，malloc（） 返回指针。你把它存储在一个接受指针的地方…有很多其他人已经指出的类型安全的东西……我只是在想为什么这行不通

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

字符串
是啊我知道这是病态的，并抛出类型安全的权利窗外。但是直接的 *（（void ）（var））= 强制转换并不总是有效。