C++；，标准库例外 < C++ >“新H”下定义的 class bad_alloc : public exception { public: bad_alloc() throw() { } virtual ~bad_alloc() throw(); };

构造函数和析构函数都被明确指定为不抛出异常，它没有其他成员函数，但它继承了“exception”类

我的假设是，“new”操作符使用该类在分配过程中发生错误时抛出异常。但是怎么做呢？没有有效的成员函数，代码中实际如何使用它

---

我想知道，这个类“bad_alloc”声明的用法是什么？请帮助我。

有效的成员函数是从

异常继承的。
bad\u alloc
的目的是在查找
runtime\u错误
或
logic\u错误
时，无法捕捉到它。有效的成员函数从
异常
继承而来。
bad\u alloc
的目的是在查找
运行时错误
或
逻辑错误
时无法捕捉到它

没有有效的成员函数，代码中实际如何使用它

此类的目的仅是向
new
的调用方发出分配失败（=缺少可用内存）的信号。它不需要任何成员函数

没有有效的成员函数，代码中实际如何使用它

此类的目的仅是向
new
的调用方发出分配失败（=缺少可用内存）的信号。它不需要任何成员函数。
当某个例程分配内存失败时，会引发异常。如果您想发出这种情况的信号，可以这样使用：

throw std::bad_alloc();

此外，如果您想捕获内存分配错误，它如下所示：

try {
    ...do something here...
} catch (const std::bad_alloc& ex) {
    ...print an error message or handle the exception in some other way...
}

当某个例程无法分配内存时，会引发异常。如果您想发出这种情况的信号，可以这样使用：

throw std::bad_alloc();

此外，如果您想捕获内存分配错误，它如下所示：

try {
    ...do something here...
} catch (const std::bad_alloc& ex) {
    ...print an error message or handle the exception in some other way...
}

成员函数不是必需的-这是完全有效的：

throw 42;

大多数情况下，我们对异常的类型感兴趣，而对其他的不感兴趣。但是，标准异常确实从异常基类继承了一些函数。
成员函数不是必需的-这是完全有效的：

throw 42;

大多数情况下，我们对异常的类型感兴趣，而对其他的不感兴趣。但是，标准异常确实从异常基类继承了一些函数。
异常实际上不需要有成员。您可以声明类，以便显式捕获它们：

try {
    Foo * foo = new Foo();
}
catch(std::bad_alloc &) {
    std::cout << "could not allocate" << std::endl;
}

试试看{
Foo*Foo=新的Foo（）；
}
捕获（标准：：错误分配&）{
std:：cout异常实际上不需要有成员。您可以声明类以便显式捕获它们：

try {
    Foo * foo = new Foo();
}
catch(std::bad_alloc &) {
    std::cout << "could not allocate" << std::endl;
}

试试看{
Foo*Foo=新的Foo（）；
}
捕获（标准：：错误分配&）{
std:：cout创建并抛出类的对象：
抛出bad_alloc（）；
。
本质上，您可以抛出任何对象或值。然后可以在
catch（）
语句中使用它的类型来捕获此类异常

例如：

try
{
   // some code throwing exceptions
}
catch(const bad_alloc&)
{
    // this code is only run if an object of class bad_alloc is thrown
}
catch(const exception&)
{
    // this code is run if an object of class exception (or any unhandled derivated class) is thrown
}

您也可以忽略此类类，只抛出字符串（抛出“Error aclied！”），但您无法区分它们，因此您要么处理所有字符串，要么不处理任何字符串。
创建了类的对象，然后抛出：
抛出bad_alloc（）；
。
本质上，您可以抛出任何对象或值。然后可以在
catch（）
语句中使用它的类型来捕获此类异常

例如：

try
{
   // some code throwing exceptions
}
catch(const bad_alloc&)
{
    // this code is only run if an object of class bad_alloc is thrown
}
catch(const exception&)
{
    // this code is run if an object of class exception (or any unhandled derivated class) is thrown
}

您也可以忽略这些类，只抛出字符串（抛出“Error ocated！”），但无法区分它们，因此您要么处理所有字符串，要么不处理任何字符串。
这是新运算符的代码。没有什么特别的。它只抛出此类的一个实例

#define _RAISE(x)   throw (x)

void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
        {       // try to allocate size bytes
        void *p;
        while ((p = malloc(size)) == 0)
                if (_callnewh(size) == 0)
                {       // report no memory
                static const std::bad_alloc nomem;
                _RAISE(nomem);
                }

        return (p);
        }

这是一个新操作符的代码。没什么特别的。它只是抛出这个类的一个实例

#define _RAISE(x)   throw (x)

void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
        {       // try to allocate size bytes
        void *p;
        while ((p = malloc(size)) == 0)
                if (_callnewh(size) == 0)
                {       // report no memory
                static const std::bad_alloc nomem;
                _RAISE(nomem);
                }

        return (p);
        }

当
new
分配内存失败时，将引发
错误\u alloc
异常

经典C<代码> MalCube（）/Cyto>通过返回<代码> null <代码>指针发出问题，但是在C++中<代码>新< /COD>操作符抛出异常。然后，您可以捕获异常：
try {
    int * bigArray = new int[1024*1024*1024] ;
}
catch (bad_alloc& ex) { 
    cout<<"bad_alloc :"<<ex.what()<<endl ;
}

试试看{
int*bigArray=newint[1024*1024*1024]；
}
捕获（错误分配和释放）{
coutA
bad_alloc
异常在
new
分配内存失败时抛出

经典C<代码> MalCube（）/Cyto>通过返回<代码> null <代码>指针发出问题，但是在C++中<代码>新< /COD>操作符抛出异常。然后，您可以捕获异常：
try {
    int * bigArray = new int[1024*1024*1024] ;
}
catch (bad_alloc& ex) { 
    cout<<"bad_alloc :"<<ex.what()<<endl ;
}

试试看{
int*bigArray=newint[1024*1024*1024]；
}
捕获（错误分配和释放）{
cout虽然请求4 gig内存很可能导致可捕获的std:：bad_alloc异常，但捕获bad_alloc通常有点冒险

try {
  char * one_byte = new char(42);
}
catch (std::bad_alloc & except) {
  // Doing anything but calling exit here will almost certainly fail.
}

虽然请求4 Gig内存很可能会导致可捕获的std:：bad_alloc异常，但捕获bad_alloc通常有点冒险

try {
  char * one_byte = new char(42);
}
catch (std::bad_alloc & except) {
  // Doing anything but calling exit here will almost certainly fail.
}

在大多数情况下，应该捕获常量引用，而不仅仅是引用，不会造成伤害。：）应该捕获常量引用，而不仅仅是引用，在大多数情况下不会造成伤害。：）