Mejor manejalo con string y lee la cadena con getline(cin,variable) para que los espacios los cuentes y ya

Necesito ayuda con lo siguiente:

Se ha definido la siguiente estructura de datos:




Escribir un programa que realice lo siguiente:
a) Dado el nombre de un postre, imprimir la lista de todos sus ingredientes.
b) Dado el nombre de un postre, insertar nuevos ingredientes a su correspondiente lista.
c) Dado el nombre de un postre, eliminar alguno de sus ingredientes.
d) Dar de alta un postre con todos sus ingredientes.
e) Dar de baja un postre con todos sus ingredientes.


Ya tengo mi clase nodo, clase listaPostre y listaIngrediente. La duda que tengo es cómo apuntar el nombre del postre hacia otra lista para que despliegue los ingredientes. Adjunto mi código

#include <iostream>
#include <stdlib.h>
using namespace std;
 
//////////////////////////////////////////////////////// 
 
 
 
class nodo {
   public:
	//contructor clase nodo, que recibe un string y crea un apuntador a NULL
    nodo(string v, nodo *sig = NULL)
    {
       valor = v;//parametro que se pasa es = valor que esta privado
       siguiente = sig; //apuntador siguiente = apuntador sig
    }
 
   private:
    string valor;
    nodo *siguiente;
 
   friend class Ingrediente;
   friend class Postre;
};
 
typedef nodo *pnodo;
 
//cambia el nombre de nodo a apuntador -->*pnodo
 
 
 
 ////////////////////////////////////////////////////////
 
 
 
 
 
class Postre {
   public:
 
	//contructor que inicializa los valores privados de la clase
    Postre() { primero = actual = NULL; }
	//Destructor
	~Postre();
	//Metodos auxiliares de la clase lista
	//insertar que pasa un valor entero 
    void Insertar(string v);
 
	//borrar que pasa un valor entero
    void Borrar(string v);
	//boleano que regresa valor de primero que es igual a NULL
    bool ListaVacia() { return primero == NULL; } 
	//Muestra el arreglo
    void Mostrar();
    void Siguiente() 
	{ 
		if(actual)
		{
			actual = actual->siguiente;
		}
	}
 
    void Primero()
	{ 
		actual = primero;
	}
    void Ultimo() 
	{ 
		Primero(); if(!ListaVacia()) while(actual->siguiente) Siguiente();
	}
    bool Actual()
	{ 
		return actual != NULL;
	}
    string ValorActual()
	{ 
		return actual->valor;
	}
 
   private:
    pnodo primero;
    pnodo actual;
 
};
 
Postre::~Postre() {
   pnodo aux;
 
   while(primero) {
      aux = primero;
      primero = primero->siguiente;
      delete aux;
   }
   actual = NULL;
}
 
void Postre::Insertar(string v) {
   pnodo anterior;
 
   // Si la lista está vacía
   if(ListaVacia() || primero->valor > v) {
      // Asignamos a lista un nuevo nodo de valor v y cuyo siguiente elemento es la lista actual                    
      primero = new nodo(v, primero);
   } else {
      // Buscar el nodo de valor menor a v 
      anterior = primero;
      // Avanzamos hasta el último elemento o hasta que el siguiente tenga un valor mayor que v 
      while(anterior->siguiente && anterior->siguiente->valor <= v) 
         anterior = anterior->siguiente;
      // Creamos un nuevo nodo después del nodo anterior, y cuyo siguiente es el siguiente del anterior
      anterior->siguiente = new nodo(v, anterior->siguiente);
   }
}
 
void Postre::Borrar(string v) {
   pnodo anterior, nodo;
 
   nodo = primero;
   anterior = NULL;
   while(nodo && nodo->valor < v) {
      anterior = nodo; 
      nodo = nodo->siguiente;
   }
   if(!nodo || nodo->valor != v) return;
   else { // Borrar el nodo 
      if(!anterior) // Primer elemento 
         primero = nodo->siguiente;
      else  // un elemento cualquiera
         anterior->siguiente = nodo->siguiente;
      delete nodo;
   }   
}
 
void Postre::Mostrar() {
   nodo *aux;
 
   aux = primero;
   while(aux) {
      cout << aux->valor << "-> ";
      aux = aux->siguiente;
   }
   cout << endl;
}
 
 
 
