Construtor de estruturas em C++?

Em C++, a única diferença entre um class e um struct é que os membros e classes de base são privados por defeito nas classes, enquanto que são públicos por defeito nas estruturas.

As estruturas podem ter construtores, e a sintaxe é a mesma das classes.

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

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

Se declarar a sua estrutura assim:

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

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

Para resolver isto, tens de fazer isto:

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

Ou isto:

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

Onde este último cria uma estrutura chamada "foo" e lhe dá o pseudónimo "foo" para que não tenha de usar a palavra-chave struct ao referenciá-la.

Como as outras respostas mencionam, uma estrutura é basicamente tratada como uma classe em C++. Isso permite que você tenha um construtor que pode ser usado para inicializar a estrutura com valores padrão. Abaixo, o construtor toma sz e b como argumentos, e inicializa as outras variáveis para alguns valores predefinidos.

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) {}
};

Utilização:

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

struct Foo
{
    int bar;

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

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

As estruturas e classes Sim Em C++ são as mesmas, excepto que os membros das estruturas são públicos por omissão, enquanto os membros das classes são privados por omissão. Qualquer coisa que você pode fazer em uma classe você deve ser capaz de fazer em uma estrutura.

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

Note que existe uma diferença interessante (pelo menos com o compilador em C++):

Se tiver uma estrutura de baunilha simples como esta

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

Então em algum outro lugar você pode inicializar um conjunto de tais objetos como este:

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

No entanto, assim que adicionar um construtor definido pelo utilizador à minha estrutura, como os mencionados acima, obterá um erro como este:

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

Em C++ struct e C++ class têm apenas uma diferença, por omissão, os membros da estrutura são públicos e os membros da classe são privados.

/*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;
}

Sim, é possível ter o construtor na estrutura aqui é um exemplo:

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

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

Em C++ ambos struct & class são iguais, excepto struct's o utilizador de acesso por omissão é public e a classe tem private.

A razão para ter struct em C++ é que o C++ é um superconjunto de C e deve ser compatível com legacy C types.

Por exemplo, se o Utilizador da língua tentar incluir algum ficheiro de cabeçalho C legacy-c.h no seu código C++ e contiver struct Test {int x,y};. Os membros de struct Test devem ser acessíveis como C.

A sintaxe é igual à da classe em C++. Se você está ciente de criar o construtor em c++, então ele é o mesmo em struct.

struct Date
{
int day;

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

};

O Struct pode ter todas as coisas como classe em C++. Como disse anteriormente, a diferença é apenas que por padrão membro C++ tem acesso privado, mas na struct é público.Mas, de acordo com a consideração de programação, Use a palavra-chave struct para estruturas somente de dados. Use a palavra-chave de classe para objetos que têm dados e funções.

Em C++, podemos declarar/definir a estrutura tal como a classe e ter os construtores/destruidores para as estruturas e ter variáveis / funções definidas nela. A única diferença é o escopo padrão das variáveis/funções definidas. Além da diferença acima, na maioria das vezes você deve ser capaz de imitar a funcionalidade da classe usando estruturas.

Mais um exemplo, mas usando esta palavra-chave ao definir o valor no construtor:

#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;
}

Compilado com GCC 8.1.0.

Em Resumo, A classe, A estrutura e a União estão descritas no quadro seguinte.