Quali sono le differenze tra struct e class in C ++?

Questa domanda è già stata posta nel contesto di C # /. Net .

Ora vorrei imparare le differenze tra una struttura e una classe in C ++. Si prega di discutere le differenze tecniche e le ragioni per scegliere l'una o l'altra nella progettazione OO.

Inizierò con un'ovvia differenza:

• Se non si specifica public:o private:, i membri di una struttura sono pubblici per impostazione predefinita; i membri di una classe sono privati ​​per impostazione predefinita.

Sono sicuro che ci sono altre differenze negli angoli oscuri della specifica C ++.

Dimentichi la delicata seconda differenza tra classi e strutture.

Abbandona lo standard (§11.2.2 in C ++ 98 fino a C ++ 11):

In assenza di un identificatore di accesso per una classe base, si assume public quando la classe derivata viene dichiarata struct e si assume private quando la classe viene dichiarata class .

E solo per completezza, la differenza più ampiamente conosciuta tra classe e struttura è definita in (11.2):

Il membro di una classe definita con la classe di parole chiave è privato per impostazione predefinita. I membri di una classe definita con le parole chiave struct o union sono pubbliche per impostazione predefinita.

Ulteriore differenza: la parola chiave classpuò essere utilizzata per dichiarare i parametri del modello, mentre la structparola chiave non può essere utilizzata così.

Citando le domande frequenti su C ++ ,

[7.8] Qual è la differenza tra la struttura delle parole chiave e la classe?

I membri e le classi di base di uno struct sono pubblici per impostazione predefinita, mentre in classe sono automaticamente privati. Nota: dovresti rendere le tue classi base esplicitamente pubbliche, private o protette, piuttosto che fare affidamento sui valori predefiniti.

La struttura e la classe sono altrimenti funzionalmente equivalenti.

OK, abbastanza di quel discorso techno perfettamente pulito. Emotivamente, la maggior parte degli sviluppatori fa una forte distinzione tra una classe e una struttura. Una struttura sembra semplicemente una pila aperta di bit con molto poco in termini di incapsulamento o funzionalità. Una classe si sente come un membro vivente e responsabile della società con servizi intelligenti, una forte barriera di incapsulamento e un'interfaccia ben definita. Dal momento che questa è la connotazione che molte persone hanno già, probabilmente dovresti usare la parola chiave struct se hai una classe che ha pochissimi metodi e ha dati pubblici (cose del genere esistono in sistemi ben progettati!), Ma altrimenti dovresti probabilmente usare la classe parola chiave.

Vale la pena ricordare le origini del C ++ e la compatibilità con C.

C ha delle strutture, non ha il concetto di incapsulamento, quindi tutto è pubblico.

Essere pubblici di default è generalmente considerato una cattiva idea quando si adotta un approccio orientato agli oggetti, quindi nel creare una forma di C che è nativamente favorevole a OOP (puoi fare OO in C, ma non ti aiuterà) che era il idea in C ++ (originariamente "C With Classes"), ha senso rendere i membri privati ​​per impostazione predefinita.

D'altra parte, se Stroustrup avesse cambiato la semantica in structmodo che i suoi membri fossero privati ​​per impostazione predefinita, avrebbe rotto la compatibilità (non è più vero quanto gli standard divergevano, ma tutti i programmi C validi erano anche programmi C ++ validi, che ha avuto un grande effetto nel dare un appoggio al C ++).

Quindi una nuova parola chiave, è classstata introdotta per essere esattamente come una struttura, ma privata per impostazione predefinita.

Se C ++ fosse venuto da zero, senza cronologia, probabilmente avrebbe una sola parola chiave. Probabilmente non avrebbe avuto l'impatto che ha avuto.

In generale, le persone tenderanno a usare struct quando stanno facendo qualcosa di simile a come le strutture sono usate in C; membri pubblici, nessun costruttore (fintanto che non è in un sindacato, puoi avere costruttori in strutture, proprio come con le classi, ma le persone tendono a non farlo), nessun metodo virtuale, ecc. Dal momento che le lingue sono tanto con cui comunicare le persone che leggono il codice per istruire le macchine (altrimenti dovremmo attenerci a assembly e codici operativi VM grezzi) è una buona idea attenersi a questo.

