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

Question

Cette question était déjà posée dans le contexte de C # /. Net .

J'aimerais maintenant 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’un ou l’autre dans la conception orientée objet.

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 angles obscurs de la spécification C ++.

Answer 1

Vous oubliez la délicate seconde différence entre les classes et les structures.

La norme (& # 167; 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é   quand 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 plus largement connue entre class et struct est définie dans (11.2):

  

Membre d'une classe définie avec le   les mots clés classe sont privés par   défaut. Membres d'une classe définie   avec les mots clés struct ou union   sont public par défaut.

Différence supplémentaire: le mot clé class peut être utilisé pour déclarer des paramètres de modèle, alors que le mot clé struct ne peut pas être utilisé de la sorte.

Answer 2

Citation de la FAQ sur C ++ ,

  

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

     

Les membres et les classes de base d'un   struct sont publiques par défaut, alors que dans   classe, ils sont par défaut privés. Remarque:   vous devriez faire vos classes de base   explicitement public, privé ou   protégé plutôt que de compter sur le   valeurs par défaut.

     

Struct et class sont autrement   fonctionnellement équivalent.

     

OK, assez de cette propreté impeccable   conversation techno. Émotionnellement, la plupart   les développeurs font une distinction forte   entre une classe et une struct. UNE   struct se sent simplement comme une pile ouverte   de bits avec très peu de   encapsulation ou fonctionnalité. UNE   la classe se sent comme une vie et   membre responsable de la société avec   services intelligents, une forte   barrière d'encapsulation, et un puits   interface définie. Depuis c'est la   connotation la plupart des gens ont déjà,   vous devriez probablement utiliser la structure   mot-clé 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!), mais sinon vous devriez   utilisez probablement le mot-clé de classe.

Answer 3

Cela vaut la peine de rappeler les origines de C ++ et leur compatibilité 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 objet. Il est donc préférable de créer une forme de C propice nativement à la programmation orientée objet (vous pouvez utiliser OO en C, mais cela ne vous aidera pas). C’était l’idée en C ++ (à l’origine & "C avec les classes &"), il est logique de rendre les membres privés par défaut.

D’autre part, si Stroustrup avait changé la sémantique de struct de sorte que ses membres soient privés par défaut, la compatibilité serait rompue (ce n’est plus aussi vrai que les normes divergeaient, mais tous les programmes C valides étaient également des programmes C ++ valides, ce qui a eu un effet important sur l’introduction du C ++).

Ainsi, un nouveau mot clé, class, a été introduit pour ressembler exactement à une structure, mais privé par défaut.

Si C ++ venait de zéro, sans historique, il n'aurait probablement qu'un seul mot clé. Cela n’aurait probablement pas eu l’impact qu’il avait eu.

En général, les gens ont tendance à utiliser struct lorsqu'ils font quelque chose de similaire à la façon dont les struct sont utilisées en C; membres du public, 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), pas de méthodes virtuelles, etc. Depuis les langues servent autant à communiquer avec les lecteurs du code qu’à donner des instructions à des machines (sinon nous collons avec des opcodes assemblés et bruts), c’est une bonne idée.

Answer 4

Les membres de la classe sont privés par défaut. Les membres de Struct sont publics par défaut. Outre cela, il n'y a pas d'autres différences. Consultez également cette question . / p>

Answer 5

Selon Stroustrup dans le langage de programmation C ++ :

  

Le style que vous utilisez dépend des circonstances et des goûts. Je préfère généralement utiliser struct pour les classes qui ont toutes les données publiques. Je pense à des classes telles que & "Des types pas tout à fait appropriés, juste des structures de données. &";

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

Answer 6

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 pour la sérialisation / désérialisation de fichiers car la structure peut souvent être écrite intégralement dans le fichier. (Par exemple, obtenez 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 garantir la dissimulation des informations. En interne, il peut y avoir une variété de machinations, méthodes, variables temp, 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 ++ étaient simplement des pré-compilateurs qui traduisaient 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 d'abstraction est différent, les classes apportent des solutions au casse-tête de nommage de code C. Comme vous ne pouvez pas exposer plus d’une fonction au même nom, les développeurs suivaient un modèle de _ (). par exemple. mathlibextreme_max (). En regroupant les API dans des classes, des fonctions similaires (appelées ici & "Méthodes &") Peuvent être regroupées et protégées du nom des méthodes d'autres classes. Cela permet au programmeur de mieux organiser son code et d’augmenter sa réutilisation. En théorie, au moins.

Answer 7

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 lors de 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 d'une classe / structure, le spécificateur d'accès par défaut pour une classe / structure de base est public. Et lorsque vous dérivez une classe, le spécificateur d'accès par défaut est privé.

Par exemple, le programme 3 échoue lors de 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;
}

