Struct Constructor en C++?

en C++ la seule différence entre un class et un struct est que les membres et les classes de base sont privés par défaut dans les classes, alors qu'ils sont publics par défaut dans les structures.

Donc, les structures peuvent 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 une union alors vous ne pouvez pas. C'est le même en tant que classe.

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

les syndicats n'autoriseront pas les constructeurs dans les structures. Vous pouvez faire un constructeur sur le syndicat cependant. cette question concerne les constructeurs non triviaux dans les syndicats.

toutes les réponses ci-dessus répondent techniquement à la question de l'asker, mais j'ai pensé que je voudrais signaler un cas où vous pourriez rencontrer des problèmes.

Si vous déclarez votre structure comme ceci:

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

vous aurez des problèmes à déclarer un constructeur. C'est bien sûr parce que vous n'avez pas réellement déclaré une structure nommée "foo", vous avez créé une structure anonyme et lui avez assigné l'alias "foo". Cela signifie également que vous ne serez pas en mesure pour utiliser "foo", avec une étude sur la portée de l'opérateur 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 corriger ceci, vous devez soit faire ceci:

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

ou ceci:

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

où ce dernier crée une structure appelée "foo" et lui donne l'alias "foo" pour que vous n'ayez pas à utiliser le mot-clé struct quand vous le référencez.

comme le mentionnent les autres réponses, une structure est essentiellement traitée comme une classe en C++. Cela vous permet d'avoir un constructeur qui peut être utilisée 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) {}
};

Utilisation:

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 en héritant:

struct Foo
{
    int bar;

    Foo(void) :
    bar(0)
    {
    }
}

considérant votre autre question, je vous suggérerais de lire quelques tutoriels . Ils répondront à vos questions plus rapidement et plus complètement que nous.

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

je préférerais initialiser à l'intérieur du constructeur pour ne pas avoir à suivre l'ordre.

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

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

notez qu'il y a une différence intéressante (au moins avec le compilateur MS c++):

Si vous avez une plaine de vanille struct comme ce

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

alors ailleurs vous pourriez initialiser un tableau de tels objets 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 discutés ci-dessus, vous obtenez une erreur comme celle-ci:

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

, de Sorte qu'au moins une autre différence entre une structure et une classe. Ce genre d'initialisation n'est peut-être pas une bonne pratique OO, mais elle apparaît partout dans le code C++ winsdk que je supporte. Si vous voulez savoir...

Dans c++ struct et classe c++ ont une seule différence par défaut, les membres de la structure sont publiques et les membres de la classe sont privés.

/*Here, C++ program constructor in struct*/ 
#include <iostream>
using namespace std;

struct hello
    {
    public:     //by default also it is public
        hello();    
        ~hello();
    };

hello::hello()
    {
    cout<<"calling constructor...!"<<endl;
    }

hello::~hello()
    {
    cout<<"calling destructor...!"<<endl;
    }

int main()
{
hello obj;      //creating a hello obj, calling hello constructor and destructor 

return 0;
}

Oui-il possible d'avoir un constructeur dans la structure voici un exemple:

#include<iostream.h> 
struct a {
  int x;
  a(){x=100;}
};

int main() {
  struct a a1;
  getch();
}

En C++ à la fois struct & class sont égaux à l'exception de struct's par défaut de l'accès des membres spécificateur public et classe a private .

la raison d'avoir struct en C++ est que C++ est un super-ensemble de C et doit avoir une compatibilité ascendante avec legacy C types .

par exemple si l'utilisateur du langage essaie d'inclure un fichier d'en-tête C legacy-c.h dans son code C++ et qu'il contient struct Test {int x,y}; . Membres de struct Test devrait être accessible comme C.

est la même que celle de la classe en C++. Si vous êtes conscient de créer un constructeur en c++, alors c'est pareil en struct.

struct Date
{
int day;

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

};

Struct peut avoir toutes choses comme classe en c++. Comme dit précédemment la différence est seulement que par défaut c++ membre ont un accès privé mais en structure il est public.Mais selon la considération de programmation utiliser le mot-clé struct pour les structures de données seulement. Utilisez le mot-clé class pour les objets qui ont à la fois des données et des fonctions.

en C++, nous pouvons déclarer/définir la structure comme class et avoir les constructeurs/destructeurs pour les Structures et avoir des variables/fonctions définies dans celui-ci. La seule différence est la portée par défaut des variables/fonctions définies. En dehors de la différence ci-dessus, la plupart du temps vous devriez être capable d'imiter la fonctionnalité de classe en utilisant des structures.

un autre exemple mais en utilisant ce mot-clé lors de la définition de la valeur dans le constructeur:

#include <iostream>

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.

sont décrites dans le tableau ci-dessous.