Struct Constructor en C ++?

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

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

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

Entonces las estructuras pueden tener constructores, y la syntax es la misma que para las clases.

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

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. Sin embargo, puedes hacer un constructor en la unión. Esta pregunta se refiere a constructores no triviales en los sindicatos.

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

Si declaras tu estructura así:

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

Tendrá problemas para tratar 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 scoping 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 solucionar esto, debe 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 da el alias "foo" para que no tenga que usar la palabra clave struct al hacer referencia a ella.

Como mencionan las otras respuestas, una estructura básicamente se trata 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); 

Sí. Una estructura es como una clase, pero se establece de forma predeterminada en public: en la definición de clase y al heredar:

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

Considerando su otra pregunta, le sugiero que lea algunos tutoriales . Contestarán sus preguntas más rápido y más completo que nosotros.

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

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

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 deberías poder hacer en una estructura.

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

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


Si tienes una estructura simple de vainilla como esta

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

entonces en otro lugar podrías 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 mencionados anteriormente, obtendrá un error como este:

  'MyStruct' : Types with user defined constructors are not aggregate  : 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 WinSDK c ++ que soporto. Solo para que sepas…

En c ++ struct y c ++ class tienen una sola diferencia por defecto. Los miembros de struct son públicos y los de clase son privados.

 /*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...!"< 

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

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

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 tener compatibilidad inversa con legacy C types .

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

La syntax es igual a la clase en C ++. Si conoce crear 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 antes mencionamos, la diferencia es que, por defecto, los miembros de C ++ tienen acceso privado, pero en struct son públicos. Pero según la consideración de la progtwigción, use la palabra clave struct para las estructuras de solo datos. Use la palabra clave class para los objetos que tienen datos y funciones.

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

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

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

Comstackdo con GCC 8.1.0.

Clase, estructura y unión se describe en la tabla a continuación en breve.

enter image description here