Answer 8

La seule autre différence réside dans l'héritage par défaut des classes et des structures, qui sont sans surprise privées et publiques, respectivement.

Answer 9

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

Answer 10

Une autre chose à noter, si vous mettiez à jour une application héritée avec 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 modifié en classes. Une ou deux fonctions virtuelles ont ensuite été ajoutées à la nouvelle classe mise à jour.

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

Cela aurait pour effet de casser l'ancien code hérité si, dans l'ancien code quelque part, la structure était effacée à l'aide de memfill pour tout effacer en zéros, cela écraserait également les données de pointeur supplémentaires.

Answer 11

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 provenant d'une autre structure ou classe est public. L'héritage par défaut pour la classe provenant 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.

Answer 12

Une autre différence majeure concerne les modèles. 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

Answer 13

1. Les membres d'une classe définie avec le mot clé class sont private par défaut. Les membres d'une classe définie avec les mots clés struct (ou union) sont public par défaut.

2. En l'absence d'un spécificateur d'accès pour une classe de base, enum class est supposé lorsque la classe dérivée est déclarée enum struct et template<class T> est présumé lorsque la classe est déclarée template<struct T>.

3. Vous pouvez déclarer un std::is_class<Y>::value mais pas un true.

4. Vous pouvez utiliser false mais pas <=>.

Notez également que la norme C ++ vous permet de déclarer un type en tant que <=>, puis d'utiliser <=> lors de la déclaration du type et inversement. De plus, <=> est <=> pour Y étant un <=> et un <=>, mais <=> pour un <=>.

Answer 14

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 que les membres d'une classe ont une visibilité privée par défaut.

Answer 15

C'est juste une convention. Des structures peuvent être créées pour contenir des données simples, mais évoluent ensuite dans le temps avec l'ajout de fonctions membres et de constructeurs. Par ailleurs, il est inhabituel de voir autre chose que public: accès dans une structure.

Answer 16

  

ISO CEI 14882-2003

     

9 classes

     

& # 167; 3

     

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

Answer 17

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

