Quelles sont les différences entre struct et classe en C ++?

Cette question a déjà été posée dans le cadre de C # /. Net .

Maintenant, j'aimerais apprendre les différences entre une structure et une classe en C ++. Veuillez discuter des différences techniques ainsi que des raisons de choisir l'une ou l'autre dans la conception OO.

Je vais commencer par une différence évidente:

• Si vous ne spécifiez pas public:ou private:, les membres d'une structure sont publics par défaut; les membres d'une classe sont privés par défaut.

Je suis sûr qu'il existe d'autres différences dans les coins obscurs de la spécification C ++.

Vous oubliez la 2ème différence délicate entre les classes et les structures.

Quoth la norme (§11.2.2 en C ++ 98 à C ++ 11):

En l'absence d'un spécificateur d' accès pour une classe de base, public est supposé lorsque la classe dérivée est déclarée struct et private est supposé lorsque la classe est déclarée classe .

Et juste pour être complet, la différence la plus connue entre classe et struct est définie dans (11.2):

Les membres d'une classe définie avec le mot-clé class sont privés par défaut. Les membres d'une classe définie avec les mots - clés struct ou union sont publics par défaut.

Différence supplémentaire: le mot-clé classpeut être utilisé pour déclarer des paramètres de modèle, tandis que le structmot - clé ne peut pas être utilisé ainsi.

Citant la FAQ C ++ ,

[7.8] Quelle est la différence entre la structure des mots clés et la classe?

Les membres et les classes de base d'une structure sont publics par défaut, tandis qu'en classe, ils sont par défaut privés. Remarque: vous devez rendre vos classes de base explicitement publiques, privées ou protégées, plutôt que de vous fier aux valeurs par défaut.

Struct et classe sont par ailleurs fonctionnellement équivalents.

OK, assez de cette conversation techno propre et grinçante. Sur le plan émotionnel, la plupart des développeurs font une forte distinction entre une classe et une structure. Une structure ressemble simplement à une pile ouverte de bits avec très peu d'encapsulation ou de fonctionnalité. Une classe se sent comme un membre vivant et responsable de la société avec des services intelligents, une forte barrière d'encapsulation et une interface bien définie. Puisque c'est la connotation que la plupart des gens ont déjà, vous devriez probablement utiliser le mot-clé struct si vous avez une classe qui a très peu de méthodes et a des données publiques (de telles choses existent dans des systèmes bien conçus!), Mais sinon vous devriez probablement utiliser la classe mot-clé.

Il convient de se rappeler les origines de C ++ et sa compatibilité avec C.

C a des structures, il n'a pas de concept d'encapsulation, donc tout est public.

Être public par défaut est généralement considéré comme une mauvaise idée lorsque vous adoptez une approche orientée objet, donc en créant une forme de C qui est nativement propice à la POO (vous pouvez faire de l'OO en C, mais cela ne vous aidera pas). idée en C ++ (à l'origine "C With Classes"), il est logique de rendre les membres privés par défaut.

En revanche, si Stroustrup avait changé la sémantique de structafin que ses membres soient privés par défaut, cela aurait rompu la compatibilité (ce n'est plus aussi souvent vrai que les normes divergeaient, mais tous les programmes C valides étaient également des programmes C ++ valides, qui a eu un grand effet sur le fait de donner un pied à C ++).

Un nouveau mot clé a donc classété introduit pour être exactement comme une structure, mais privé par défaut.

Si C ++ était venu de zéro, sans historique, il n'aurait probablement qu'un seul de ces mots clés. Cela n'aurait probablement pas non plus eu l'impact qu'il a eu.

En général, les gens auront tendance à utiliser struct lorsqu'ils font quelque chose comme la façon dont les structures sont utilisées en C; les membres publics, pas de constructeur (tant que ce n'est pas dans une union, vous pouvez avoir des constructeurs dans des structures, comme avec les classes, mais les gens ont tendance à ne pas le faire), pas de méthodes virtuelles, etc. Puisque les langages sont autant pour communiquer avec les gens qui lisent le code pour instruire les machines (ou bien nous nous en tiendrons aux assemblages et aux opcodes VM bruts), c'est une bonne idée de s'en tenir à cela.

Les membres de la classe sont privés par défaut. Les membres de Struct sont publics par défaut. En dehors de cela, il n'y a pas d'autres différences. Voir aussi cette question .