I membri della classe sono privati ​​per impostazione predefinita. I membri di Struct sono pubblici per impostazione predefinita. Oltre a ciò non ci sono altre differenze. Vedi anche questa domanda .

Secondo Stroustrup nel linguaggio di programmazione C ++ :

Lo stile che usi dipende dalle circostanze e dal gusto. Di solito preferisco usare structper le classi che hanno tutti i dati pubblici. Penso a classi come "tipi non proprio corretti, solo strutture di dati".

Funzionalmente, non c'è differenza se non quella pubblica / privata

STRUCT è un tipo di tipo di dati astratto che divide un determinato blocco di memoria in base alle specifiche della struttura. Le strutture sono particolarmente utili nella serializzazione / deserializzazione dei file poiché la struttura può spesso essere scritta nel file alla lettera. (ovvero Ottieni un puntatore alla struttura, usa la macro SIZE per calcolare il numero di byte da copiare, quindi sposta i dati dentro o fuori dalla struttura.)

Le classi sono un diverso tipo di tipo di dati astratto che tenta di nascondere le informazioni. Internamente, ci possono essere una varietà di macchinazioni, metodi, variabili temporanee, variabili di stato. ecc. che sono tutti utilizzati per presentare un'API coerente a qualsiasi codice che desideri utilizzare la classe.

In effetti, le strutture riguardano i dati, le classi riguardano il codice.

Tuttavia, devi capire che si tratta semplicemente di astrazioni. È perfettamente possibile creare strutture che assomigliano molto a classi e classi che assomigliano molto a strutture. In effetti, i primi compilatori C ++ erano semplicemente pre-compilatori che traducono il codice C ++ in C. Quindi queste astrazioni sono un vantaggio per il pensiero logico, non necessariamente una risorsa per il computer stesso.

Oltre al fatto che ognuno è un diverso tipo di astrazione, Classes fornisce soluzioni al puzzle di denominazione del codice C. Poiché non è possibile avere più di una funzione esposta con lo stesso nome, gli sviluppatori seguivano un modello di _ (). ad esempio mathlibextreme_max (). Raggruppando le API in classi, funzioni simili (qui le chiamiamo "metodi") possono essere raggruppate e protette dalla denominazione dei metodi in altre classi. Ciò consente al programmatore di organizzare meglio il proprio codice e aumentare il riutilizzo del codice. In teoria, almeno.

1) I membri di una classe sono privati ​​per impostazione predefinita e i membri di struct sono pubblici per impostazione predefinita.

Ad esempio, il programma 1 non riesce nella compilazione e il programma 2 funziona correttamente.

// Program 1
#include <stdio.h>

class Test {
    int x; // x is private
};
int main()
{
  Test t;
  t.x = 20; // compiler error because x is private
  getchar();
  return 0;
}
Run on IDE
// Program 2
#include <stdio.h>

struct Test {
    int x; // x is public
};
int main()
{
  Test t;
  t.x = 20; // works fine because x is public
  getchar();
  return 0;
}

2) Quando si ricava una struttura da una classe / struttura, l'identificatore di accesso predefinito per una classe / struttura di base è pubblico. E quando deriva una classe, l'identificatore di accesso predefinito è privato.

Ad esempio il programma 3 fallisce nella compilazione e il programma 4 funziona bene.

// Program 3
#include <stdio.h>

class Base {
public:
    int x;
};

class Derived : Base { }; // is equilalent to class Derived : private Base {}

int main()
{
  Derived d;
  d.x = 20; // compiler error becuase inheritance is private
  getchar();
  return 0;
}
Run on IDE
// Program 4
#include <stdio.h>

class Base {
public:
    int x;
};

struct Derived : Base { }; // is equilalent to struct Derived : public Base {}

int main()
{
  Derived d;
  d.x = 20; // works fine becuase inheritance is public
  getchar();
  return 0;
}

