Differenza tra "nuovo operatore" e "operatore nuovo"?

Qual è la differenza tra "new operator" e "operator new"?

Di solito provo a formulare le cose in modo diverso per differenziarle un po 'meglio, ma in ogni caso è una buona domanda.

L'operatore new è una funzione che alloca memoria non elaborata, almeno concettualmente, non è molto diverso da malloc(). Sebbene sia abbastanza insolito a meno che tu non stia scrivendo qualcosa come il tuo contenitore, puoi chiamare l'operatore new direttamente, come:

char *x = static_cast<char *>(operator new(100));

È anche possibile sovraccaricare l'operatore new globalmente o per una classe specifica. IIRC, la firma è:

void *operator new(size_t);

Ovviamente, se sovraccarichi un operatore new (globale o per una classe), vorrai / dovrai anche sovraccaricare anche l'operatore corrispondente delete. Per quel che vale, c'è anche un operatore separato new [] che viene utilizzato per allocare la memoria per gli array, ma quasi certamente faresti meglio a ignorare completamente tutto quel casino.

Il nuovo operatore è quello che usi normalmente per creare un oggetto dal negozio gratuito:

my_class *x = new my_class(0);

La differenza tra i due è che l'operatore new alloca solo la memoria non elaborata, nient'altro. Il nuovo operatore inizia usando l'operatore new per allocare la memoria, ma poi richiama il costruttore per il giusto tipo di oggetto, quindi il risultato è un vero oggetto live creato in quella memoria. Se quell'oggetto contiene altri oggetti (incorporati o come classi base) anche quei costruttori vengono richiamati.

"operatore nuovo"

class Foo
{
public:
        void* operator new( size_t );
}

"nuovo operatore":

Foo* foo = new Foo();

In questo esempio, new Foo()callsFoo::operator new()

In altre parole, "nuovo operatore" chiama " operator new()" proprio come l'operatore + chiamaoperator +()

Di seguito è riportata la citazione dal libro C ++ più efficace di Scott Meyers:

Il nuovo operatore chiama una funzione per eseguire l'allocazione di memoria richiesta ed è possibile riscrivere o sovraccaricare quella funzione per modificarne il comportamento. Il nome della funzione che il nuovo operatore chiama per allocare la memoria è operatore nuovo.

Non c'è differenza tra "nuovo operatore" e "nuovo operatore". Entrambi si riferiscono alla stessa cosa: la funzione sovraccaricabile / sostituibile operator newche in genere esegue l'allocazione di memoria non elaborata per oggetti creati da nuove espressioni .

Si noti inoltre che nessuno dei due termini è presente nella specifica della lingua (che è la fonte che definisce la terminologia ufficiale).

Quando si utilizza newnel programma per creare un oggetto, si parla di nuova espressione . La nuova espressione consiste in parole chiave newe parti sintattiche aggiuntive definite dalla grammatica. Nessuna parte della sintassi di questa espressione viene mai chiamata "operatore".

La funzione di allocazione della memoria non elaborata operator newviene ufficialmente definita solo " operator newfunzione". Nota che le parole operatore newin questa sequenza sono solo due parole chiave del linguaggio C ++ separate. Non formano un termine inglese "operatore nuovo". Da nessuna parte nella specifica della lingua troverai riferimenti a "operatore nuovo" come termine inglese. Ogni volta questa è solo una combinazione di due parole chiave indipendenti che producono la sintassi di dichiarazione per una funzione di allocazione della memoria.

Di nuovo, nel curriculum: formalmente in C ++ non ci sono termini in lingua inglese come "operator new" o "new operator". La prima sequenza è presente nella specifica della lingua come una semplice combinazione di parole chiave, non come un termine inglese. Quest'ultimo non è affatto presente.

Quando si crea un nuovo oggetto, la memoria viene allocata utilizzando l' operatore new, quindi viene richiamato il costruttore per inizializzare la memoria. Il nuovo operatore fa sia l'allocazione che l'inizializzazione, mentre l'operatore nuovo fa solo l'allocazione.

La domanda dell'OP non è formulata correttamente. È meglio impostare la fase come "Differenza tra" operatore nuovo "e" nuova espressione "?" Nota "nuovo operatore" spesso si riferisce anche a "nuova funzione operatore".

E ci sono molte risposte corrette in giro, di seguito è la mia:

1> "nuova espressione" chiama "operatore nuovo" per allocare memoria non elaborata, quindi chiama il costruttore

apple * p = new apple(); //new expression

2> 'operator new' alloca solo memoria grezza, non molta differenza rispetto a malloc

void* mem = operator new(sizeof(apple)); //just like calling malloc()
apple* p2 = new(mem) apple(1); //call construct here using placement new.

Il nuovo operatore : C ++ supporta l'allocazione dinamica di oggetti utilizzando l'operatore nuovo. Il nuovo operatore alloca memoria per gli oggetti da un pool denominato archivio gratuito. Il nuovo operatore chiama la funzione speciale operatore nuovo.

operator new : se la richiesta è per zero byte di memoria, l'operatore new restituisce un puntatore a un oggetto distinto (ovvero, chiamate ripetute a operator new restituiscono puntatori diversi). Se la memoria è insufficiente per la richiesta di allocazione, l'operatore new restituisce NULL o genera un'eccezione. Il primo argomento dell'operatore new deve essere di tipo size_t (un tipo definito in STDDEF.H) e il tipo restituito è sempre void *.

Ecco i collegamenti MSDN per maggiori dettagli:

La nuova funzione operatore

Il nuovo operatore

1. new è un operatore oltre che una parola chiave.

   vedere [1] In 2.13 && In 2.12.

2. new fa due cose: T * t = new T (arg);

   1) alloca memoria per l'oggetto: void * ptr = operator new (sizeof (T));

   // l' operatore new è una funzione (proprio come malloc in c), non un operatore (vedere [1] in 3.7.4). Ma l'articolo 7 [2] dice che è anche un operatore. Secondo me, la differenza tra operatore e funzione è piccola e puoi vederla quando ricordi che l'operatore di sovraccarico è implementato dalle funzioni.

   // possiamo sovraccaricare questo operatore / funzione (operatore nuovo) facendo ciò che vogliamo proprio qui.

   2) inizializza l'oggetto nella memoria allocata: chiama T :: T (arg) su ptr

   // solo il compilatore può farlo. Né io né tu possiamo.

   // anche il compilatore richiamerà i costruttori degli oggetti membri e il costruttore della classe base se T li ha. E questa invocazione è ricorsiva. Solo il compilatore può farlo.

3. Quindi, operatore nuovo fa parte delle missioni di nuovo, e solo in questa parte possiamo fare qualcosa.

   [1]: ISO / IEC, N3690. http://ww.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3690.pdf

   [2]: Meyers, Scott. Efficace C ++, 3 °.