Perché le variabili membro di un oggetto const non sono const

Question

Appena posta una domanda simile che si riduce a questa.

#include <iostream> 
using namespace std; 

struct A { 
    A() : a{1} {}; 
    int a; 
}; 

template <typename Which> 
struct WhichType; 

int main() { 
    const A a; 
    const A& a_ref = a; 
    const A* a_ptr = &a; 
    WhichType<decltype(a.a)> which_obj; // template evaluates to int 
    WhichType<decltype(a_ref.a)> which_ref; // template evaluates to int 
    WhichType<decltype(a_ptr->a)> which_ptr; // template evaluates to int 

    return 0; 
} 

Perché i modelli non diventano const int invece di int?

Answer 1

decltype fornisce il "tipo dichiarato" dell'operando quando non è racchiuso tra parentesi.

Per ottenere il tipo effettivo dell'espressione, ovvero const int, è necessario scrivere decltype((a.a)) e così via.

decltype restituisce sempre un tipo di riferimento per le espressioni lvalue diverse dai nomi.

Answer 2

Quando viene passato il nome di un identificatore (o membro), restituisce il tipo di dichiarazione.

Quando si passa un'espressione diversa, restituisce qualcosa più vicino a ciò che si desidera, ma con qualifica di riferimento.

WhichType<std::remove_reference_t<decltype((a_ptr->a))>> which_ptr; // template evaluates to const int! 

live example o se si desidera che la L/R valueness:

WhichType<decltype((a_ptr->a))> which_ptr2; // template evaluates to const int& 
WhichType<decltype(((const A){}.a))> which_ptr3; // template evaluates to const int 

è possibile aggiungere && per farne un "vero" rvalue di riferimento qui.

WhichType<decltype(((A){}.a))&&> which_ptr4; // template evaluates to int&&! 

live example.