Quand devriez-vous utiliser une classe ou une structure en C ++?

Dans quels scénarios est-il préférable d’utiliser une struct vs une class en C ++?

Les différences entre une class et une struct en C ++ sont que les structures ont public membres public par défaut et que les bases et les classes ont des bases et private membres private . Les classes et les structures peuvent avoir un mélange de membres public , protected et private , peuvent utiliser l’inheritance et peuvent avoir des fonctions membres.

Je recommanderais d’utiliser des structures comme des structures de données simples, dépourvues de fonctionnalités de classe, et d’utiliser des classes comme structures de données agrégées avec private données private et des fonctions membres.

Comme tout le monde le note, il n’y a vraiment que deux différences de langue:

  • struct défaut est l’access public et la class défaut à l’access privé.
  • Lors de l’inheritance, la struct défaut est public inheritance public et class valeurs par défaut de la class private inheritance private . (Ironiquement, comme avec beaucoup de choses en C ++, la valeur par défaut est en arrière: public inheritance public est de loin le choix le plus courant, mais les gens déclarent rarement struct pour économiser sur le mot clé ” public “.

Mais la vraie différence dans la pratique se situe entre une class / struct qui déclare un constructeur / destructeur et une autre qui ne le fait pas. Il existe certaines garanties à un type de POD “plain-old-data”, qui ne s’applique plus une fois que vous avez pris en charge la construction de la classe. Pour que cette distinction rest claire, de nombreuses personnes n’utilisent délibérément que struct pour les types de POD et, si elles veulent append des méthodes, utilisent la class es. La différence entre les deux fragments ci-dessous est autrement dénuée de sens:

 class X { public: // ... }; struct X { // ... }; 

(Incidemment, voici un fil avec quelques bonnes explications sur ce que signifie réellement le “type POD”: Quels sont les types de POD en C ++? )

Les réponses existantes comportent de nombreuses idées fausses.

class et struct déclarent une classe.

Oui, vous devrez peut-être réorganiser vos mots-clés de modification d’access dans la définition de la classe, en fonction du mot-clé que vous avez utilisé pour déclarer la classe.

Mais, au-delà de la syntaxe, la seule raison de choisir l’un est la convention / style / préférence.

Certaines personnes aiment conserver le mot struct clé struct pour les classes sans fonctions membres, car la définition qui en résulte “ressemble” à une structure simple de C.

De même, certains utilisateurs préfèrent utiliser le mot class clé class pour les classes avec des fonctions membres et private données private , car il indique «class» et ressemble donc à des exemples tirés de leur livre préféré sur la programmation orientée object.

La réalité est que cela dépend entièrement de vous et de votre équipe, et cela ne fera littéralement aucune différence pour votre programme.

Les deux classes suivantes sont absolument équivalentes, sauf leur nom:

 struct Foo { int x; }; class Bar { public: int x; }; 

Vous pouvez même changer de mot-clé lors de la redéclaration:

 class Foo; struct Bar; 

(bien que certains compilateurs émettent un avertissement lorsque vous faites cela, en supposant que vous n’avez probablement pas l’ intention de faire quelque chose d’aussi déroutant et que vous devriez donc être invité à vérifier votre code.)

et les expressions suivantes sont toutes deux évaluées à true:

 std::is_class::value std::is_class::value 

Notez, cependant, que vous ne pouvez pas changer les mots-clés lors de la redéfinition ; c’est uniquement parce que (selon la règle de la définition unique) les définitions de classes dupliquées entre unités de traduction doivent “se composer de la même séquence de jetons” . Cela signifie que vous ne pouvez même pas échanger le const int member; avec int const member; , et n’a rien à voir avec la sémantique de la class ou de la struct .

La seule fois où j’utilise une structure au lieu d’une classe, c’est lorsque vous déclarez un foncteur juste avant de l’utiliser dans un appel de fonction et que vous souhaitez minimiser la syntaxe pour des raisons de clarté. par exemple:

 struct Compare { bool operator() { ... } }; std::sort(collection.begin(), collection.end(), Compare()); 

De la FAQ C ++ Lite :

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.

struct et class sont par ailleurs fonctionnellement équivalents.

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

Un endroit où une structure m’a été utile est celui où un système reçoit des messages au format fixe (par exemple, un port série) provenant d’un autre système. Vous pouvez convertir le stream d’octets en une structure qui définit vos champs, puis accéder facilement aux champs.

 typedef struct { int messageId; int messageCounter; int messageData; } tMessageType; void processMessage(unsigned char *rawMessage) { tMessageType *messageFields = (tMessageType *)rawMessage; printf("MessageId is %d\n", messageFields->messageId); } 

Evidemment, c’est la même chose que dans C, mais je trouve que le fait de devoir décoder le message en classe ne vaut généralement pas la peine.

Vous pouvez utiliser “struct” en C ++ si vous écrivez une bibliothèque dont les composants internes sont en C ++, mais que l’API peut être appelée par code C ou C ++. Vous créez simplement un en-tête unique contenant des structures et des fonctions API globales que vous exposez au code C et C ++ comme suit:

 // C access Header to a C++ library #ifdef __cpp extern "C" { #endif // Put your C struct's here struct foo { ... }; // NOTE: the typedef is used because C does not automatically generate // a typedef with the same name as a struct like C++. typedef struct foo foo; // Put your C API functions here void bar(foo *fun); #ifdef __cpp } #endif 

Ensuite, vous pouvez écrire une barre de fonctions () dans un fichier C ++ en utilisant le code C ++ et le rendre appelable à partir de C et les deux mondes peuvent partager des données via les structures déclarées. Bien sûr, il y a d’autres réserves lorsque vous mélangez C et C ++, mais c’est un exemple simplifié.

Comme chacun le dit, la seule différence réelle est l’access par défaut. Mais j’utilise particulièrement struct quand je ne veux aucune sorte d’encapsulation avec une classe de données simple, même si j’implémente certaines méthodes d’assistance. Par exemple, quand j’ai besoin de quelque chose comme ça:

 struct myvec { int x; int y; int z; int length() {return x+y+z;} }; 

Les structures ( POD , plus généralement) sont pratiques lorsque vous fournissez une interface compatible C avec une implémentation C ++, car elles sont portables entre les frontières de langue et les formats de l’éditeur de liens.

Si cela ne vous concerne pas, alors je suppose que l’utilisation de “struct” au lieu de “class” est un bon moyen de communication (comme @ZeroSignal dit ci-dessus). Les structures ont également une sémantique de copie plus prévisible, elles sont donc utiles pour les données que vous prévoyez d’écrire sur un support externe ou d’envoyer via le réseau.

Les structures sont également pratiques pour diverses tâches de métaprogrammation, comme les modèles de traits qui exposent simplement un ensemble de types de caractères dépendants:

 template  struct type_traits { typedef T type; typedef T::iterator_type iterator_type; ... }; 

… Mais c’est vraiment juste profiter du niveau de protection par défaut de struct étant public …

Pour C ++, il n’y a pas vraiment de différence entre les structures et les classes. La principale différence fonctionnelle est que les membres d’une structure sont publics par défaut, alors qu’ils sont privés par défaut dans les classes. Sinon, en ce qui concerne la langue, ils sont équivalents.

Cela dit, j’ai tendance à utiliser des structures en C ++ comme dans C #, comme le dit Brian. Les structures sont de simples conteneurs de données, tandis que les classes sont utilisées pour les objects qui doivent agir sur les données en plus de s’y accrocher.

Pour répondre à ma propre question (sans vergogne), comme déjà mentionné, les privilèges d’access sont la seule différence entre eux en C ++.

J’ai tendance à utiliser une structure uniquement pour le stockage de données. Je vais lui permettre d’obtenir quelques fonctions d’aide si cela facilite le travail avec les données. Cependant, dès que les données requièrent un contrôle de stream (c’est-à-dire des getters / setters qui maintiennent ou protègent un état interne) ou commencent à acquérir des fonctionnalités majeures (essentiellement de type object), elles seront mises à niveau vers une classe pour mieux communiquer leurs intentions.

Ils sont à peu près la même chose. Grâce à la magie de C ++, une structure peut contenir des fonctions, utiliser l’inheritance, créé en utilisant “new” et ainsi de suite, comme une classe

La seule différence fonctionnelle est qu’une classe commence par des droits d’access privés, tandis qu’une structure commence par public. C’est la compatibilité ascendante avec C.

En pratique, j’ai toujours utilisé des structures en tant que détenteurs de données et classes en tant qu’objects.

Classe.

Les membres de la classe sont privés par défaut.

 class test_one { int main_one(); }; 

Est équivalent à

 class test_one { private: int main_one(); }; 

Donc, si vous essayez

 int two = one.main_one(); 

Nous aurons une erreur: main_one is private car il n’est pas accessible. Nous pouvons le résoudre en l’initialisant en spécifiant son public

 class test_one { public: int main_one(); }; 

Struct.

Une structure est une classe où les membres sont publics par défaut.

 struct test_one { int main_one; }; 

Signifie que main_one est privé

 class test_one { public: int main_one; }; 

J’utilise des structures pour des structures de données où les membres peuvent prendre n’importe quelle valeur, c’est plus facile.

ils sont la même chose avec des valeurs par défaut différentes (privé par défaut pour la class et public par défaut pour struct ), donc en théorie, ils sont totalement interchangeables.

donc, si je veux juste empaqueter des informations pour les déplacer, j’utilise une structure, même si j’y mets quelques méthodes (mais pas beaucoup). Si c’est une chose principalement opaque, où l’utilisation principale serait via des méthodes, et non directement aux membres de données, j’utilise une classe complète.

Les structures par défaut ont un access public et les classes par défaut ont un access privé.

Personnellement, j’utilise des structures pour les objects de transfert de données ou comme objects de valeur. Lorsque utilisé comme tel, je déclare tous les membres comme constants pour empêcher toute modification par un autre code.

Techniquement, les deux sont les mêmes en C ++ – par exemple, une structure peut avoir des opérateurs surchargés, etc.

Toutefois :

J’utilise des structures lorsque je souhaite transmettre des informations de plusieurs types simultanément. J’utilise des classes lorsque je traite d’un object “fonctionnel”.

J’espère que cela aide.

 #include  #include  using namespace std; struct student { int age; ssortingng name; map grades }; class ClassRoom { typedef map student_map; public : student getStudentByName(ssortingng name) const { student_map::const_iterator m_it = students.find(name); return m_it->second; } private : student_map students; }; 

Par exemple, je retourne un étudiant struct dans les méthodes get … () ici – profitez-en.

Quand choisiriez-vous d’utiliser struct et Quand utiliser la classe en C ++?

J’utilise struct quand je définis des functors et des POD . Sinon, j’utilise la class .

 // '()' is public by default! struct mycompare : public std::binary_function { bool operator()(int first, int second) { return first < second; } }; class mycompare : public std::binary_function { public: bool operator()(int first, int second) { return first < second; } }; 

J’utilise des structures lorsque j’ai besoin de créer un type de POD ou un foncteur.

Un avantage de struct over class est qu’il sauve une ligne de code, si elle adhère aux “premiers membres publics, puis privés”. Dans cette optique, je trouve la class mot-clé inutile.

Voici une autre raison d’utiliser uniquement struct et never class . Certaines directives de style de code pour C ++ suggèrent d’utiliser des lettres minuscules pour les macros de fonction, la raison étant que lorsque la macro est convertie en une fonction inline, le nom ne devrait pas avoir besoin d’être modifié. Pareil ici. Vous avez votre belle structure en C et un jour, vous découvrez que vous devez append un constructeur ou une méthode pratique. Est-ce que vous changez de class ? Partout?

Distinguer entre les struct et les class est trop compliqué, entrer dans la façon de faire ce que nous devrions faire – la programmation. Comme beaucoup de problèmes de C ++, cela découle du désir de compatibilité ascendante.

J’utilise struct uniquement lorsque je dois conserver certaines données sans aucune fonction membre associée (pour opérer sur les données des membres) et accéder directement aux variables de données.

Par exemple: lecture / écriture de données à partir de fichiers et de stream de socket, etc. Passage d’arguments de fonction dans une structure où les arguments de la fonction sont trop nombreux et la syntaxe des fonctions trop longue.

Techniquement, il n’y a pas de grande différence entre la classe et la structure, à l’exception de l’accessibilité par défaut. De plus, cela dépend du style de programmation utilisé.

Je pensais que Structs était conçu comme une structure de données (comme un tableau d’informations de type multi-données) et que les classes étaient destinées à l’empaquetage de code (comme les collections de sous-routines et de fonctions).

🙁

Je n’utilise jamais “struct” en C ++.

Je ne peux jamais imaginer un scénario où vous utiliseriez une structure lorsque vous voulez des membres privés, sauf si vous essayez délibérément d’être déroutant.

Il semble que l’utilisation de structs soit davantage une indication syntaxique de la manière dont les données seront utilisées, mais je préfère simplement créer une classe et essayer de rendre cela explicite au nom de la classe ou par des commentaires.

Par exemple

 class PublicInputData { //data members }; 

Les fonctions d’access ne sont pas la seule différence entre les structures et les classes. Une structure est préférable pour les types POD (Plain Old Data), car il est plus facile à gérer pour le compilateur et le programmeur. Pour les débutants qui n’utilisent pas de programmation orientée object, l’utilisation d’une structure convient.