Selon Stroustrup dans le langage de programmation C ++ :

Le style que vous utilisez dépend des circonstances et du goût. Je préfère généralement utiliser structpour les classes qui ont toutes les données publiques. Je pense à ces classes comme «des types pas tout à fait appropriés, juste des structures de données».

Fonctionnellement, il n'y a pas de différence autre que le public / privé

STRUCT est un type de type de données abstrait qui divise un bloc de mémoire donné en fonction de la spécification de la structure. Les structures sont particulièrement utiles dans la sérialisation / désérialisation de fichiers car la structure peut souvent être écrite dans le fichier mot pour mot. (c'est-à-dire obtenir un pointeur sur la structure, utilisez la macro SIZE pour calculer le nombre d'octets à copier, puis déplacez les données dans ou hors de la structure.)

Les classes sont un type différent de type de données abstrait qui tentent d'assurer le masquage des informations. En interne, il peut y avoir une variété de machinations, de méthodes, de variables temporaires, de variables d'état. etc. qui sont tous utilisés pour présenter une API cohérente à tout code qui souhaite utiliser la classe.

En effet, les structures concernent les données, les classes concernent le code.

Cependant, vous devez comprendre que ce ne sont que des abstractions. Il est parfaitement possible de créer des structures qui ressemblent beaucoup à des classes et des classes qui ressemblent beaucoup à des structures. En fait, les premiers compilateurs C ++ n'étaient que des précompilateurs qui traduisent le code C ++ en C. Ainsi, ces abstractions sont un avantage pour la pensée logique, pas nécessairement un atout pour l'ordinateur lui-même.

Au-delà du fait que chacun est un type d'abstraction différent, les classes fournissent des solutions au casse-tête de nommage du code C. Comme vous ne pouvez pas avoir plus d'une fonction exposée avec le même nom, les développeurs suivaient un modèle de _ (). par exemple mathlibextreme_max (). En regroupant les API en classes, des fonctions similaires (que nous appelons ici "méthodes") peuvent être regroupées et protégées contre la dénomination des méthodes dans d'autres classes. Cela permet au programmeur de mieux organiser son code et d'augmenter la réutilisation du code. En théorie du moins.

1) Les membres d'une classe sont privés par défaut et les membres de struct sont publics par défaut.

Par exemple, le programme 1 échoue dans la compilation et le programme 2 fonctionne correctement.

// 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) Lors de la dérivation d'une structure à partir d'une classe / structure, le spécificateur d'accès par défaut pour une classe / structure de base est public. Et lors de la dérivation d'une classe, le spécificateur d'accès par défaut est privé.

Par exemple, le programme 3 échoue dans la compilation et le programme 4 fonctionne correctement.

// 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;
}

La seule autre différence est l'héritage par défaut des classes et des structures, qui, sans surprise, est respectivement privé et public.

1. Les membres d'une structure sont publics par défaut, les membres de la classe sont privés par défaut.
2. L'héritage par défaut pour la Structure d'une autre structure ou classe est public. L'héritage par défaut pour la classe d'une autre structure ou classe est privé.

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;
}

C'est sur VS2005.

Pas dans la spécification, non. La principale différence réside dans les attentes des programmeurs lorsqu'ils lisent votre code en 2 ans. les structures sont souvent supposées être POD. Les structures sont également utilisées dans la métaprogrammation de modèles lorsque vous définissez un type à des fins autres que la définition d'objets.

Une autre chose à noter, si vous avez mis à jour une application héritée qui avait des structures pour utiliser des classes, vous pourriez rencontrer le problème suivant:

L'ancien code a des structures, le code a été nettoyé et changé en classes. Une ou deux fonctions virtuelles ont ensuite été ajoutées à la nouvelle classe mise à jour.

Lorsque les fonctions virtuelles sont dans des classes, le compilateur ajoute en interne un pointeur supplémentaire aux données de classe pour pointer vers les fonctions.

Comment cela briserait l'ancien code hérité si dans l'ancien code quelque part la structure était effacée en utilisant memfill pour effacer tout cela à zéro, cela écraserait également les données de pointeur supplémentaires.

