c++ - struct vs class swift




Quand devriez-vous utiliser une classe vs une structure en C++? (16)

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


Quand choisiriez-vous d'utiliser struct et quand utiliser classe en C ++?

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

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

class mycompare : public std::binary_function<int, int, bool>
{
public:
    bool operator()(int first, int second)
    { return first < second; }
};

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 qu'il s'agit d'un public

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

Struct.

Une structure est une classe dans laquelle les membres sont publics par défaut.

struct test_one {
    int main_one;
};

Moyens main_one est privé ie

class test_one {
  public:
    int main_one;
};

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


Comme tout le monde le fait remarquer, il n'y a vraiment que deux différences linguistiques:

  • struct défaut à l'accès public et class défaut à l'accès privé.
  • Lors de l'héritage, la struct défaut est public héritage public et la class défaut est private héritage private . (Ironiquement, comme avec beaucoup de choses en C ++, la valeur par défaut est à rebours: public héritage public est de loin le choix le plus commun, mais les gens déclarent rarement struct simplement pour sauver en tapant le mot-clé " public ".

Mais la vraie différence dans la pratique est entre une class / struct qui déclare un constructeur / destructeur et une qui ne le fait pas. Il y a certaines garanties à un type de POD "plaine ancienne", qui ne s'applique plus une fois que vous avez repris la construction de la classe. Pour garder cette distinction claire, de nombreuses personnes utilisent délibérément des struct pour les types POD et, si elles veulent ajouter des méthodes, utilisent des class es. La différence entre les deux fragments ci-dessous est autrement insignifiante:

class X
{
  public:

  // ...
};

struct X
{
  // ...
};

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


De la FAQ C ++ Lite :

Les membres et les classes de base d'une structure sont publics par défaut, tandis qu'en classe, ils sont privés par défaut. 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 grincheuse. Emotionnellement, la plupart des développeurs font une forte distinction entre une classe et une structure. Une structure ressemble simplement à un tas ouvert 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 des données publiques (ces choses existent dans des systèmes bien conçus!), Sinon vous devriez utiliser la classe mot-clé.


Ils sont à peu près la même chose. Grâce à la magie de C ++, une structure peut contenir des fonctions, utiliser l'héritage, créer en utilisant "new" et ainsi de suite tout comme une classe

La seule différence fonctionnelle est qu'une classe commence avec des droits d'accès privés, alors qu'une structure commence par public. C'est la compatibilité descendante avec C.

En pratique, j'ai toujours utilisé des structures comme supports de données et classes comme objets.


J'utilise des structs quand j'ai besoin de créer un type POD ou un foncteur.


Je n'utilise struct que lorsque j'ai besoin de stocker des données sans aucune fonction membre (pour opérer sur les données des membres) et d'accéder directement aux variables de données.

Ex: Lecture / écriture de données à partir de fichiers et de flux de socket, etc. Passage d'arguments de fonction dans une structure où les arguments de la fonction sont trop nombreux et la syntaxe de la fonction semble trop longue.

Techniquement, il n'y a pas de grande différence entre la classe et la structure sauf l'accessibilité par défaut. Plus cela dépend du style de programmation que vous utilisez.


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-programmes et de fonctions).

:(


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

Je recommanderais d'utiliser des structures comme des structures de type plain-old-data sans aucune fonctionnalité de type classe, et d'utiliser des classes comme des structures de données agrégées avec private données private et des fonctions membres.


Les fonctions d'accès ne sont pas la seule différence entre les structures et les classes. Une structure est meilleure pour les types POD (Plain Old Data), car elle est plus facile à gérer pour le compilateur et le programmeur. Pour les débutants qui n'utilisent pas la programmation orientée objet, l'utilisation d'une struct est très bien.


Les structures par défaut ont un accès public et les classes ont par défaut un accès privé.

Personnellement, j'utilise des structures pour les objets de transfert de données ou comme objets de valeur. Lorsqu'ils sont utilisés comme tels, je déclare tous les membres comme const pour empêcher toute modification par d'autres codes.


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 je le fais en C #, comme Brian l'a dit. Les structures sont des conteneurs de données simples, tandis que les classes sont utilisées pour les objets qui doivent agir sur les données en plus de simplement s'y accrocher.


Techniquement, les deux sont les mêmes en C ++ - par exemple, il est possible qu'une structure ait des opérateurs surchargés, etc.

Toutefois :

J'utilise des structures quand je souhaite transmettre des informations de plusieurs types simultanément J'utilise des classes quand j'ai affaire à un objet "fonctionnel".

J'espère que cela aide.

#include <string>
#include <map>
using namespace std;

struct student
{
    int age;
    string name;
    map<string, int> grades
};

class ClassRoom
{
    typedef map<string, student> student_map;
  public :
    student getStudentByName(string 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 - enjoy.


Un avantage de la struct rapport à la class est qu'elle économise une ligne de code, si elle adhère aux "premiers membres publics, puis privés". Dans cette optique, je trouve le mot-clé class inutile.

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

Distinguer les struct et les class est trop compliqué, ce qui nous empêche de faire ce que nous devrions faire: la programmation. Comme beaucoup de problèmes de C ++, il découle du fort désir de rétrocompatibilité.


Vous pouvez utiliser "struct" en C ++ si vous écrivez une bibliothèque dont les internes sont en C ++ mais l'API peut être appelée par du 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 au code 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 fonction bar () dans un fichier C ++ en utilisant du code C ++ et le rendre appelable de C et les deux mondes peuvent partager des données à travers les structures déclarées. Il y a bien sûr d'autres mises en garde quand on mélange C et C ++, mais c'est un exemple simplifié.


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

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







ooad