L'unica altra differenza è l'ereditarietà predefinita di classi e strutture, che, ovviamente, è privata e pubblica rispettivamente.

1. I membri di una struttura sono pubblici per impostazione predefinita, i membri della classe sono privati ​​per impostazione predefinita.
2. L'eredità predefinita per la struttura da un'altra struttura o classe è pubblica. L'eredità predefinita per la classe da un'altra struttura o classe è privata.

class A{    
public:    
    int i;      
};

class A2:A{    
};

struct A3:A{    
};


struct abc{    
    int i;
};

struct abc2:abc{    
};

class abc3:abc{
};


int _tmain(int argc, _TCHAR* argv[])
{    
    abc2 objabc;
    objabc.i = 10;

    A3 ob;
    ob.i = 10;

    //A2 obja; //privately inherited
    //obja.i = 10;

    //abc3 obss;
    //obss.i = 10;
}

Questo è su VS2005.

Non nelle specifiche, no. La differenza principale sta nelle aspettative del programmatore quando leggono il tuo codice in 2 anni. le strutture sono spesso considerate POD. Le strutture vengono utilizzate anche nella metaprogrammazione dei modelli quando si definisce un tipo per scopi diversi dalla definizione degli oggetti.

Un'altra cosa da notare, se hai aggiornato un'app legacy che aveva delle strutture per usare le classi potresti riscontrare il seguente problema:

Il vecchio codice ha delle strutture, il codice è stato ripulito e questi sono stati cambiati in classi. Una o due funzioni virtuali sono state quindi aggiunte alla nuova classe aggiornata.

Quando le funzioni virtuali sono in classe, internamente il compilatore aggiungerà un puntatore extra ai dati della classe per puntare alle funzioni.

Il modo in cui questo spezzerebbe il vecchio codice legacy è se nel vecchio codice da qualche parte la struttura fosse cancellata usando memfill per cancellare tutto a zero, questo avrebbe anche calpestato i dati del puntatore extra.

1. I membri di una classe definita con la parola chiave classsono privatepredefiniti. I membri di una classe definita con le parole chiave struct(o union) sono publicpredefiniti.

2. In assenza di un identificatore di accesso per una classe di base, publicviene assunto quando viene dichiarata la classe derivatastruct e privateviene assunto quando viene dichiarata la classe class.

3. Puoi dichiarare un enum classma non un enum struct.

4. Puoi usare template<class T>ma non template<struct T>.

Si noti inoltre che lo standard C ++ consente di dichiarare in avanti un tipo come a struct, quindi utilizzarlo classper dichiarare il tipo e viceversa. Inoltre, std::is_class<Y>::valueè trueper Y essere un structe un class, ma è falseper un enum class.

La differenza tra classe structè una differenza tra parole chiave, non tra tipi di dati. Questo due

struct foo : foo_base { int x;};
class bar : bar_base { int x; };

entrambi definiscono un tipo di classe. La differenza delle parole chiave in questo contesto è il diverso accesso predefinito:

• foo::xè pubblico ed foo_baseè ereditato pubblicamente
• bar::xè privato ed bar_baseè ereditato privatamente

Ecco una buona spiegazione: http://carcino.gen.nz/tech/cpp/struct_vs_class.php

Quindi, ancora una volta: in C ++, una struttura è identica a una classe, tranne per il fatto che i membri di una struttura hanno visibilità pubblica per impostazione predefinita, ma i membri di una classe hanno visibilità privata per impostazione predefinita.

È solo una convention. Le strutture possono essere create per contenere dati semplici ma successivamente evolvono il tempo con l'aggiunta di funzioni e costruttori dei membri. D'altra parte è insolito vedere qualcosa di diverso dal pubblico: accesso in una struttura.

ISO IEC 14882-2003

9 classi

§3

Una struttura è una classe definita con la chiave di classe struct ; i suoi membri e le classi base (clausola 10) sono di default pubblici (clausola 11).

Un'altra differenza principale è quando si tratta di modelli. Per quanto ne so, puoi usare una classe quando definisci un modello ma NON una struttura.

