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

Cette question a déjà été posée dans le contexte 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 commencerai 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 recoins obscurs de la spécification C ++.

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

Le standard (§11.2.2 en C ++ 98 à C ++ 11):

En l’absence d’un spécificateur d’ access pour une classe de base, public est supposé lorsque la classe dérivée est déclarée struct et private est supposée lorsque la classe est déclarée class .

Et par souci d’exhaustivité, la différence la plus connue entre class et struct est définie dans (11.2):

Les membres d’une classe définie avec la classe de mots-clés 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: la class mots-clés peut être utilisée pour déclarer des parameters de modèle, alors que le mot struct clé struct ne peut pas être utilisé de la sorte.

Citant la FAQ C ++ ,

[7.8] Quelle est la différence entre les mots-clés struct et class?

Les membres et les classes de base d’une structure sont publiques par défaut, tandis que dans la 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.

La structure et la classe sont par ailleurs fonctionnellement équivalentes.

OK, assez de cette conversation techno impeccable. Sur le plan émotionnel, la plupart des développeurs font une distinction forte entre une classe et une structure. Une structure ressemble simplement à une stack de bits ouverte 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 barrière d’encapsulation solide et une interface bien définie. Comme 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 qui a des données publiques (de telles choses existent dans des systèmes bien conçus!) mot-clé.

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

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

Etre public par défaut est généralement considéré comme une mauvaise idée lorsqu’on adopte une approche orientée object, donc en faisant une forme de C qui est nativement favorable à la POO (vous pouvez faire 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.

D’un autre côté, si Stroustrup avait modifié la sémantique de struct pour que ses membres soient privés par défaut, la compatibilité serait rompue (ce n’est plus aussi souvent vrai que les normes divergent, mais tous les programmes C valides étaient également des programmes C ++ valides). , ce qui a eu un grand effet en donnant au C ++ un pied d’attaque).

Donc, un nouveau mot-clé, class été introduit pour être exactement comme une structure, mais privé par défaut.

Si C ++ venait de zéro, sans historique, alors il n’y aurait probablement qu’un seul de ces mots-clés. Cela n’aurait probablement pas eu l’impact escompté.