1. Les membres d'une classe définie avec le mot clé classsont privatepar défaut. Les membres d'une classe définie avec les mots-clés struct(ou union) sont publicpar défaut.

2. En l'absence d'un spécificateur d'accès pour une classe de base, publicest supposé lorsque la classe dérivée est déclarée structet privateest supposé lorsque la classe est déclarée class.

3. Vous pouvez déclarer un enum classmais pas un enum struct.

4. Vous pouvez utiliser template<class T>mais pas template<struct T>.

Notez également que la norme C ++ vous permet de déclarer un type en tant que a struct, puis de l'utiliser classlors de la déclaration du type et vice-versa. Aussi, std::is_class<Y>::valueest truepour Y étant un structet un class, mais est falsepour un enum class.

La différence entre classet structest une différence entre les mots clés, pas entre les types de données. Ces deux

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

les deux définissent un type de classe. La différence des mots clés dans ce contexte réside dans les différents accès par défaut:

• foo::x est public et foo_base hérité publiquement
• bar::xest privé et bar_basehérité en privé

Voici une bonne explication: http://carcino.gen.nz/tech/cpp/struct_vs_class.php

Donc, une fois de plus: en C ++, une structure est identique à une classe sauf que les membres d'une structure ont une visibilité publique par défaut, mais les membres d'une classe ont une visibilité privée par défaut.

C'est juste une convention. Les structures peuvent être créées pour contenir des données simples, mais évoluer ultérieurement avec l'ajout de fonctions membres et de constructeurs. En revanche, il est inhabituel de voir autre chose que public: l'accès dans une structure.

ISO IEC 14882-2003

9 cours

§3

Une structure est une classe définie avec la clé de classe struct ; ses membres et classes de base (article 10) sont publics par défaut (article 11).

Une autre différence principale concerne les modèles. Pour autant que je sache, vous pouvez utiliser une classe lorsque vous définissez un modèle mais PAS une structure.

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

Les autres réponses ont mentionné les valeurs par défaut privées / publiques (mais notez qu'une structure est une classe est une structure; ce ne sont pas deux éléments différents, juste deux façons de définir le même élément).

Ce qui peut être intéressant à noter (d'autant plus que le demandeur est susceptible d'utiliser MSVC ++ car il mentionne le C ++ "non managé"), c'est que Visual C ++ se plaint dans certaines circonstances si une classe est déclarée avec classpuis définie avec struct(ou peut-être l'inverse) ), bien que la norme le dise parfaitement légal.

• . Dans les classes, tous les membres par défaut sont privés, mais dans la structure, les membres sont publics par défaut.

  1. Il n'y a pas de terme comme constructeur et destructeur pour les structures, mais pour le compilateur de classe crée par défaut si vous ne fournissez pas.

  2. La taille de la structure vide est de 0 octet car la classe vide de Sizeof est de 1 octet. Le type d'accès par défaut à la structure est public. Une structure doit généralement être utilisée pour regrouper des données.

  Le type d'accès par défaut de la classe est privé et le mode par défaut pour l'héritage est privé. Une classe doit être utilisée pour regrouper les données et les méthodes qui opèrent sur ces données.

  En bref, la convention consiste à utiliser struct lorsque le but est de regrouper des données et à utiliser des classes lorsque nous avons besoin d'abstraction de données et, peut-être d'héritage.

  En C ++, les structures et les classes sont passées par valeur, sauf si elles sont explicitement dé-référencées. Dans d'autres langues, les classes et les structures peuvent avoir une sémantique distincte, c'est-à-dire. les objets (instances de classes) peuvent être passés par référence et les structures peuvent être passées par valeur. Remarque: Il y a des commentaires associés à cette question. Voir la page de discussion pour ajouter à la conversation.

Bien qu'impliqué par d'autres réponses, il n'est pas explicitement mentionné - que les structures sont compatibles C, selon l'utilisation; les classes ne le sont pas.

Cela signifie que si vous écrivez un en-tête que vous voulez être compatible C, vous n'avez pas d'autre option que struct (qui dans le monde C ne peut pas avoir de fonctions; mais peut avoir des pointeurs de fonction).

Vous pouvez considérer cela pour des directives sur le moment où aller pour la structure ou la classe, https://msdn.microsoft.com/en-us/library/ms229017%28v=vs.110%29.aspx .

