C++ 新的，微软除外

当我为Windows和Linux编写代码时，我遇到了一大堆问题。 微软Visual C++没有STNDIt头，但为此我编写了自己的.< /P> 现在我发现MS C++的新操作符没有抛出异常，所以我想尽快解决这个问题。我知道我可以用括号中的参数定义宏，我可以定义一个替换

MyClass x = new MyClass();

与

（或相当的东西），在C++和G ++中都有作用？

或者，如果这是不可能的，一个批处理文件来运行代码来实现这一点？

---

我已经变得相当依赖于这个异常被抛出。

< P>微软的C++编译器非常接近100%个标准，除了一些模糊的东西。不在new中抛出异常不是其中之一

---

除非你想重写“代码>新的<代码>（破坏目的）的所有用法。否则，微软的C++编译器非常接近100%个标准，除了一些模糊的东西之外。不在new中抛出异常不是其中之一

---

除此之外，你不能编写一个宏来检测这个表达式并相应地处理它，除非你想重写你所有的

new

（违背了这个目的）。

事实上，有一个简单的解决方案：使用一个确实会导致分配失败的宏。（链接代码是标准C++，可能需要编译器的调整。您可以使用Maloc来分配AlelaTeaFixSo.AthoStayStand源代码，并且对于DealLoTeaFas-For某个其他源是免费的）

---

旧答案 （这些替换确实需要调用代码的更改，因为C++语法是结构化的，这是不可避免的。然而，它们被编写为需要最少的更改，以便用作替换中的逻辑下降。真正的解决方案是在过去7年左右升级到MSVC版本。ING，实际上是在1998之前发布的C++标准。 解决一般情况很困难，但这里有一个近似值：

struct Thrower { // needs a better name
  void* p;
  Thrower(void* p) : p(p) {
    if (!p) throw std::bad_alloc();
  }
  ~Thrower() {
    if (std::uncaught_exception()) operator delete(p);
    // this is true when the object's ctor throws
  }
  operator void*() const { return p; }
};