template<class T> // OK
template<struct T> // ERROR, struct not allowed here

Le altre risposte hanno menzionato le impostazioni predefinite private / pubbliche (ma nota che una struttura è una classe è una struttura; non sono due elementi diversi, solo due modi per definire lo stesso oggetto).

Ciò che potrebbe essere interessante notare (in particolare poiché è probabile che il richiedente stia utilizzando MSVC ++ poiché menziona C ++ "non gestito") è che Visual C ++ si lamenta in determinate circostanze se una classe viene dichiarata con classe quindi definita con struct(o forse viceversa) ), sebbene lo standard affermi che è perfettamente legale.

• . Nelle classi tutti i membri per impostazione predefinita sono privati ​​ma nella struttura i membri sono pubblici per impostazione predefinita.

  1. Non esiste un termine come costruttore e distruttore per le strutture, ma per il compilatore di classi viene creato un valore predefinito se non viene fornito.

  2. La dimensione della struttura vuota è di 0 byte poiché la dimensione della classe vuota è di 1 byte Il tipo di accesso predefinito struct è pubblico. Una struttura dovrebbe in genere essere utilizzata per raggruppare i dati.

  Il tipo di accesso predefinito della classe è privato e la modalità predefinita per l'ereditarietà è privata. Una classe dovrebbe essere utilizzata per raggruppare dati e metodi che operano su tali dati.

  In breve, la convenzione è di usare struct quando lo scopo è quello di raggruppare i dati e usare le classi quando abbiamo bisogno di astrazione dei dati e, forse, ereditarietà.

  In C ++ le strutture e le classi vengono passate per valore, a meno che non vengano esplicitamente rimosse. In altre lingue le classi e le strutture possono avere una semantica distinta, ad es. gli oggetti (istanze di classi) possono essere passati per riferimento e le strutture possono essere passate per valore. Nota: ci sono commenti associati a questa domanda. Vedi la pagina di discussione da aggiungere alla conversazione.

Sebbene implicito da altre risposte, non è esplicitamente menzionato - che le strutture sono C compatibili, a seconda dell'uso; le classi no.

Questo significa che se stai scrivendo un'intestazione che vuoi essere compatibile con C, allora non hai altra scelta che struct (che nel mondo C non può avere funzioni; ma può avere puntatori a funzioni).

Si potrebbe considerare questo per le linee guida su quando andare per struct o class, https://msdn.microsoft.com/en-us/library/ms229017%28v=vs.110%29.aspx .

√ CONSIDERANDO la definizione di una struttura anziché di una classe se le istanze del tipo sono piccole e comunemente di breve durata o sono comunemente incorporate in altri oggetti.

X EVITARE di definire una struttura a meno che il tipo non abbia tutte le seguenti caratteristiche:

Rappresenta logicamente un singolo valore, simile ai tipi primitivi (int, double, ecc.).

Ha una dimensione dell'istanza inferiore a 16 byte.

È immutabile

Non dovrà essere inscatolato frequentemente.

La classe ha senso solo nel contesto dell'ingegneria del software. Nel contesto delle strutture dati e degli algoritmi, classe e struttura non sono così diverse. Non esiste alcuna regola limitata a cui deve essere fatto riferimento il membro della classe.

Quando si sviluppa un progetto di grandi dimensioni con tonnellate di persone senza classe, si può finalmente ottenere un codice accoppiato complicato perché tutti usano qualsiasi funzione e dato desiderino. class fornisce controlli di autorizzazione ed elementi inerenti per migliorare il disaccoppiamento e il riutilizzo dei codici.

Se leggi alcuni principi di ingegneria del software, scoprirai che la maggior parte degli standard non può essere implementata facilmente senza classe. ad esempio: http://en.wikipedia.org/wiki/SOLID_%28object-oriented_design%29

A proposito, quando una struttura alloca uno scricchiolio della memoria e include diverse variabili, le variabili del tipo di valore indicano che i valori sono incorporati nel punto in cui è allocata la struttura. Al contrario, i valori della variabile del tipo di riferimento sono esterni e riferimento da un puntatore incorporato anche nel punto in cui viene allocata la struttura.