√ CONSIDÉRER la définition d'une structure au lieu d'une classe si les instances du type sont petites et généralement de courte durée ou sont généralement intégrées dans d'autres objets.

X ÉVITEZ de définir une structure sauf si le type possède toutes les caractéristiques suivantes:

Il représente logiquement une valeur unique, similaire aux types primitifs (int, double, etc.).

Il a une taille d'instance inférieure à 16 octets.

C'est immuable.

Il n'aura pas à être emballé fréquemment.

La classe n'a de sens que dans le contexte du génie logiciel. Dans le contexte des structures de données et des algorithmes, la classe et la structure ne sont pas si différentes. Il n'y a aucune règle restreignant le fait que le membre de la classe doit être référencé.

Lorsque vous développez un grand projet avec des tonnes de personnes sans classe, vous pouvez enfin obtenir du code couplé compliqué car tout le monde utilise les fonctions et les données qu'il souhaite. La classe fournit des contrôles d'autorisation et inhérents pour améliorer le découplage et la réutilisation des codes.

Si vous lisez certains principes d'ingénierie logicielle, vous constaterez que la plupart des normes ne peuvent pas être mises en œuvre facilement sans classe. par exemple: http://en.wikipedia.org/wiki/SOLID_%28object-oriented_design%29

BTW, lorsqu'une structure alloue un crunch de mémoire et inclut plusieurs variables, les variables de type valeur indiquent que les valeurs sont incorporées là où la structure est allouée. En revanche, les valeurs des variables de type référence sont externes et référencées par un pointeur qui est également intégré à l'endroit où struct est alloué.

La différence entre les mots clés struct et class en C ++ est que, lorsqu'il n'y a pas de spécificateur spécifique sur un type de données composite particulier, alors par défaut struct ou union sont les mots clés publics qui considèrent simplement le masquage des données mais la classe est le mot clé privé qui considère le masquage du programme codes ou données. Certains programmeurs utilisent toujours struct pour les données et la classe pour le code. Pour plus d'informations, contactez d'autres sources.

De tous ces facteurs, on peut conclure que le concept Classe est très approprié pour représenter des objets du monde réel plutôt que des "Structures". En grande partie parce que les concepts POO utilisés en classe sont très pratiques pour expliquer des scénarios du monde réel, donc plus faciles à fusionner avec la réalité. Par exemple, l'héritage par défaut est public pour les structures, mais si nous appliquons cette règle pour le monde réel, c'est ridicule.Mais dans une classe, l'héritage par défaut est privé, ce qui est plus réaliste.

Quoi qu'il en soit, ce que je dois justifier, c'est que la classe est un concept beaucoup plus large et applicable dans le monde réel, tandis que la structure est un concept primitif avec une mauvaise organisation interne (la structure Eventhough suit les concepts de la POO, ils ont un mauvais sens)

La principale différence entre la structure et le mot clé de classe dans oops est qu'aucune déclaration de membre public et privé n'est présente dans la structure et que la fonction membre et membre de données peut être définie comme publique, privée et protégée.

** MISE À JOUR: ** Veuillez ignorer cette réponse. Je n'ai pas considéré la possibilité que pour la structure, la valeur n'était pas initialisée mais se trouvait juste être 0. Il n'y a pas de différence d'initialisation entre la structure et la classe.

Je vois une autre différence entre les structures et les classes liées à l'initialisation par défaut.

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();
}

Exécutez ce code et examinez myTester. Vous constaterez que pour m_Foo, la structure, m_Foo.a a été initialisée à 0, mais pour m_Bar, la classe, m_Bar.a n'est pas initialisée. Il semble donc qu'il y ait une différence dans ce que le constructeur par défaut fait pour struct vs classe. Je vois cela avec Visual Studio.

La principale différence entre struct et classe est que dans struct, vous ne pouvez déclarer que des variables de données de différents types de données tandis qu'en classe, vous pouvez déclarer des variables de données, des fonctions membres et ainsi vous pouvez manipuler des variables de données via des fonctions.

-> une autre chose pratique que je trouve dans la classe vs struct est que lors de l'implémentation de fichiers dans un programme si vous souhaitez effectuer plusieurs opérations d'une structure encore et encore sur chaque nouvel ensemble d'opérations, vous devez créer une fonction distincte et vous devez passer l'objet de struct après l'avoir lu dans le fichier afin de faire quelques opérations dessus. en classe si vous créez une fonction qui effectue à chaque fois des opérations sur les données nécessaires ... c'est facile, il vous suffit de lire l'objet à partir du fichier et d'appeler la fonction.