int main() {
  int* p = new (Thrower(operator new(sizeof(int))) int(42);
  // int is a placeholder type, but shows you can still pass ctor parameters

  // with a macro becomes:
#define MYNEW(T) new (Thrower(operator new(sizeof(T))) T
  int* p = MYNEW(int)(42);
}

对于已知参数，可以避免使用宏并使其保持简单：

template<class T>
T* my_new() {
  T* p = new T();
  if (!p) throw std::bad_alloc();
  return p;
}
template<class T>
T* my_new(T const& value) {
  T* p = new T(value);
  if (!p) throw std::bad_alloc();
  return p;
}

int main() {
  int* p = my_new<int>();
  int* p2 = my_new<int>(*p);
}

模板
T*my_new（）{
T*p=新的T（）；
如果（！p）抛出std:：bad_alloc（）；
返回p；
}
模板
T*my_new（T常量和值）{
T*p=新的T（值）；
如果（！p）抛出std:：bad_alloc（）；
返回p；
}
int main（）{
int*p=my_new（）；
int*p2=我的新（*p）；
}
实际上，有一个简单的解决方案：一个会导致分配失败。（链接代码是标准C++，可能需要编译器的调整。

旧答案
（这些替换确实需要调用代码的更改，因为C++语法是结构化的，这是不可避免的。然而，它们被编写为需要最少的更改，以便用作替换中的逻辑下降。真正的解决方案是在过去7年左右升级到MSVC版本。ING，实际上是在1998之前发布的C++标准。
解决一般情况很困难，但这里有一个近似值：

struct Thrower { // needs a better name
  void* p;
  Thrower(void* p) : p(p) {
    if (!p) throw std::bad_alloc();
  }
  ~Thrower() {
    if (std::uncaught_exception()) operator delete(p);
    // this is true when the object's ctor throws
  }
  operator void*() const { return p; }
};

int main() {
  int* p = new (Thrower(operator new(sizeof(int))) int(42);
  // int is a placeholder type, but shows you can still pass ctor parameters

  // with a macro becomes:
#define MYNEW(T) new (Thrower(operator new(sizeof(T))) T
  int* p = MYNEW(int)(42);
}

对于已知参数，可以避免使用宏并使其保持简单：

template<class T>
T* my_new() {
  T* p = new T();
  if (!p) throw std::bad_alloc();
  return p;
}
template<class T>
T* my_new(T const& value) {
  T* p = new T(value);
  if (!p) throw std::bad_alloc();
  return p;
}

int main() {
  int* p = my_new<int>();
  int* p2 = my_new<int>(*p);
}

模板
T*my_new（）{
T*p=新的T（）；
如果（！p）抛出std:：bad_alloc（）；
返回p；
}
模板
T*my_new（T常量和值）{
T*p=新的T（值）；
如果（！p）抛出std:：bad_alloc（）；
返回p；
}
int main（）{
int*p=my_new（）；
int*p2=我的新（*p）；
}
最简单的替代方法是编写自己的
运算符new
实现，覆盖编译器的默认实现（如果您的MSVC版本支持）。这也是Roger在其链接答案中建议的

下面的程序演示了该尝试。
operator new
使用
malloc
和
free
从堆中分配内存。如果您正在为G++和MSVC进行条件编译，您也可以使用
HeapAlloc
和
HeapFree
来获得更多WinAP面向I的方法

#include <iostream>
#include <cstdlib>

void *operator new(unsigned int size) throw (std::bad_alloc) {
    void *ptr = malloc(size);

    if (!ptr)
        throw std::bad_alloc();
    return ptr;
}

void operator delete(void *ptr) throw () {
    free(ptr);
}

// Sample code to test the implementation.
int main(int argc, char **argv) {
    int *values[10];

    for (int i = 0; i < 10; ++i)
        values[i] = new int(i);
    for (int i = 0; i < 10; ++i)
        std::cout << *values[i] << std::endl;
    for (int i = 0; i < 10; ++i)
        delete values[i];
    return 0;
}

#包括
#包括
void*运算符新（无符号整数大小）抛出（std:：bad_alloc）{
void*ptr=malloc（尺寸）；
如果（！ptr）
抛出std:：bad_alloc（）；
返回ptr；
}
void操作符删除（void*ptr）抛出（）{
免费（ptr）；
}
//测试实现的示例代码。
int main（int argc，字符**argv）{
int*值[10]；
对于（int i=0；i<10；++i）
值[i]=新整数（i）；
对于（int i=0；i<10；++i）
std:：cout最简单的替代方法是编写自己的
操作符new
实现，覆盖编译器的默认实现（如果您的MSVC版本支持）。这也是Roger在其链接答案中建议的

下面的程序演示了该尝试。
operator new
使用
malloc
和
free
从堆中分配内存。如果您正在为G++和MSVC进行条件编译，您也可以使用
HeapAlloc
和
HeapFree
来获得更多WinAP面向I的方法

#include <iostream>
#include <cstdlib>

void *operator new(unsigned int size) throw (std::bad_alloc) {
    void *ptr = malloc(size);

    if (!ptr)
        throw std::bad_alloc();
    return ptr;
}

void operator delete(void *ptr) throw () {
    free(ptr);
}

// Sample code to test the implementation.
int main(int argc, char **argv) {
    int *values[10];

    for (int i = 0; i < 10; ++i)
        values[i] = new int(i);
    for (int i = 0; i < 10; ++i)
        std::cout << *values[i] << std::endl;
    for (int i = 0; i < 10; ++i)
        delete values[i];
    return 0;
}

#包括
#包括
void*运算符新（无符号整数大小）抛出（std:：bad_alloc）{
void*ptr=malloc（尺寸）；
如果（！ptr）
抛出std:：bad_alloc（）；
返回ptr；
}
void操作符删除（void*ptr）抛出（）{
免费（ptr）；
}
//测试实现的示例代码。
int main（int argc，字符**argv）{
int*值[10]；
对于（int i=0；i<10；++i）
值[i]=新整数（i）；
对于（int i=0；i<10；++i）
std：：请问您使用的是哪个版本的VC++？我向您保证，当前版本有符合标准的
新的
语句。我可以确认，从版本7.1（2003）开始（可能也在7.0/2002），它肯定符合中的标准