////////////////////////////////////////////////////////
 
 
 
 
 
 
class Ingrediente {
   public:
	//contructor que inicializa los valores privados de la clase
    Ingrediente() { primero = actual = NULL; }
	//Destructor
	~Ingrediente();
	//Metodos auxiliares de la clase lista
	//insertar que pasa un valor entero 
    void Insertar(string v);
	//borrar que pasa un valor entero
    void Borrar(string v);
	//boleano que regresa valor de primero que es igual a NULL
    bool ListaVacia() { return primero == NULL; } 
	//Muestra el arreglo
    void Mostrar();
    void Siguiente() 
	{ 
		if(actual)
		{
			actual = actual->siguiente;
		}
	}
 
    void Primero()
	{ 
		actual = primero;
	}
    void Ultimo() 
	{ 
		Primero(); if(!ListaVacia()) while(actual->siguiente) Siguiente();
	}
    bool Actual()
	{ 
		return actual != NULL;
	}
    string ValorActual()
	{ 
		return actual->valor;
	}
 
   private:
    pnodo primero;
    pnodo actual;
};
 
Ingrediente::~Ingrediente() {
   pnodo aux;
 
   while(primero) {
      aux = primero;
      primero = primero->siguiente;
      delete aux;
   }
   actual = NULL;
}
 
void Ingrediente::Insertar(string v) {
   pnodo anterior;
 
   // Si la lista está vacía
   if(ListaVacia() || primero->valor > v) {
      // Asignamos a lista un nuevo nodo de valor v y cuyo siguiente elemento es la lista actual                    
      primero = new nodo(v, primero);
   } else {
      // Buscar el nodo de valor menor a v 
      anterior = primero;
      // Avanzamos hasta el último elemento o hasta que el siguiente tenga un valor mayor que v 
      while(anterior->siguiente && anterior->siguiente->valor <= v) 
         anterior = anterior->siguiente;
      // Creamos un nuevo nodo después del nodo anterior, y cuyo siguiente es el siguiente del anterior
      anterior->siguiente = new nodo(v, anterior->siguiente);
   }
}
 
void Ingrediente::Borrar(string v) {
   pnodo anterior, nodo;
 
   nodo = primero;
   anterior = NULL;
   while(nodo && nodo->valor < v) {
      anterior = nodo; 
      nodo = nodo->siguiente;
   }
   if(!nodo || nodo->valor != v) return;
   else { // Borrar el nodo 
      if(!anterior) // Primer elemento 
         primero = nodo->siguiente;
      else  // un elemento cualquiera
         anterior->siguiente = nodo->siguiente;
      delete nodo;
   }   
}
 
void Ingrediente::Mostrar() {
   nodo *aux;
 
   aux = primero;
   while(aux) {
      cout << aux->valor << "-> ";
      aux = aux->siguiente;
   }
   cout << endl;
}
 
 
////////////////////////////////////////////////////////
 
 
 
 
int main() {
   Postre Lista;
   Ingrediente Lista1;
 
 
   Lista.Insertar("Pastel Chocolate");
   Lista.Insertar("Pastel Fresa");
 
   Lista1.Insertar("Harina");
   Lista1.Insertar("Crema");
   Lista1.Insertar("Huevos");
 
   cout << "Lista de elementos:" << endl;
   Lista.Primero();
   while(Lista.Actual()) {
      cout << Lista.ValorActual() << endl;
      Lista.Siguiente();
   }
   Lista.Primero();
   cout << "Primero: " << Lista.ValorActual() << endl;
 
   Lista.Ultimo();
   cout << "Ultimo: " << Lista.ValorActual() << endl;
 
 
   cout << "Lista de elementos:" << endl;
   Lista1.Primero();
   while(Lista1.Actual()) {
      cout << Lista1.ValorActual() << endl;
      Lista1.Siguiente();
   }
   Lista1.Primero();
   cout << "Primero: " << Lista1.ValorActual() << endl;
 
   Lista1.Ultimo();
   cout << "Ultimo: " << Lista1.ValorActual() << endl;
 
 
system("PAUSE");
   return 0;
}