Mais cela dépend du programmeur de quelle manière il / elle trouve approprié ... selon moi, je préfère la classe à chaque fois juste parce qu'il prend en charge les POO et c'est la raison pour laquelle il est implémenté dans presque toutes les langues et c'est la merveilleuse caractéristique de la programmation de tous les temps; - )

Et oui, la différence la plus inoubliable que j'ai oublié de mentionner est que la classe prend en charge le masquage des données et prend également en charge les opérations qui sont effectuées sur des types de données intégrés tandis que struct ne fonctionne pas!

J'ai trouvé une autre différence. si vous ne définissez pas de constructeur dans une classe, le compilateur en définira un. mais dans une structure si vous ne définissez pas de constructeur, le compilateur ne définit pas non plus de constructeur. donc dans certains cas où nous n'avons vraiment pas besoin d'un constructeur, struct est un meilleur choix (astuce performance). et désolé pour mon mauvais anglais.

Les classes sont des types de référence et les structures sont des types de valeurs.
Quand je dis que les classes sont des types de référence,
elles contiennent essentiellement l'adresse d'une variable d'instance.

Par exemple:

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.
}

Dans la méthode principale,
je peux créer une instance de cette classe en utilisant un nouvel opérateur qui alloue de la mémoire pour cette classe
et stocke l'adresse de base de celle-ci dans la variable de type MyClass (_myClassObject2).

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

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

Dans le programme ci-dessus, MyClass _myClassObject2 = _myClassObject1; indique que les deux variables de type MyClass

1. myClassObject1
2. myClassObject2

et pointera vers le même emplacement mémoire.
Il affecte fondamentalement le même emplacement de mémoire dans une autre variable du même type.

Donc, si des modifications que nous apportons à l'un des objets, tapez MyClass aura un effet sur un autre
puisque les deux pointent vers le même emplacement de mémoire.

"_myClassObject1.DataMember = 10;" sur cette ligne, les deux membres de données de l'objet contiendront la valeur de 10.
"_myClassObject2.DataMember = 20;" sur cette ligne, le membre de données de l'objet contient la valeur de 20.
Finalement, nous accédons aux membres de données d'un objet via des pointeurs.

Contrairement aux classes, les structures sont des types de valeur. Par exemple:

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;
}

Dans le programme ci-dessus,
instanciation de l'objet de type MyStructure à l'aide d'un nouvel opérateur et
stockage de l'adresse dans la variable _myStructObject de type MyStructure et
affectation de la valeur 10 au membre de données de la structure à l'aide de "_myStructObject1.DataMember = 10".

Dans la ligne suivante,
je déclare une autre variable _myStructObject2 de type MyStructure et j'assigne _myStructObject1 à cela.
Ici, le compilateur .NET C # crée une autre copie de l'objet _myStructureObject1 et
affecte cet emplacement mémoire dans la variable MyStructure _myStructObject2.

Donc, quel que soit le changement que nous effectuons sur _myStructObject1, il n'aura jamais d'effet sur une autre variable _myStructObject2 de type MyStructrue.
C'est pourquoi nous disons que les structures sont des types de valeur.

Ainsi, la classe de base immédiate pour la classe est Object et la classe de base immédiate pour Structure est ValueType qui hérite de Object.
Les classes prendront en charge un héritage, contrairement aux structures.

Comment dit-on cela?
Et quelle est la raison derrière cela?
La réponse est Classes.

Il peut être abstrait, scellé, statique et partiel et ne peut pas être privé, protégé et protégé en interne.

Il y a 3 différences fondamentales entre la structure et la classe

La mémoire 1St- est réservée à la structure en mémoire de pile (qui est proche du langage de programmation), que la classe en mémoire de pile soit réservée à la référence seule et la mémoire réelle est réservée en mémoire de tas.

2Nd - Par défaut, la structure traite comme un public si la classe est considérée comme un privé.

3Rd- ne peut pas réutiliser le code dans la structure mais en classe, nous pouvons réutiliser le même code dans de nombreux temps appelé héritage