¡Urgente! Defina una clase. El objeto de la clase es un vector y los elementos del vector son estructuras. Hay múltiples estructuras anidadas en la estructura.

#include

#include

usando el espacio de nombres std;

clase CTargetState/ /declaración de clase

{

public：

struct m_strTargetPosition//Posición del sistema de coordenadas cartesianas

{

m_strTargetPosition( doble x, doble y, doble z):

m_dTargetPostionX(x), m_dTargetPostionY(y), m_dTargetPostionZ(z){}

doble m_dTargetPostionX;

doble m_dTargetPostionY

doble m_dTargetPostionZ

};

estructura m_strTargetVelocity//velocity

{

m_ strTargetVelocity(doble x, doble y, doble z):

m_dTargetVelocityX(x), m_dTargetVelocityY(y), m_dTargetVelocityZ(z){}

doble m_dTargetVelocityX;

double m_dTargetVelocityY;

double m_dTargetVelocityZ;

};

struct m_strTargetAccelerate// Aceleración

{

m_strTargetAccelerate(doble x, doble y, doble z):

m_dTargetAccelerateX(x), m_dTargetAccelerateY(y), m_ dTargetAccelerateZ(z){}

doble m_dTargetAccelerateX;

double m_dTargetAccelerateY;

double m_dTargetAccelerateZ;

};

typedef struct m_strTargetState//definir tipo de autoestructura

{

m_strTargetState(doble x1, doble y1, doble z1, doble x2, doble y2, doble z2, doble x3, doble y3, doble z3)

: m_stp(x1, y1, z1) , m_stv(x2, y2, z2), m_sta(x3, y3, z3) {}

m_strTargetPosition m_stp;

m_strTargetVelocity m_stv;

m_str

TargetAccelerate m_sta;

}StruTargetState;

vector m_ vTargetState;

privado:

};//endof clase CTargetState

int main()

{

CTargetState::StruTargetState sts1(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0) ;

CTargetState::StruTargetState sts2(1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.m_vTargetState[1].m_sta .m_dTargetAccelerateX<

cout<

return 0;

}

Es mejor declarar la estructura interna como pública estructura, de lo contrario no se podrá acceder a estas estructuras desde el exterior.

Para simplificar, hice pública su variable miembro, puede escribir funciones miembro para acceder a ella, es lo mismo, vector> es equivalente a datos bidimensionales push_back(4);

vector v3;

v3.push_back(5); v3.push_back( 6);

vector> vv;

vv.push_back(v1);

vv.push_back(v2);

p >

vv.push_back(v3);

La fase de acceso a elementos en v3 puede ser:

int res = vv[2][0]; 5

La fase de acceso a los elementos en v1 puede ser:

res = vv[0][2] // res = 3