Ce qui pourrait être intéressant à noter (en particulier étant donné que le demandeur utilise probablement MSVC ++ puisqu'il mentionne & "unmanaged &"; C ++), c'est que Visual C ++ se plaint dans certaines circonstances si une classe est déclarée avec class et ensuite défini avec struct (ou éventuellement l'inverse), bien que la norme indique que cela est parfaitement légal.

Answer 18

• . Dans les classes, tous les membres par défaut sont privés mais de 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 classes, crée par défaut si vous ne fournissez pas.

  2. La taille de la structure vide de 0 octets est égale à 1 octet pour la classe de taille vide Le type d'accès par défaut à la structure est public. Un struct devrait généralement être utilisé pour regrouper des données.

  Le type d'accès par défaut à la classe est privé et le mode par défaut pour l'héritage est privé. Une classe devrait être utilisée pour regrouper les données et méthodes qui fonctionnent 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'une abstraction de données et, peut-être l'héritage.

  En C ++, les structures et les classes sont passées par valeur, sauf si explicitement dé-référencé. Dans d’autres langues, les classes et les structures peuvent avoir 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. Note: Il y a commentaires associés à cette question. Voir la page de discussion pour ajouter à la conversation.

Answer 19

Bien que impliqué par d’autres réponses, il n’est pas explicitement mentionné - les structures sont compatibles avec le langage C, en fonction de l’utilisation; les classes ne sont pas.

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

Answer 20

La différence entre class et struct est une différence entre les mots-clés et non entre les types de données. Ces deux

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

définissent tous deux un type de classe. La différence des mots-clés dans ce contexte est l’accès par défaut différent:

• foo::x est public et foo_base hérité publiquement
• bar::x est privé et bar_base hérité de manière privée

Answer 21

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, classe et structure ne sont pas si différentes. Il n'y a aucune règle restreinte membre de cette classe doit être référencé.

Lorsque vous développez un projet volumineux 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 de son choix. class fournit des contrôles de permission et des ressources inhérentes 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://fr.wikipedia.org/wiki/SOLID_%28object-oriented_design%29

BTW, quand 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'emplacement où la structure est allouée. En revanche, les valeurs de la variable de type référence sont externes et référencées par un pointeur qui est également incorporé à l'emplacement où struct est alloué.

Answer 22

Vous pouvez envisager cette option pour savoir quand opter pour une structure ou une classe, https://msdn.microsoft.com/en-us/library/ms229017%28v=vs.110%29.aspx .

  

& # 8730; CONSIDER définir une structure au lieu d’une classe si des instances de   type sont petits et ont généralement une courte durée de vie ou sont généralement intégrés à   autres objets.

     

X ÉVITER de définir une structure sauf si le type a tout   les caractéristiques suivantes:

     

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

     

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

     

C'est immuable.

     

Il ne devra pas être mis en boîte   fréquemment.

Answer 23

La différence entre les mots clés struct et classe 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 de données, alors que classe est le mot clé privé qui envisage le masquage de codes de programme ou de données. Certains programmeurs utilisent toujours struct pour les données et classe pour des raisons de code. Pour plus d'informations, contactez d'autres sources.

Answer 24

Parmi tous ces facteurs, on peut conclure que le concept Class est très approprié pour représenter des objets du monde réel plutôt que & "Structures &"; surtout que les concepts de POO utilisés en classe sont très pratiques pour expliquer Les scénarios du monde réel sont 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 au 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 j’ai besoin de justifier, c’est Class, c’est un concept beaucoup plus large, applicable dans le monde réel, tandis que Structure est un concept primitif avec une organisation interne médiocre (Eventhough struct suit les concepts de POO, ils ont un mauvais sens)

Answer 25

La principale différence entre les mots clés structure et class dans oops réside dans le fait qu’aucune déclaration de membre public et privé n’est présente dans structure.et que le membre data et la fonction membre peuvent être définis comme publics, privés ou protégés.

Answer 26

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 de constructeur, struct est un meilleur choix (astuce de performance). et désolé pour mon mauvais anglais.

Answer 27

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,
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 cela 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; instruction indique que les deux variables de type MyClass

    
1. myClassObject1
    
2. myClassObject2

et pointera vers le même emplacement mémoire.
Fondamentalement, il attribue le même emplacement mémoire à une autre variable du même type.

Donc, si des modifications que nous apportons à l'un des objets, le type MyClass aura un effet sur un autre

puisque les deux pointent vers le même emplacement mémoire.

" _myClassObject1.DataMember = 10; " sur cette ligne, les membres de l'objet de données & # 8217; contiendront la valeur de 10.
" _myClassObject2.DataMember = 20; " sur cette ligne, le membre de données de l'objet & # 8217; contient la valeur 20. "
Finalement, nous accédons aux données d'un objet par 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,
instanciant l'objet de type MyStructure en utilisant nouvel opérateur et
stockant 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 assigne _myStructObject1 dans celle-ci.
Ici, le compilateur .NET C # crée une autre copie de l'objet _myStructureObject1 et
assigne cet emplacement mémoire dans la variable MyStructure _myStructObject2.

Ainsi, quelle que soit la modification apportée à _myStructObject1, celle-ci n'aura jamais d'effet sur une autre variable _myStructObject2 de type MyStructrue.
C’est & # 8217; pourquoi nous disons que les structures sont des types de valeur.

La classe de base immédiate de la classe est donc Object et la classe de base immédiate de la Structure est ValueType, qui hérite de Object.
Les classes prendront en charge un héritage alors que les structures ont gagné & # 8217; t.

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

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

Answer 28

La principale différence entre struct et class réside dans le fait que dans struct, vous ne pouvez déclarer que des variables de données de différents types de données, alors que dans class, vous pouvez déclarer des variables de données, des fonctions membres et donc que vous pouvez manipuler des variables de données à l'aide de fonctions.

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

Mais cela dépend du programmeur de la manière qu’il / elle juge appropriée ... selon moi, je préfère les cours à chaque fois, tout simplement parce qu’ils prennent en charge le POO et que c’est la raison pour laquelle il est implémenté dans presque toutes les langues et c’est la merveilleuse fonctionnalité de tous les temps. programmation ;-)

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

Answer 29

** UPDATE: ** Veuillez ignorer cette réponse. Je n'ai pas envisagé la possibilité que, pour la structure, la valeur ait été non initialisée, mais qu'il s'agisse simplement de 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 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 constaterez que pour m_Foo, la structure m_Foo.a a été initialisée à 0, mais que pour m_Bar, la classe m_Bar.a n'est pas initialisée. Il semble donc y avoir une différence entre ce que le constructeur par défaut fait pour struct vs class. Je vois cela avec Visual Studio.

Answer 30

Il existe 3 différences fondamentales entre structure et classe

1St-memory sont réservés pour la structure dans la mémoire de pile (ce qui est proche du langage de programmation), que ce soit pour la classe dans la mémoire de pile sont réservés uniquement pour la mémoire et la mémoire réelle est réservée dans la mémoire de tas.

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

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