En général, les gens auront tendance à utiliser struct quand ils font quelque chose comme la façon dont les structures sont utilisées dans C; membres publics, pas de constructeur (tant que ce n’est pas dans une union, vous pouvez avoir des constructeurs dans les structures, comme avec les classes, mais les gens ont tendance à ne pas le faire), les gens qui lisent le code comme pour instruire les machines (ou alors nous nous en tenions à l’assemblage 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 outre, 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 struct pour les classes qui ont toutes les données publiques. Je pense à de telles 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 verbatim. (c.-à-d. 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 de type de données abstrait différent qui tente de masquer les informations. En interne, il peut y avoir diverses machinations, méthodes, variables temporaires, 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 des 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 ++ étaient simplement 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 chaque type est un type d’abstraction différent, les classes fournissent des solutions au casse-tête du nommage en code C. Comme vous ne pouvez pas exposer plus d’une fonction avec le même nom, les développeurs ont suivi un modèle de _ (). p.ex. mathlibextreme_max (). En regroupant les API en classes, des fonctions similaires (ici on les appelle “méthodes”) peuvent être regroupées et protégées de 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, au moins.

La seule autre différence est l’inheritance par défaut des classes et des structures, ce qui n’est pas surprenant, respectivement, privé et public.

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  class Test { int x; // x is private }; int main() { Test t; tx = 20; // comstackr error because x is private getchar(); return 0; } Run on IDE // Program 2 #include  struct Test { int x; // x is public }; int main() { Test t; tx = 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’access par défaut pour une classe / structure de base est public. Et lors de la dérivation d’une classe, le spécificateur d’access par défaut est privé.

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

 // Program 3 #include  class Base { public: int x; }; class Derived : Base { }; // is equilalent to class Derived : private Base {} int main() { Derived d; dx = 20; // comstackr error becuase inheritance is private getchar(); return 0; } Run on IDE // Program 4 #include  class Base { public: int x; }; struct Derived : Base { }; // is equilalent to struct Derived : public Base {} int main() { Derived d; dx = 20; // works fine becuase inheritance is public getchar(); return 0; } 

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’objects.

Une autre chose à noter, si vous avez mis à jour une application héritée ayant 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 ceux-ci ont 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 la classe pour indiquer les fonctions.

La façon dont cela briserait l’ancien code hérité est que si dans l’ancien code quelque part, la structure était effacée à l’aide de memfill pour effacer tout à zéro, cela détruirait également les données supplémentaires du pointeur.

  1. Les membres d’une structure sont publics par défaut, les membres de la classe sont privés par défaut.
  2. L’inheritance par défaut pour Structure d’une autre structure ou classe est public.Default l’inheritance d’une 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; } 

Ceci est sur VS2005.

Une autre différence majeure 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 // OK template // ERROR, struct not allowed here 
  • . 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 structs, mais pour la classe, le compilateur crée un défaut si vous ne le fournissez pas.

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

    Le type d’access par défaut à la classe est privé et le mode par défaut pour l’inheritance est privé. Une classe doit être utilisée pour regrouper les données et les méthodes qui fonctionnent sur ces données.

    En résumé, la convention consiste à utiliser struct lorsque l’objective est de regrouper des données et d’utiliser des classes lorsque nous avons besoin d’une abstraction de données et, peut-être, d’un inheritance.

    Dans C ++, les structures et les classes sont transmises par valeur, sauf si elles sont explicitement dé-référencées. Dans d’autres langages, les classes et les structures peuvent avoir une sémantique distincte – c.-à-d. les objects (instances de classes) peuvent être passés par référence et les structures peuvent être passées par valeur. Note: Il y a des commentaires associés à cette question. Voir la page de discussion pour append à la conversation.

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

Donc, encore une fois: 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 évoluent ultérieurement avec l’ajout de fonctions membres et de constructeurs. D’un autre côté, il est inhabituel de voir autre chose que public: l’access dans une structure.

ISO IEC 14882-2003

9 cours

§3

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

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

Ce qui pourrait être intéressant à noter (d’autant plus que le demandeur utilisera probablement MSVC ++ puisqu’il mentionne le C ++ “non géré”) est que Visual C ++ se plaint dans certaines circonstances si une classe est déclarée avec class puis définie avec struct (ou éventuellement l’autre) bien sûr), même si la norme dit que cela est parfaitement légal.

Bien qu’impliqué par d’autres réponses, il n’est pas explicitement mentionné – que les structures sont compatibles C, en fonction de leur utilisation; les classes ne sont pas.

Cela signifie que si vous écrivez un en-tête que vous voulez être compatible C, alors 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).

La différence entre les mots clés struct et class dans C ++ est que, lorsqu’il n’y a pas de spécificateur spécifique sur un type de données composite particulier, struct ou union est par défaut les mots-clés publics qui se contentent de masquer les données mais class est le mot-clé privé 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 Class est très approprié pour représenter des objects du monde réel plutôt que des “structures”. En effet, les concepts de POO utilisés en classe sont très pratiques pour expliquer des scénarios réels plus faciles à fusionner. Par exemple, l’inheritance par défaut est public pour les structs mais si nous appliquons cette règle pour le monde réel, c’est ridicule. Mais dans une classe, l’inheritance par défaut est privé, ce qui est plus réaliste.

Quoi qu’il en soit, ce que je dois justifier, c’est que Class est un concept beaucoup plus vaste et applicable dans le monde réel, alors que Structure est un concept primitif avec une organisation interne médiocre (même si les structures suivent les concepts de la POO)

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 pas de règle restreinte dont 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 un code couplé compliqué car tout le monde utilise les fonctions et les données souhaitées. classe fournit des contrôles d’autorisation et hérite pour améliorer le découplage et la réutilisation des codes.

Si vous lisez certains principes de génie logiciel, 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, Quand une structure alloue une quantité de mémoire et inclut plusieurs variables, les variables de type valeur indiquent que les valeurs sont intégrées à la structure où struct est allouée. En revanche, les valeurs des variables de type référence sont externes et référence par un pointeur qui est également intégré à l’emplacement où struct est alloué.

Vous pouvez envisager cela pour obtenir des directives sur le moment de choisir struct ou class, https://msdn.microsoft.com/en-us/library/ms229017%28v=vs.110%29.aspx .

