struct c++

¿Struct Constructor en C++?

Question

¿Puede una struct tener un constructor en C ++?

He estado tratando de resolver este problema pero no obtengo la sintaxis.

Answer 1

Clase, estructura y unión se describen en la siguiente tabla en breve.

Answer 2

Como mencionan las otras respuestas, una estructura se trata básicamente como una clase en C ++. Esto le permite tener un constructor que puede usarse para inicializar la estructura con los valores predeterminados. A continuación, el constructor toma sz y b como argumentos, e inicializa las otras variables a algunos valores predeterminados.

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

Uso:

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

Answer 3

En c ++, struct y c ++ class tienen solo una diferencia por defecto, los miembros de la estructura son públicos y los miembros de la clase son 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;
}

Answer 4

En C ++, la única diferencia entre una class y una struct es que los miembros y las clases base son privados por defecto en las clases, mientras que son públicos por defecto en las estructuras.

Así que las estructuras pueden tener constructores, y la sintaxis es la misma que para las clases.

Answer 5

En C ++, podemos declarar / definir la estructura como una clase y tener los constructores / destructores para las Estructuras y tener variables / funciones definidas en ella. La única diferencia es el alcance predeterminado de las variables / funciones definidas. Aparte de la diferencia anterior, principalmente debería poder imitar la funcionalidad de la clase utilizando estructuras.

Answer 6

En C ++, tanto struct class son iguales, excepto que struct''s especificador de acceso de miembro predeterminado struct''s es public y class tiene private .

La razón para tener struct en C ++ es que C ++ es un superconjunto de C y debe ser compatible con versiones anteriores de legacy C types .

Por ejemplo, si el usuario del idioma intenta incluir algún archivo legacy-ch encabezado C en su código C ++ y contiene la struct Test {int x,y}; . Los miembros de struct Test deben ser accesibles como C.

Answer 7

La sintaxis es la misma que la de la clase en C ++. Si conoce la creación de un constructor en c ++, entonces es lo mismo en struct.

struct Date
{
int day;

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

};

Struct puede tener todas las cosas como clase en c ++. Como se mencionó anteriormente, la diferencia es solo que, de manera predeterminada, los miembros de C ++ tienen acceso privado, pero en la estructura es público. Utilice la palabra clave de clase para objetos que tienen datos y funciones.

Answer 8

Sí, es posible tener constructor en estructura aquí es un ejemplo:

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

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

Answer 9

Sí, las estructuras y clases en C ++ son las mismas, excepto que los miembros de las estructuras son públicos por defecto, mientras que los miembros de las clases son privados por defecto. Cualquier cosa que puedas hacer en una clase que deberías poder hacer en una estructura.

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

Answer 10

Sí, pero si tienes tu estructura en una unión, entonces no puedes. Es lo mismo que una clase.

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

Los sindicatos no permitirán constructores en las estructuras. Aunque puedes hacer un constructor en el sindicato. Esta pregunta se refiere a los constructores no triviales en los sindicatos.

Answer 11

Sí. Una estructura es como una clase, pero por defecto es public: en la definición de la clase y cuando se hereda:

struct Foo
{
    int bar;

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

Teniendo en cuenta su otra pregunta, le sugiero que lea algunos tutoriales . Responderán a sus preguntas más rápido y más completo que nosotros.

Answer 12

Tenga en cuenta que hay una diferencia interesante (al menos con el compilador de MS C ++):

Si tienes una estructura de vainilla simple como esta

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

luego, en otro lugar, podría inicializar una matriz de objetos como este:

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

sin embargo, tan pronto como agregue un constructor definido por el usuario a MyStruct como los que se mencionaron anteriormente, obtendrá un error 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.

Entonces esa es al menos otra diferencia entre una estructura y una clase. Este tipo de inicialización puede no ser una buena práctica de OO, pero aparece en todas partes en el código heredado de WinSDK c ++ que admito. Solo para que sepas...

Answer 13

Todas las respuestas anteriores responden técnicamente a la pregunta del autor de la pregunta, pero solo pensé en señalar un caso en el que podría encontrar problemas.

Si declara su estructura así:

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

Tendrá problemas tratando de declarar un constructor. Esto es, por supuesto, porque en realidad no ha declarado una estructura llamada "foo", ha creado una estructura anónima y le ha asignado el alias "foo". Esto también significa que no podrá usar "foo" con un operador de alcance en un archivo 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...
}

Para arreglar esto, debes hacer esto:

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

o esto:

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

Donde este último crea una estructura llamada "foo" y le asigna el alias "foo" para que no tenga que usar la palabra clave struct al hacer referencia a ella.

Answer 14

Un ejemplo más, pero utilizando esta palabra clave al establecer el valor en el constructor:

#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 con GCC 8.1.0.

Answer 15

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

Prefiero inicializar dentro del constructor, así que no necesito mantener el orden.

Answer 16

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