parola chiave 'class' in definizione variabile in C++

Question

Prima che qualcuno chieda, sì, questo fa parte di un compito a casa, e sì, ho fatto un sacco di ricerche su Google prima di chiedere. Ho passato l'ultima ora a cercare intensamente su Google con molte, molte parole chiave diverse, ma proprio non riuscivo a trovare nulla.

quindi ecco qui la domanda:

Cosa fa la seguente definizione media variabile: class MyClass* myClass;?

ho provato che il codice con qualcosa come class MyClass* myClass = new MyClass(); e ha scoperto che si crea semplicemente un puntatore ad una nuova istanza di MyClass.

Quindi, qual è il vantaggio dell'utilizzo del prefisso class? Fa qualche differenza?

Qualcuno ha un link ad alcune risorse al riguardo? Semplicemente non riuscivo a trovare nulla (è davvero, davvero difficile trovare altre cose oltre alla "definizione della classe"!).

Grazie mille!

Answer 1

Un identificatore di tipo elaborato è un nome di tipo preceduto dalla parola chiave class, struct, enum o union.

class identifier 
struct identifier 
enum identifier 
union identifier 

Un elaborato indicatore di tipo viene utilizzato sia per enfasi o per rivelare un nome di tipo che è nascosto dalla dichiarazione di una variabile con lo stesso nome nello stesso ambito.

source

Answer 2

In realtà è facoltativo utilizzare class durante la creazione dell'oggetto di classe. In linguaggio C è obbligatorio utilizzare struct davanti al nome della struttura per creare la sua variabile. Come C++ è superset di C. C'è solo una differenza tra struct e class in C++, e quello è un modificatore di accesso.

Per mantenere compatibile con le versioni precedenti è ammesso.

Quindi,

class MyClass* myClass = new MyClass(); 

E,

MyClass* myClass = new MyClass(); 

Entrambi sono lo stesso.

Answer 3

Le parole "in linea dichiarazione anticipata" hanno bisogno di essere menzionati qui!

Una dichiarazione di inoltro è semplicemente un modo per indicare al compilatore un nome di tipo prima che sia effettivamente definito. Li trovi sempre nei file di intestazione.

// MyStruct.h 
class MyClass; 

struct MyStuct { 
    MyClass* m_myClass; 
    void foo(); 
} 

// MyStruct.cpp 
#inlude "MyClass.h" 
void MyStruct::foo() { m_myClass->SomeFunc(); } 

Si noti che il file di intestazione dichiara solo MyClass come un identificatore di classe, e non ha idea di cosa sia in realtà fino alla sua definita tramite il # include nel file cpp. Questa è una dichiarazione in avanti.

la dichiarazione di inoltro in linea è davvero la stessa cosa, ma si fa semplicemente tutto su un'unica riga. Questo è lo stesso codice esatto che raggiunge la stessa cosa.

// MyStruct.h 
struct MyStuct { 
    class MyClass* m_myClass; 
    void foo(); 
} 

// MyStruct.cpp 
#inlude "MyClass.h" 
void MyStruct::foo() { m_myClass->SomeFunc(); } 

Mi sento come se la maggior parte dei programmatori preferisse il metodo di dichiarazione in avanti standard (di solito digitando meno in generale). Ecco perché può essere fonte di confusione quando inciampo sulla versione inline meno utilizzata.

Vedo molte delle risposte qui che la chiamano una parola chiave opzionale, ma nel contesto precedente della dichiarazione diretta inline, non è molto facoltativa e comporterà errori di compilazione a causa di un identificatore di tipo mancante.