√ CONSIDERER de définir une structure à la place d’une classe si les instances de ce type sont petites et généralement de courte durée ou sont généralement incorporées dans d’autres objects.

X AVOID définissant une structure à moins que le type ait 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 ne sera pas nécessaire de l’encadrer fréquemment.

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, nous n’avons vraiment pas besoin de constructeur, struct est un meilleur choix (conseil en performance). et désolé pour mon mauvais anglais.

La principale différence entre la structure et le mot-clé de classe dans oops est que, aucune déclaration de membre public ou privé n’est présente dans la structure. Le membre de données et la fonction membre peuvent être définis comme publics, privés et protégés.

Je vois une autre différence entre les structures et les classes ayant trait à 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 trouverez 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 y avoir une différence dans ce que fait le constructeur par défaut pour struct vs class. Je le vois avec Visual Studio.

La principale différence entre struct et class est que, dans struct, vous ne pouvez déclarer que des variables de données de différents types de données alors que vous pouvez déclarer des variables de données, des fonctions membres et donc manipuler des variables de données via des fonctions.

-> Une autre chose pratique que je trouve en classe vs struct est que lors de l’implémentation de fichiers dans un programme, si vous voulez effectuer certaines 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 Passez l’object de struct après l’avoir lu dans le fichier afin d’y effectuer des opérations. Pendant que vous êtes en classe, si vous faites à chaque fois une fonction effectuant des opérations sur les données, il vous suffit de lire l’object du fichier et d’appeler la fonction.

Mais cela dépend du programmeur de la manière dont il / elle le trouve approprié … selon moi, je préfère le cours tout le temps simplement parce qu’il supporte les POO et que c’est la raison pour laquelle il est implémenté dans presque toutes les langues. )

Et oui, la différence la plus inattendue 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 effectuées sur les types de données intégrés alors que struct doesnt!

Les classes sont des types de référence et les structures sont des types de valeurs.
Quand je dis les classes sont des types de référence,
fondamentalement, ils contiendront 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 (ssortingng[] arg) { MyClass _myClassObject1 = new MyClass(); _myClassObject1.DataMember = 10; MyClass _myClassObject2 = _myClassObject1; _myClassObject2.DataMember=20; } 

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

  1. myClassObject1
  2. myClassObject2

et pointera vers le même emplacement mémoire.
Il atsortingbue essentiellement le même emplacement mémoire à une autre variable du même type.

Donc, si des modifications que nous apportons à l’un des objects du type MyClass auront un effet sur un autre
puisque les deux pointent vers le même emplacement mémoire.

“_myClassObject1.DataMember = 10;” à cette ligne, les membres de données de l’object contiendront la valeur 10.
“_myClassObject2.DataMember = 20;” à cette ligne, le membre de données de l’object contiendra la valeur 20.
Finalement, nous accédons à des datamembers d’un object 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 (ssortingng[] arg) { MyStructure _myStructObject1 = new MyStructure(); _myStructObject1.DataMember = 10; MyStructure _myStructObject2 = _myStructObject1; _myStructObject2.DataMember = 20; } 

Dans le programme ci-dessus,
instanciation de l’object de type MyStructure en utilisant new operator et
stocker l’adresse dans la variable _myStructObject de type MyStructure et
affecter 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 en y affectant _myStructObject1.
Ici, le compilateur .NET C # crée une autre copie de l’object _myStructureObject1 et
assigne cet emplacement mémoire à la variable MyStructure _myStructObject2.

Ainsi, tout changement que nous apportons à _myStructObject1 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.

La classe de base immédiate pour la classe est donc Object et la classe de base immédiate pour Structure est ValueType qui hérite de Object.
Les classes supporteront un inheritance alors que les structures ne le feront pas.

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 être privé, protégé et protégé en interne.

There are 3 basic difference between structure and class

1St- memory are reserved for structure in stack memory (which is near to programming language )whether for class in stack memory are reserved for only reffrence and actual memory are reserved in heap memory.

2Nd – By default structure treat as a public whether class treat as a private .

3Rd- can’t re -use code in structure but in class we can re-use same code in many time called inhertence