Constructeur Struct en C ++?

Une struct avoir un constructeur en C ++?

J’ai essayé de résoudre ce problème mais je n’obtiens pas la syntaxe.

En C ++, la seule différence entre une class et une struct est que les membres et les classes de base sont privées par défaut dans les classes, alors qu’elles sont publiques par défaut dans les structures.

Les structures peuvent donc avoir des constructeurs et la syntaxe est la même que pour les classes.

 struct TestStruct { int id; TestStruct() : id(42) { } }; 

Oui, mais si vous avez votre structure dans un syndicat, alors vous ne pouvez pas. C’est la même chose qu’une classe.

 struct Example { unsigned int mTest; Example() { } }; 

Les syndicats n’autoriseront pas les constructeurs dans les structures. Vous pouvez cependant créer un constructeur sur l’union. Cette question concerne les constructeurs non sortingviaux dans les unions.

Toutes les réponses ci-dessus répondent techniquement à la question du demandeur, mais pensaient juste que je signalerais un cas où vous pourriez rencontrer des problèmes.

Si vous déclarez votre struct comme ceci:

 typedef struct{ int x; foo(){}; } foo; 

Vous aurez des problèmes pour essayer de déclarer un constructeur. C’est bien sûr parce que vous n’avez pas déclaré une structure nommée “foo”, vous avez créé une structure anonyme et vous lui avez atsortingbué le pseudonyme “foo”. Cela signifie également que vous ne pourrez pas utiliser “foo” avec un opérateur de scope dans un fichier cpp:

foo.h:

 typedef struct{ int x; void myFunc(int y); } foo; 

foo.cpp:

 //<-- This will not work because the struct "foo" was never declared. void foo::myFunc(int y) { //do something... } 

Pour résoudre ce problème, vous devez soit faire ceci:

 struct foo{ int x; foo(){}; }; 

ou ca:

 typedef struct foo{ int x; foo(){}; } foo; 

Où ce dernier crée une structure appelée "foo" et lui donne l'alias "foo", vous n'avez donc pas à utiliser le mot struct clé struct pour le référencer.

Comme le mentionnent les autres réponses, une structure est fondamentalement traitée comme une classe en C ++. Cela vous permet d’avoir un constructeur qui peut être utilisé pour initialiser la structure avec des valeurs par défaut. Ci-dessous, le constructeur prend sz et b comme arguments et initialise les autres variables à certaines valeurs par défaut.

 struct blocknode { unsigned int bsize; bool free; unsigned char *bptr; blocknode *next; blocknode *prev; blocknode(unsigned int sz, unsigned char *b, bool f = true, blocknode *p = 0, blocknode *n = 0) : bsize(sz), free(f), bptr(b), prev(p), next(n) {} }; 

Usage:

 unsigned char *bptr = new unsigned char[1024]; blocknode *fblock = new blocknode(1024, btpr); 

Oui. Une structure est comme une classe, mais par défaut public: :, dans la définition de la classe et lors de l’inheritance:

 struct Foo { int bar; Foo(void) : bar(0) { } } 

Compte tenu de votre autre question, je vous suggère de lire quelques tutoriels . Ils répondront à vos questions plus rapidement et plus complètement que nous le ferons.

 struct HaveSome { int fun; HaveSome() { fun = 69; } }; 

Je préfère initialiser à l’intérieur du constructeur, donc je n’ai pas besoin de garder l’ordre.

Oui, les structures et les classes en C ++ sont les mêmes sauf que les membres des structures sont publics par défaut alors que les membres des classes sont privés par défaut. Tout ce que vous pouvez faire dans une classe que vous devriez pouvoir faire dans une structure.

 struct Foo { Foo() { // Initialize Foo } }; 

Notez qu’il existe une différence intéressante (au moins avec le compilateur MS C ++):


Si vous avez une structure simple comme celle-ci

 struct MyStruct { int id; double x; double y; } MYSTRUCT; 

alors ailleurs, vous pourriez initialiser un tableau de tels objects comme ceci:

 MYSTRUCT _pointList[] = { { 1, 1.0, 1.0 }, { 2, 1.0, 2.0 }, { 3, 2.0, 1.0 } }; 

Cependant, dès que vous ajoutez un constructeur défini par l’utilisateur à MyStruct, comme ceux décrits ci-dessus, vous obtenez une erreur comme celle-ci:

  'MyStruct' : Types with user defined constructors are not aggregate  : error C2552: '_pointList' : non-aggregates cannot be initialized with initializer list. 

Donc, au moins une autre différence entre une structure et une classe. Ce type d’initialisation n’est peut-être pas une bonne pratique, mais il apparaît partout dans le code WinSDK c ++ hérité que je prends en charge. Juste pour que tu saches …

Dans c ++, struct et c ++ class n’ont qu’une seule différence par défaut: les membres de la structure sont publics et les membres de la classe sont privés.

 /*Here, C++ program constructor in struct*/ #include  using namespace std; struct hello { public: //by default also it is public hello(); ~hello(); }; hello::hello() { cout<<"calling constructor...!"< 

Oui, il est possible d’avoir un constructeur dans la structure, voici un exemple:

 #include struct a { int x; a(){x=100;} }; int main() { struct a a1; getch(); } 

En C ++, struct et class sont égaux, sauf que struct's spécificateur d’access aux membres par défaut struct's est public & class a private .

La raison pour laquelle struct C ++ est C ++ est un sur-ensemble de C et doit avoir une compatibilité descendante avec les legacy C types

Par exemple, si l’utilisateur du langage essaie d’inclure un fichier d’en legacy-ch tête C legacy-ch dans son code C ++ et qu’il contient la struct Test {int x,y}; . Les membres de struct Test doivent être accessibles comme C.

La syntaxe est identique à celle de la classe en C ++. Si vous avez conscience de créer un constructeur dans c ++, il en va de même pour struct.

 struct Date { int day; Date(int d) { day = d; } void printDay() { cout << "day " << day << endl; } }; 

Struct peut avoir tout en classe en c ++. Comme précédemment, la différence est que, par défaut, le membre C ++ a un access privé, mais que dans struct, il est public. Utilisez le mot-clé class pour les objects qui ont à la fois des données et des fonctions.

En C ++, nous pouvons déclarer / définir la structure comme la classe et avoir les constructeurs / destructeurs pour les structures et y avoir des variables / fonctions définies. La seule différence est la scope par défaut des variables / fonctions définies. A part la différence ci-dessus, vous devriez surtout pouvoir imiter les fonctionnalités de la classe en utilisant des structures.

Un autre exemple, mais en utilisant ce mot clé lors de la définition de la valeur dans constructeur:

 #include  using namespace std; struct Node { int value; Node(int value) { this->value = value; } void print() { cout << this->value << endl; } }; int main() { Node n = Node(10); n.print(); return 0; } 

Compilé avec GCC 8.1.0.

La classe, la structure et l’union sont brièvement décrites dans le tableau ci-dessous.

entrer la description de l'image ici