La differenza tra le parole chiave struct e class in C ++ è che, quando non esiste uno specifico specificatore su un particolare tipo di dati compositi, per impostazione predefinita struct o union sono le parole chiave pubbliche che considerano semplicemente il nascondimento dei dati ma class è la parola chiave privata che considera il nascondimento del programma codici o dati. Alcuni programmatori usano sempre struct per i dati e la classe per motivi di codice. Per ulteriori informazioni contattare altre fonti.

Di tutti questi fattori, si può concludere che il concetto di Classe è altamente adatto a rappresentare oggetti del mondo reale piuttosto che "Strutture". Probabilmente perché i concetti di OOP usati in classe sono altamente pratici nello spiegare scenari di mondo reale, quindi è più facile fonderli con la realtà. Ad esempio, l'ereditarietà predefinita è pubblica per le strutture ma se applichiamo questa regola per il mondo reale, è ridicola, ma in una classe l'eredità predefinita è privata che è più realistica.

Comunque, ciò che devo giustificare è che Class è un concetto molto più ampio e applicabile nel mondo reale, mentre la Struttura è un concetto primitivo con scarsa organizzazione interna (anche se la struttura segue i concetti OOP, hanno un significato scarso)

La differenza principale tra struttura e parola chiave class in oops è che nessuna struttura pubblica e privata è presente nella struttura. E la funzione membro membro e membro può essere definita come pubblica, privata e protetta.

** AGGIORNAMENTO: ** Si prega di ignorare questa risposta. Non ho considerato la possibilità che per la struttura il valore non fosse inizializzato, ma era appena pari a 0. Non esiste una differenza di inizializzazione tra la struttura e la classe.

Vedo un'altra differenza tra le strutture e le classi che hanno a che fare con l'inizializzazione predefinita.

struct Foo {
    int a;
};

class Bar {
    int a;
};

class Tester {
    Foo m_Foo = Foo();
    Bar m_Bar = Bar();

public:
    Tester() {}
};

int main() {
    auto myTester = Tester();
}

Esegui quel codice ed esamina myTester. Scoprirai che per m_Foo, la struttura, m_Foo.a è stata inizializzata su 0, ma per m_Bar, la classe, m_Bar.a non è inizializzata. Quindi sembra esserci una differenza in ciò che fa il costruttore predefinito per struct vs. class. Lo vedo con Visual Studio.

La differenza principale tra struct e class è che in struct puoi dichiarare solo variabili di dati di diversi tipi di dati mentre in class puoi dichiarare variabili di dati, funzioni membro e quindi puoi manipolare variabili di dati attraverso funzioni.

-> un'altra cosa utile che trovo in class vs struct è che durante l'implementazione dei file in un programma se si desidera eseguire alcune operazioni di una struttura ancora e ancora su ogni nuovo set di operazioni è necessario creare una funzione separata e è necessario passa l'oggetto di struct dopo averlo letto dal file in modo da effettuare alcune operazioni su di esso. mentre sei in classe se fai una funzione che fa ogni volta alcune operazioni sui dati necessari..e facile, devi solo leggere l'oggetto dal file e chiamare la funzione ..

Ma dipende dal programmatore nel modo in cui lo trova adatto ... secondo me preferisco la classe ogni volta solo perché supporta gli OOP e questo è il motivo per cui è implementato in quasi tutte le lingue ed è la meravigliosa caratteristica della programmazione di tutti i tempi; - )

E sì, la differenza più impercettibile che ho dimenticato di menzionare è che la classe supporta il nascondimento dei dati e supporta anche le operazioni che vengono eseguite su tipi di dati incorporati mentre struct non lo fa!

Ho trovato un'altra differenza. se non si definisce un costruttore in una classe, il compilatore ne definirà uno. ma in una struttura se non si definisce un costruttore, anche il compilatore non definisce un costruttore. quindi in alcuni casi che non abbiamo davvero bisogno di un costruttore, la struttura è una scelta migliore (suggerimento sulle prestazioni). e scusami per il mio cattivo inglese.

