Condividi tramite

<new> operatori ed enumerazioni

  • Articolo

enum align_val_t

enum class align_val_t : size_t {};

operator delete

Funzione chiamata da un'espressione delete per deallocare l'archiviazione per singoli oggetti.

void operator delete(void* ptr) noexcept;
void operator delete(void *, void*) noexcept;
void operator delete(void* ptr, const std::nothrow_t&) noexcept;

Parametri

ptr
Puntatore il cui valore deve essere reso non valido dall'eliminazione.

Osservazioni:

La prima funzione viene chiamata da un'espressione delete per eseguire il rendering del valore non ptr valido. Il programma può definire una funzione con questa firma che sostituisce la versione predefinita della libreria standard C++. Il comportamento richiesto consiste nell'accettare un valore di ptr che è nullptr o che è stato restituito da una chiamata precedente a operator new.

Il comportamento predefinito di un nullptr valore in consiste nell'eseguire ptr alcuna operazione. Qualsiasi altro valore di ptr deve essere un valore restituito in precedenza da una new chiamata come descritto in precedenza. Il comportamento predefinito per un valore non Null di ptr consiste nel recuperare l'archiviazione allocata dalla chiamata precedente. Non è specificato in quali condizioni parte o in tutte queste risorse di archiviazione recuperate viene allocata da una chiamata successiva a operator newo a una delle callocfunzioni , malloco realloc .

La seconda funzione viene chiamata da un'espressione di posizionamento delete corrispondente a un'espressione new del formato new( std::size_t ). Non esegue alcuna operazione.

La terza funzione viene chiamata da un'espressione di posizionamento delete corrispondente a un'espressione new del formato new( std::size_t, const std::nothrow_t& ). Il programma può definire una funzione con questa firma che sostituisce la versione predefinita della libreria standard C++. Il comportamento richiesto consiste nell'accettare un valore di ptr ovvero nullptr o restituito da una chiamata precedente a operator new. Il comportamento predefinito consiste nel valutare delete( ptr ).

Esempio

Vedere operator new per un esempio che usa operator delete.

operator delete[]

Funzione chiamata da un'espressione delete per deallocare l'archiviazione per una matrice di oggetti.

void operator delete[](void* ptr) noexcept;
void operator delete[](void *, void*) noexcept;
void operator delete[](void* ptr, const std::nothrow_t&) noexcept;

Parametri

ptr
Puntatore il cui valore deve essere reso non valido dall'eliminazione.

Osservazioni:

La prima funzione viene chiamata da un'espressione delete[] per rendere non valido il valore di ptr. La funzione è sostituibile perché il programma può definire una funzione con questa firma che sostituisce la versione predefinita della libreria standard C++. Il comportamento richiesto consiste nell'accettare un valore di ptr ovvero nullptr o restituito da una chiamata precedente a operator new[]. Il comportamento predefinito per un valore Null di ptr non prevede l'esecuzione di alcuna operazione. Qualsiasi altro valore di ptr deve essere un valore restituito da una precedente chiamata, come descritto in precedenza. Il comportamento predefinito per un valore non Null di ptr questo tipo consiste nel recuperare lo spazio di archiviazione allocato dalla chiamata precedente. Non è specificato in quali condizioni parte o in tutte queste risorse di archiviazione recuperate viene allocata da una chiamata successiva a operator newo a una delle callocfunzioni , malloco realloc .

La seconda funzione viene chiamata da un'espressione di posizionamento delete[] corrispondente a un'espressione new[] del formato new[]( std::size_t ). Non esegue alcuna operazione.

La terza funzione viene chiamata da un'espressione di posizionamento delete[] corrispondente a un'espressione new[] del formato new[]( std::size_t, const std::nothrow_t& ). Il programma può definire una funzione con questa firma che sostituisce la versione predefinita della libreria standard C++. Il comportamento richiesto consiste nell'accettare un valore di ptr ovvero nullptr o restituito da una chiamata precedente all'operatore new[]. Il comportamento predefinito consiste nel valutare delete[]( ptr ).

Esempio

Vedere operator new[] per esempi dell'uso di operator delete[].

operator new

Funzione chiamata da un'espressione new per allocare memoria per singoli oggetti.

