L’operatore + è sovraccarico per i tipi primitivi?

Gli operatori già sovraccaricati, <>, = etc sono usati molte volte.

Un esempio a cui stavo pensando è quando aggiungiamo le stringhe diciamo:

string name = string (“munish”) + “kumar”;

l’operatore + è sovraccarico nella class string.

ma quando aggiungiamo numeri come 1 + 2 (non sembra una chiamata dell’operatore sovraccaricata)

Mi stavo chiedendo come succede il compilatore esegue un additon binario.

Non ho bisogno di preoccuparmene molto anche se il compilatore lo fa, è solo una questione di curiosità per me.

I tipi primitivi non implementano l’ operator+ che in realtà è una funzione con un nome strano. L’aggiunta per il tipo Primitive viene eseguita mediante l’istruzione della CPU come:

 addl %edx,(%eax) //this adds two integral values loaded at edx and eax 

Implementa l’ operator+ per i tipi definiti dall’utente e il compilatore genera molte istruzioni della CPU per eseguire l’attività che scrivi in operator+ .

Penso che tu stia confondendo due cose: l’overloading dell’operatore e come definisci un operatore per un tipo definito dall’utente. Il sovraccarico dell’operatore non è nuovo; esiste già in C, dove + è sovraccaricato su int , unsigned int , long , unsigned long , float , double e long double . In C ++, è ansible aggiungere operatori per tipi definiti dall’utente, definendo una funzione denominata operator+ , quindi l’elenco dei sovraccarichi è più lungo. E per rendere le cose più coerenti, il modo in cui il compilatore risolve il sovraccarico consiste nell’aggiungere firme sintetizzate lungo le linee di operator+(int, int) all’elenco di overload. Se la risoluzione di sovraccarico finisce quindi scegliendo una di queste firme sintetizzate, utilizza l’operatore integrato, generando qualsiasi codice macchina necessario (che può comportare una chiamata di funzione a livello di codice macchina). Il fatto che scelga uno dei sovraccarichi “built-in” ha ripercussioni nel resto del codice: un operatore definito dall’utente è considerato una chiamata di funzione, con i corrispondenti punti di sequenza e tutto il resto, e il compilatore non è permesso di formulare ipotesi sulla sua semantica – in particolare, il compilatore non può presumere che un operator+ definito dall’utente operator+ sia associativo o commutativo. Un operatore build-in (con pochissime eccezioni) non introduce alcun punto di sequenza, e il compilatore conosce la sua semantica e può ottimizzare di conseguenza.

Si noti che il codice macchina generato potrebbe non essere così diverso. Ho usato macchine in cui il compilatore doveva chiamare una funzione per moltiplicare int s, e il compilatore può (e spesso lo farà) in linea un operatore definito dall’utente. Ciò che cambia sono le regole che ho menzionato sopra: la presenza di punti di sequenza negli operatori definiti dall’utente e il fatto che il compilatore non può formulare ipotesi riguardo alle varie leggi matematiche che potrebbero applicarsi.

È ansible sovraccaricare gli operatori su tipi di dati personalizzati, ad esempio le classi .. int è un tipo di dati primitivo e gli operatori sui tipi primitivi sono implementati dal compilatore stesso, in pratica è solo una semplice istruzione CPU per aggiungere int ecc.