Perché int x {y = 5} è possibile?

int main() {
    int y;
    int x{ y = 5 };
    //x is 5
}

Come è possibile, poiché y = 5 non è un'espressione calcolabile?

Inoltre, perché il compilatore o l'IDE non si lamentano del fatto che main () non restituisce un int?

Inizierò dalla tua ultima domanda

Inoltre, perché il compilatore o l'IDE non si lamentano del fatto che main () non restituisca un int?

Secondo lo standard C ++ (6.6.1 funzione principale)

5 Un'istruzione return in main ha l'effetto di lasciare la funzione principale (distruggere qualsiasi oggetto con durata di memorizzazione automatica) e chiamare std :: exit con il valore restituito come argomento. Se il controllo scorre fuori dalla fine dell'istruzione composta di main, l'effetto è equivalente a un ritorno con l'operando 0 (vedere anche 18.3).

E relativo a questa domanda

Come è possibile, poiché y = 5 non è un'espressione calcolabile?

Dallo standard C ++ (8.18 Operatori di assegnazione e assegnazione composti)

1 L'operatore di assegnazione (=) e gli operatori di assegnazione composti si raggruppano tutti da destra a sinistra. Tutti richiedono un valore modificabile come operando di sinistra e restituiscono un valore riferito all'operando di sinistra.

Sp questa dichiarazione

int x{ y = 5 };

può essere equamente suddiviso in due affermazioni

y = 5;
int x{ y };

Inoltre in C ++ puoi anche fare un riferimento alla variabile y nel modo seguente

int &x{ y = 5 };

Ecco un programma dimostrativo

#include <iostream>

int main() 
{
    int y;
    int &x{ y = 5 };    

    std::cout << "y = " << y << '\n';

    x = 10;

    std::cout << "y = " << y << '\n';
}

Il suo output è

y = 5
y = 10

Puoi questa dichiarazione

int x{ y = 5 };

riscrivi anche come

int x = { y = 5 };

Tuttavia, tenere conto del fatto che esiste una differenza tra queste due dichiarazioni (simili alle dichiarazioni precedenti).

auto x{ y = 5 };

e

auto x = { y = 5 };

Nella prima dichiarazione la variabile xha il tipo int. Nella seconda dichiarazione la variabile xha il tipo std::initializer_list<int>.

Per rendere più visibile la differenza, vedere come vengono emessi i valori degli oggetti.

#include <iostream>

int main() 
{
    int y;
    auto x1 { y = 5 };  

    std::cout << "x1 = " << x1 << '\n';

    auto x2 = { y = 10 };   

    std::cout << "*x2.begin()= " << *x2.begin() << '\n';

    std::cout << "y = " << y << '\n';

    return 0;
}

L'output del programma è

x1 = 5
*x2.begin()= 10
y = 10

Come è possibile, poiché y = 5 non è un'espressione calcolabile?

È un compito e i valori di rendimento assegnano, cioè il "tipo non qualificato cv dell'operando di sinistra", vedere [expr.ass / 3] . Quindi y = 5risulta y, che è 5, che viene utilizzato per inizializzare x.

Per quanto riguarda la tua seconda domanda, vedi cppreference su main (o [basic.start.main / 5] ):

Il corpo della funzione principale non deve contenere l' returnistruzione: se il controllo raggiunge la fine di main senza incontrare returnun'istruzione, l'effetto è quello dell'esecuzione return 0;.

Quindi, compilatore o IDE che ti avvertono di returnun'istruzione mancante alla fine di mainsarebbe chiaramente sbagliato. Certo, il fatto che dovresti sempre returnobiettare a causa di esecuzioni non voidfunzionali è un po '... beh, per motivi storici immagino.main

Il operator=()risultato è un valore, che è il valore assegnato alla variabile. Per questo motivo, è possibile concatenare le assegnazioni in questo modo:

int x, y, z;
x = y = z = 1;

Se dai un'occhiata alla documentazione su cppreference , vedrai che operator=()restituisce un riferimento all'oggetto che è stato assegnato. Pertanto, un'assegnazione può essere utilizzata come espressione che restituisce l'oggetto assegnato.

Quindi, è solo un normale incarico con parentesi graffe.