void* operator new(std::size_t count);
void* operator new(std::size_t count, const std::nothrow_t&) noexcept;
void* operator new(std::size_t count, void* ptr) noexcept;

Parametri

count
Numero di byte di memoria da allocare.

ptr
Puntatore da restituire.

Valore restituito

Puntatore all'indirizzo di byte più basso della risorsa di archiviazione appena allocata. Oppure ptr, se si usa la terza forma della funzione.

Osservazioni:

La prima funzione viene chiamata da un'espressione new per allocare count byte di archiviazione allineati in modo adeguato per rappresentare qualsiasi oggetto di tale dimensione. Questa funzione è sostituibile. Significa che il programma può definire una funzione alternativa con questa firma di funzione che sostituisce la versione predefinita definita dalla libreria standard C++.

Il comportamento richiesto consiste nel restituire un puntatore non Null solo se l'archiviazione può essere allocata come richiesto. Ogni allocazione di questo tipo genera un puntatore alla memoria indipendente da qualsiasi altra allocazione di memoria. L'ordine e la contiguità della memoria allocata dalle chiamate successive non sono specificati. Il valore memorizzato iniziale non è specificato. Il puntatore restituito punta all'inizio (l'indirizzo di byte più basso) della risorsa di archiviazione allocata. Se count è zero, il valore restituito non viene confrontato con qualsiasi altro valore restituito dalla funzione.

Il comportamento predefinito consiste nell'eseguire un ciclo. Nell'ambito del ciclo, la funzione prova innanzitutto ad allocare la memoria richiesta. Indica se il tentativo prevede una chiamata a malloc non è specificato. Se il tentativo di allocazione ha esito positivo, la funzione restituisce un puntatore all'archiviazione allocata. In caso contrario, la funzione chiama la funzione designata di tipo new_handler. Se la funzione chiamata restituisce un risultato, il ciclo viene ripetuto. Il ciclo termina quando un tentativo di allocare l'archiviazione richiesta ha esito positivo o quando una funzione chiamata non restituisce.

Il comportamento richiesto di una funzione di tipo new_handler consiste nell'eseguire una delle operazioni seguenti:

  • Rendere disponibile altra memoria per l'allocazione e quindi restituire un risultato.

  • abort Chiamare o exit.

  • Generare un oggetto di tipo bad_alloc.

Il comportamento predefinito di una new_handler funzione consiste nel generare un oggetto di tipo bad_alloc. Un nullptr valore definisce la funzione predefinita new_handler .

L'ordine e la contiguità dello spazio di archiviazione allocato da chiamate successive a operator new non sono specificati, come sono i valori iniziali archiviati in tale posizione.

Per liberare spazio di archiviazione allocato dalla prima forma di operator new, chiamare operator delete.

La seconda funzione viene chiamata da un'espressione di posizionamento new per allocare count byte di archiviazione allineati in modo adeguato per rappresentare qualsiasi oggetto di tale dimensione. Questa funzione è sostituibile. Significa che il programma può definire una funzione alternativa con questa firma di funzione che sostituisce la versione predefinita definita dalla libreria standard C++.

Il comportamento predefinito consiste nel restituire operator new( count ) se la funzione ha esito positivo. In caso contrario, viene restituito nullptr.

Per liberare spazio di archiviazione allocato dalla seconda forma di operator new , ovvero se non ha restituito nullptr, chiamare operator delete.

La terza funzione viene chiamata da un'espressione di posizionamento new non allocata, del formato new ( ptr ) T. In questo caso, ptr è costituito da un singolo puntatore a un oggetto. Può essere utile per costruire un oggetto in un indirizzo noto. La funzione restituisce ptr. È necessario chiamare il distruttore in modo esplicito su questo oggetto.

Se si chiama il posizionamento newnon allocato, non chiamare delete. Chiamare invece l'dealloatore per la memoria specificata, se necessario, dopo aver chiamato il distruttore per l'oggetto.

Per informazioni su come generare o non generare un comportamento di new, vedere Operatori new e delete.

Esempio

// new_op_new.cpp
// compile with: /EHsc
#include<new>
#include<iostream>

using namespace std;

class MyClass {
    int member{ 0 };
public:
    MyClass() {
        cout << "MyClass at 0x" << this << " constructed.\n";
    };

