Maleta *Mi_Maleta=new Maleta[10];

Creas un array de 10 punteros de tipo Maleta.

Mi_Maleta->Items=new Item[10];

Creas un array de 10 punteros de tipo Item en... donde?? si Mi_Maleta es un array de 10 punteros lo lógico hubiese sido un acceso del tipo:

Mi_Maleta[0]->Items = new Item[10];

Lo que sucede es que esta línea puesta tal cual te va a dar error porque tu únicamente has definido el array de punteros... no has creado ni un solo objeto de tipo Maleta.

Tendrías que haber hecho algo así:

Maleta *Mi_Maleta=new Maleta[10];
for ( int i=0; i<10; i++ )
  Mi_Maleta[ i ] = new MiMaleta( );

Ya que una cosa es crear un array de punteros y otra muy diferente crear los objetos en sí.

En el caso del array de items te pasa exactamente lo mismo, pero con lo que te he dicho ya deberías ser capaz de resolverlo tu mismo.

Un saludo.

 

Vale, ahora estoy más tranquilo y creo que puedo darte una respuesta un poco más elaborada.

Vayamos por partes:

1. Clases de c++

Maleta *Mi_Maleta=new Maleta[10];

Estás usando c++. Salvo que sea una práctica de clase o que quieras practicar de forma intensiva con la memoria dinámica, te recomiendo usar la clase "vector", que es bastante más potente que los arreglos "a pelo" que estás intentando programar.

2. Clases de c++ ( 2ª parte )

struct Item{
       int Peso;
       int Volumen;
       string Nombre;
};

Estás usando c++, luego lo lógico y normal es que emplees "class" en vez de "struct". A grandes rasgos, la única diferencia entre ambos es que, por defecto, "class" tiene sus miembros privados mientras que "struct" los mantiene públicos. "class" es más natural en c++ y es altamente recomendado familiarizarse con su uso, ya que está tremendamente extendido.

Aprovechando tu paso a un c++ más normal, aprovecha para dejar las variables de las clases en la parte "private" de la clase y crea métodos que permitan acceder y modificar el valor de dichas variables. Este proceso se conoce como "encapsulación" y es uno de los pilares de la programación orientada a objetos. Familiarízate con ello.

La clase Item debería tener una declaración tal que:

class Item
{
  public:
 
       // Constructor por defecto. Para inicializar las variables de la clase.
       Item( );
 
       // Destructor. En tu caso no hace falta hacer deletes... pero conviene acostumbrarse a ponerlo.
       virtual ~Item( );
 
       int GetPeso( ) const;
 
       void SetPeso( int peso );
 
       int GetVolumen( ) const;
 
       void SetVolumen( int volumen );
 
       const string& GetNombre( ) const;
 
       void SetNombre( const string& nombre );
 
  private:
 
       int Peso;
       int Volumen;
       string Nombre;
};

La implementación te la dejo a tí. Es muy sencilla.

3. Constructores

Hay muchísima documentación en internet al respecto, te aconsejo buscar un poco e informarte.

Lo que deberías saber es que los constructores te permiten inicializar las variables de la clase con el objetivo de que dichas variables no tengan valores inválidos.

En el caso de la clase Maleta, el constructor podría, por su propia cuenta, crear el arreglo de Items de dicha maleta.

4. Arreglos

Maleta *Mi_Maleta=new Maleta[10];

La línea superior crea un arreglo de 10 punteros de tipo Maleta... pero no crea un solo objeto Maleta. Es necesario crear de forma individual los objetos Maleta y almacenar sus punteros en la posición que corresponda del arreglo de maletas. Con los items pasa exactamente lo mismo.

Aprovechando el punto 3, es decir, creando el arreglo de items en el constructor de la clase maleta, te olvidas de tener que crearlo explícitamente cada vez que crees un objeto maleta... aunque como te he comentado en el punto 1, la clase vector da mucha más flexibilidad que los arreglos puros.