Re: Generic message holder class design

I'm receving incoming messages R1,R2,R3..Rn from an aircraft. I
respond with T1,T2,T3..Tn. So now consider the source snippet.

# include <iostream>
# include <string>
# include <vector>
# include <memory>

class non_copyable {
protected:
   non_copyable() {}
   ~non_copyable() {}
private:
   non_copyable(const non_copyable &);
   non_copyable & operator=(const non_copyable &);

};

/*

==============================================================================
  | singleton class: Used to enforce an single instance

==============================================================================
*/
template <class T>
class singleton : non_copyable
{
public:
   static T& instance() {
     if (!_object.get()) //Not yet created
          _object = std::auto_ptr<T>(new T);
     return * ( _object.get() );
   }
   static T* get_singleton_ptr() { return &( instance() ); }
   static void destroy() { _object.reset() ; }

protected:
   singleton() {}
   virtual ~singleton() {}
   static std::auto_ptr<T> _object; //auto_ptr ensures T is deleted at
end

};

template <class T>
std::auto_ptr<T> singleton<T>::_object; //Initilize static variable

/*

==============================================================================
  | Incoming messages: R1,R2,R3 ....Rn
  | Outgoing messages: T1,T2,T3 ....Tn

==============================================================================
*/
//Base class for messages
class Base {
public:
   // handful of methods.
   virtual ~Base() {}};

//R1
class R1_Msg : public Base {
public :
   explicit R1_Msg( /*arg*/ ) {}
   double Get_Latitude() const { std::cout << "R1" << '\n'; return
(1.); }
// more Sets/Gets};

//R2
class R2_Msg : public Base {
public :
   explicit R2_Msg( /*arg*/ ) {}
   unsigned short Get_Ad_Confirmation() const { std::cout << "R2" <<
'\n'; return ( 5 ) ; }
// more Sets/Gets

};

template < typename Type >
class Msg_Holder : public non_copyable {
//class Msg_Holder {
   //useful statistic
   int msg_count ;
   //msg count
   int msg_id ;
   Type msg_instance ;
   //singleton < Type > msg_instance ;
public:

   //std::string would be 'better' for an id, nonethless for now
   Msg_Holder ( int const id, Type& in )
   : msg_id ( id )
   , msg_instance ( in )
   {}

   int Get_Msg_ID() const { return ( msg_id ) ; }
   int Get_Msg_Count() const { return ( msg_count ) ; }
   void Increment_Msg_Count() { msg_count ++ ; }

   /*
    | This gets tricky.....we want the derived type, hence:
    | a) downcasting
    | b) dynamic_cast possibly
    | Do I care though since the 'message classes' are wrapped
    | in a singleton?
   */
   Type Get_Type () const { return ( msg_instance ) ; }

   //destruct
   ~Msg_Holder () {}

};

int main()
{
   typedef std::vector < Msg_Holder* > MSG_HOLDER_VEC ;
   MSG_HOLDER_VEC msg_vec;
   msg_vec.push_back ( new Msg_Holder < R1_Msg > (
                       ( 1, singleton < R1_Msg >::instance() ) ) ) ;

   std::cin.get();

}

I'd like store an instance of each message within a container of
Msg_Hholder type. My issues here is predicated upon template usage/
understanding (something i struggle with often), noetheless at issue:

a) The Msg_Holder class is a generic class and I'm unsure how to
typedef the vector so I could push-back message classes

b) How do I enforce the use of the singleton in the Msg_Holder
constructor? IOW: push_back of Msg_Holder instances must be routed
through the singleton class.

c) I suspect there's no way to 'chain' push back? Ideally I'd like to
do .
    msg_vec.push_back ( id1, single_instance::r1_msg ).
                 push_back ( id2, single_instance::r2_msg ) // etc.;
lots more

     // later iterate and find the id i'm interested in)
     R1_Msg obj ;
     for ( MSG_HOLDER_VEC::const_iterator it = msg_vec.begin(), it !=
msg_ve.end(); ++it ) {
       if ( .. ... ) {
         obj = it -> ....
         //increment the count
         int ->
      }
    }
   Of course this might seem painful but I dont think a map helps me
here.

I'm open to ideas (source snippet works even better). Thanks in
advance.
Mark