c++ - and - Constructor en implementación versus encabezado

class h and class cpp

Question

El constructor debería, en mi conocimiento, estar definido en el archivo de implementación, pero solo he podido encontrar ejemplos con la clase dentro de un archivo principal en lugar de dividirlo en un archivo .h y .cpp

Todo lo que necesito saber es si mi siguiente código está separado de una manera aceptable.

Entidad.h:

 using namespace std;
class cEntity {
private:
/*-----------------------------
----------Init Methods---------
-----------------------------*/
int *X, *Y;
int *Height, *Width;
public:
/*-----------------------------
----------Constructor----------
-----------------------------*/
cEntity (int,int, int, int);
/*-----------------------------
----------Destructor-----------
-----------------------------*/
~cEntity ();
/*-----------------------------
----------Set Methods----------
-----------------------------*/
/*Set X,Y Methods*/
void setX(int x){*X=x;};
void setY(int y){*Y=y;};
void setXY(int x, int y){*X=x; *Y=y;};
/*Set Height, Width Methods*/
void setHeight(int x){*Height=x;};
void setWidth(int x){*Width=x;};
void setDimensions(int x, int y){*Height=x; *Width=y;};
/*-----------------------------
----------Get Methods----------
-----------------------------*/
/*Get X,Y Methods*/
int getX(){return *X;};
int getY(){return *Y;};
/*Get Height, Width Methods*/
int getHeight(){return *Height;};
int getWidth(){return *Width;};
};

y Entity.cpp:

#include "Entity.h"
cEntity::cEntity (int x, int y, int height, int width) {
X,Y,Height,Width = new int;
*X = x;
*Y = y;
*Height = height;
*Width = width;
}
cEntity::~cEntity () {
delete X, Y, Height, Width;
}

También me gustaría dar las gracias a todos por ser tan útiles, especialmente en mi primera pregunta.

Answer 1

Cualquier método definido en la clase directamente está implícitamente en línea, incluido el constructor.

Es decir

class MyClass
{
public:
MyClass() {};
};

define un constructor en línea, que puede (o no) mejorar el rendimiento del código,

Mientras

class MyClass
{
public:
MyClass();
};
MyClass::MyClass()
{
};

no está en línea, y por lo tanto no tendrá esos beneficios. Ambas opciones son correctas C ++ sin embargo.

Solo mis 2 centavos.

PS Y sí, cuando decides guardar punteros dentro de una clase de esta manera, abres una caja de Pandora.

Answer 2

Sí. Para la separación al menos, esa es generalmente la mejor manera de hacerlo.

En cuanto a la implementación real, tienes algunos problemas. No estoy seguro de qué intenta hacer con el constructor o si tiene los tipos de datos correctos para las variables miembro de la clase, pero algo parece estar apagado.

Answer 3

Si esta bien. Sin embargo, hay un problema con su constructor y destructor. Lo que tu código realmente hace es asignar un int y tu destructor desasigna uno int también. De todos modos, no hay necesidad de usar punteros aquí. Una implementación algo mejor (si no usamos punteros inteligentes), podría ser:

[Entidad.h]

private:
/*Private fields*/
int X, Y;
int Height, Width;

[Entity.cpp]

cEntity::cEntity (int x, int y, int height, int width) {
X = x;
Y = y;
Height = height;
Width = width;
}
cEntity::~cEntity () {
}

Y una cosa más. Intenta evitar el using namespace std; en tus archivos de encabezado Si lo haces, obligas a los que incluyen tu encabezado a usar esta declaración de uso y puede provocar enfrentamientos en el espacio de nombres.

Answer 4

Tu separación está bien. La implementación de esas funciones es incorrecta, pero las ha separado adecuadamente de la declaración. (No asignan ni liberan tantos objetos como crees que hacen).

Answer 5

cEntity::cEntity (int x, int y, int height, int width) {

es correcto

 X,Y,Height,Width = new int;

no tanto. Eso establece Width a un nuevo int , pero no el resto. Probablemente tenías la intención de:

 X = new int(x);
Y = new int(y);
Height = new int(height);
Width = new int(width);

Tenga en cuenta que este método de construcción no funcionará para objetos sin asignación / copia, como referencias. Para algunos objetos, también es más lento que construirlos en su lugar. Como tal, la forma preferida de construir es así:

cEntity::cEntity (int x, int y, int height, int width) {
:X(new int(x))
,Y(new int(y))
,Height(new int(height))
,Width(new int(width))
{}

Esto es mejor, pero si se lanzan algunas excepciones, tendrá que desasignar las asignadas. Mejor es hacer que cada uno de esos miembros sea std::unique_ptr<int> , por lo que se desasignarán y le ahorrarán muchos dolores de cabeza.