Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://en.cppreference.com/w/cpp/language/../memory/new/bad_array_new_length.html below:

std::bad_array_new_length - cppreference.com

std::bad_array_new_length is the type of the object thrown as exceptions by the new-expressions to report invalid array lengths if

1. Array length is negative,
2. Total size of the new array would exceed implementation-defined maximum value,
3. The number of initializer-clauses exceeds the number of elements to initialize.

Only the first array dimension may generate this exception; dimensions other than the first are constant expressions and are checked at compile time.

Inheritance diagram

bad_array_new_length() noexcept;

bad_array_new_length( const bad_array_new_length& other ) noexcept;

Constructs a new bad_array_new_length object with an implementation-defined null-terminated byte string which is accessible through what().

1) Default constructor.

Copy constructor. If

and

both have dynamic type

then

.

bad_array_new_length& operator=( const bad_array_new_length& other ) noexcept;

Assigns the contents with those of other. If *this and other both have dynamic type std::bad_array_new_length then std::strcmp(what(), other.what()) == 0 after assignment.

*this

virtual const char* what() const noexcept;

Returns the explanatory string.

Pointer to an implementation-defined null-terminated string with explanatory information. The string is suitable for conversion and display as a std::wstring. The pointer is guaranteed to be valid at least until the exception object from which it is obtained is destroyed, or until a non-const member function (e.g. copy assignment operator) on the exception object is called.

The returned string is encoded with the ordinary literal encoding during constant evaluation.

Implementations are allowed but not required to override what().

Three conditions where std::bad_array_new_length should be thrown:

#include <climits>
#include <iostream>
#include <new>
 
int main()
{
    try
    {
        int negative = -1;
        new int[negative];
    }
    catch (const std::bad_array_new_length& e)
    {
        std::cout << "1) " << e.what() << ": negative size\n";
    }
 
    try
    {
        int small = 1;
        new int[small]{1,2,3};
    }
    catch (const std::bad_array_new_length& e)
    {
        std::cout << "2) " << e.what() << ": too many initializers\n";
    }
 
    try
    {
        long large = LONG_MAX;
        new int[large][1000];
    } 
    catch (const std::bad_array_new_length& e)
    {
        std::cout << "3) " << e.what() << ": too large\n";
    }
 
    std::cout << "End\n";
}

Possible output:

1) std::bad_array_new_length: negative size
2) std::bad_array_new_length: too many initializers
3) std::bad_array_new_length: too large
End

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4