Le classi sono tipi di riferimento e le strutture sono tipi di valori.
Quando dico che le classi sono tipi di riferimento,
fondamentalmente conterranno l'indirizzo di una variabile di istanza.

Per esempio:

Class MyClass
{
    Public Int DataMember;  //By default, accessibility of class data members 
                            //will be private. So I am making it as Public which 
                            //can be accessed outside of the class.
}

Nel metodo principale,
posso creare un'istanza di questa classe utilizzando un nuovo operatore che alloca memoria per questa classe
e memorizza l'indirizzo di base di tale nella variabile di tipo MyClass (_myClassObject2).

Static Public void Main (string[] arg)
{
    MyClass _myClassObject1 = new MyClass();
    _myClassObject1.DataMember = 10;

    MyClass _myClassObject2 = _myClassObject1;
    _myClassObject2.DataMember=20;
}

Nel programma sopra, MyClass _myClassObject2 = _myClassObject1; l'istruzione indica che entrambe le variabili di tipo MyClass

1. myClassObject1
2. myClassObject2

e indicherà la stessa posizione di memoria.
In pratica assegna la stessa posizione di memoria in un'altra variabile dello stesso tipo.

Pertanto, se qualsiasi modifica apportata a uno qualsiasi degli oggetti, digitare MyClass avrà un effetto su un altro
poiché entrambi puntano alla stessa posizione di memoria.

"_myClassObject1.DataMember = 10;" su questa riga entrambi i membri dei dati dell'oggetto conterranno il valore di 10.
"_myClassObject2.DataMember = 20;" su questa riga entrambi i membri dei dati dell'oggetto conterranno il valore di 20.
Alla fine, accediamo ai membri di un oggetto tramite puntatori.

A differenza delle classi, le strutture sono tipi di valore. Per esempio:

Structure MyStructure
{
    Public Int DataMember;  //By default, accessibility of Structure data 
                            //members will be private. So I am making it as 
                            //Public which can be accessed out side of the structure.
}

Static Public void Main (string[] arg)
{
    MyStructure _myStructObject1 = new MyStructure();
    _myStructObject1.DataMember = 10;

    MyStructure _myStructObject2 = _myStructObject1;
    _myStructObject2.DataMember = 20;
}

Nel programma precedente,
creare un'istanza dell'oggetto di tipo MyStructure usando un nuovo operatore e
memorizzare l'indirizzo nella variabile _myStructObject di tipo MyStructure e
assegnare il valore 10 al membro dati della struttura utilizzando "_myStructObject1.DataMember = 10".

Nella riga successiva,
sto dichiarando un'altra variabile _myStructObject2 di tipo MyStructure e assegnando _myStructObject1.
Qui il compilatore .NET C # crea un'altra copia dell'oggetto _myStructureObject1 e
assegna tale posizione di memoria nella variabile MyStructure _myStructObject2.

Pertanto, qualsiasi modifica apportata a _myStructObject1 non avrà mai effetto su un'altra variabile _myStructObject2 di tipo MyStructrue.
Ecco perché stiamo dicendo che le strutture sono tipi di valore.

Quindi la classe Base immediata per la classe è Object e la classe Base immediata per Structure è ValueType che eredita da Object.
Le classi sosterranno un'eredità mentre le strutture no.

Come lo stiamo dicendo?
E qual è la ragione dietro questo?
La risposta è Classi.

Può essere astratto, sigillato, statico e parziale e non può essere interno privato, protetto e protetto.

Esistono 3 differenze di base tra struttura e classe

La memoria 1St è riservata per la struttura nella memoria dello stack (che è vicina al linguaggio di programmazione) se per la classe nella memoria dello stack è riservata solo la reffrenza e la memoria effettiva è riservata nella memoria dell'heap.

2 ° - Per impostazione predefinita, la struttura tratta come pubblico se la classe tratta come privata.

3Rd- non è possibile riutilizzare il codice nella struttura, ma in classe possiamo riutilizzare lo stesso codice in molti casi chiamato eredità