    ~MyClass() {
        cout << "MyClass at 0x" << this << " destroyed.\n";
    };
};

int main( )
{
    // The first form of new / delete
    MyClass* fPtr1 = new MyClass;
    delete fPtr1;

    // The second form (fail returns nullptr) of new / delete
    MyClass* fPtr2 = new(nothrow) MyClass[2];
    if (fPtr2)
        delete fPtr2;

    // The third form (non-allocating placement) of new / delete
    char x[sizeof(MyClass)]; // x is automatic
    MyClass* fPtr3 = new(&x[0]) MyClass;
    fPtr3->~MyClass(); // Requires explicit destructor call
    // no delete because x is on the stack
}

operator new[]

Funzione di allocazione chiamata da un'espressione new per allocare memoria per una matrice di oggetti.

void* operator new[](std::size_t count);
void* operator new[](std::size_t count, const std::nothrow_t&) noexcept;
void* operator new[](std::size_t count, void* ptr) noexcept;

Parametri

count
Numero di byte di memoria da allocare per l'oggetto matrice.

ptr
Puntatore da restituire.

Valore restituito

Puntatore all'indirizzo di byte più basso della risorsa di archiviazione appena allocata. In alternativa ptr, quando viene utilizzata la terza maschera.

Osservazioni:

La prima funzione viene chiamata da un'espressione new[] per allocare count byte di memoria allineati correttamente in modo da rappresentare qualsiasi oggetto matrice di dimensione uguale o minore. Il programma può definire una funzione con questa firma che sostituisce la versione predefinita della libreria standard C++. Il comportamento richiesto è uguale a per operator new. Il comportamento predefinito consiste nel restituire operator new( count ) se ha esito positivo. In caso contrario, genera un'eccezione std::bad_alloc (o un'eccezione derivata da std::bad_alloc). Per liberare spazio di archiviazione allocato da questo formato di operator new[], chiamare operator delete[].

La seconda funzione viene chiamata da un'espressione new[] di posizionamento per allocare count byte di memoria allineati correttamente in modo da rappresentare qualsiasi oggetto matrice di tale dimensione. Il programma può definire una funzione con questa firma che sostituisce la versione predefinita della libreria standard C++. Il comportamento predefinito consiste nel restituire operator new( count ) se la funzione ha esito positivo. In caso contrario, viene restituito nullptr. Per liberare spazio di archiviazione allocato da questo formato di operator new[], chiamare operator delete[]. Per altre informazioni sul comportamento di throwing o non throwing di new, vedere Operatori new e delete.

La terza funzione viene chiamata da un'espressione di posizionamento new[] non allocata, del formato new( ptr ) T[ N ]. Questo modulo non alloca memoria. Costruisce gli oggetti nella memoria passati tramite il ptr parametro . La funzione restituisce ptr. È necessario chiamare il distruttore in modo esplicito per ogni oggetto creato. L'utente è responsabile della fornitura di memoria sufficiente per ptr. Non richiamare delete[] sul valore restituito dall'espressione new . Al contrario, deallocare ptr, se necessario, dopo aver chiamato i distruttori.

Esempio

// new_op_array.cpp
// compile with: /EHsc
#include <new>
#include <iostream>

using namespace std;

class MyClass {
    int member{ 0 };
public:
    MyClass() {
        cout << "MyClass at 0x" << this << " constructed.\n";
    };

    ~MyClass() {
        cout << "MyClass at 0x" << this << " destroyed.\n";
    };
};

int main() {
    // The first form of array new / delete
    MyClass* fPtr1 = new MyClass[2];
    delete[] fPtr1;

    // The second form (fail returns nullptr) of array new / delete
    MyClass* fPtr2 = new(nothrow) MyClass[2];
    if (fPtr2)
        delete[] fPtr2;

    // The third form (non-allocating placement) of array new / delete
    char x[2 * sizeof(MyClass) + sizeof(int)]; // x is automatic

    MyClass* fPtr3 = new(&x[0]) MyClass[2];
    fPtr3[1].~MyClass(); // Requires explicit destructor calls
    fPtr3[0].~MyClass(); // Recommended in reverse construction order
    // Don't delete[] fPtr3 here.
    // delete[] &x[0] not required because x is on the stack
}