将派生的类启用到基类指针

请帮助我将派生的类挑选到基础级指针。我附上完整的源代码示例。

request.hpp （没有配对CPP文件）

#ifndef REQUEST_HPP
#define REQUEST_HPP
#include <memory>
#include <string>
#include <boost/archive/xml_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>
namespace demo {
namespace common {
        class request {
        public:
            static const int INVALID_ID = -42;
            request() 
                : id_(INVALID_ID), timestamp_(0), source_ip_("unknown") {};
            request(int id, long timestamp, const std::string& source_ip) 
                : id_(id), timestamp_(timestamp), source_ip_(source_ip) {};
            virtual ~request() {};
            int id() const { return id_; }
            long timestamp() const { return timestamp_; }
            std::string source_ip() const { return source_ip_; }

        protected:
            int id_;
            long timestamp_;
            std::string source_ip_;

        private:
            friend class boost::serialization::access;
            template<class Archive>
            void serialize(Archive& ar, const unsigned version) {
                ar & BOOST_SERIALIZATION_NVP(id_);
                ar & BOOST_SERIALIZATION_NVP(timestamp_);
                ar & BOOST_SERIALIZATION_NVP(source_ip_);
            }
        };
        typedef std::shared_ptr<request> request_ptr;
    }
};
#endif

command.hpp （派生类）

#ifndef COMMAND_HPP
#define COMMAND_HPP
#include <memory>
#include <string>
#include <boost/serialization/export.hpp>
#include <demo/common/request.hpp>
namespace demo {
    namespace common {
            class command : public request {
            public:
                command(): name_("untitled") {};
                explicit command(const std::string& name) : name_(name) {};
                virtual ~command() {};
                virtual void execute();
                std::string name() const { return name_; }
            protected:
                std::string name_;
            private:
                friend class boost::serialization::access;
                template<class Archive>
                void serialize(Archive& ar, const unsigned version) {
                    ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(request);
                    ar & BOOST_SERIALIZATION_NVP(name_);
                }
            };
            typedef std::shared_ptr<command> command_ptr;
        }
};
BOOST_CLASS_EXPORT_KEY(demo::common::command)

#endif

command.cpp

#include "command.hpp"
#include <iostream>
BOOST_CLASS_EXPORT_IMPLEMENT(demo::common::command)
namespace demo {
    namespace common {
            void command::execute() {
                std::cout << "  I am '" + name_ +"' and I am executing..." << std::endl;
            }
    }
};

serializer.hpp

#ifndef SERIALIZER_HPP
#define SERIALIZER_HPP
#include <sstream>
#include <string>
/* classes to serialize */
#include <demo/common/request.hpp>
#include <demo/common/command.hpp>
namespace demo {
    namespace common {
        class serializer {
        public:
            serializer() : {};
            template<typename T>
            std::string serialize(const T& t){  
                std::stringstream stream;
                boost::archive::xml_oarchive archive(stream);
                archive << BOOST_SERIALIZATION_NVP(t);
                std::string serialized = stream.str();
                return serialized;
            }

            template<typename T>
            void deserialize(const std::string& serialized, T& t) {
                std::stringstream stream(serialized);
                boost::archive::xml_iarchive archive(stream);
                archive >> BOOST_SERIALIZATION_NVP(t);
            }
        };
    }
}
#endif

示例用法

#include <iostream>
#include <demo/common/serializer.hpp>
#include <demo/common/command.hpp>

using namespace std;
using namespace demo::common;
int main(){
    serializer serializer_;
    command r("123"); // <-- (1) my desired way of declaring
    //request* r = new command("123"); <-- (2) replacing with this makes all work!
    //command* r = new command("123"); <-- (3) replacing with this crashes the app, like (1)
    std::string s = serializer_.serialize(r);
    std::cout << s << std::endl;
    request* rr = nullptr;
    serializer_.deserialize(s, rr); //this throws an exception
    command* rrr = dynamic_cast<command*>(rr);
    rrr->execute();
}

我以为我做了需要完成的所有工作，包括任何类导出之前的档案，所有默认构造函数初始化成员。

请注意，可序列化类和序列化器已编译为LIB文件。然后，该LIB用于两个子项目中，可以访问标题并具有链接的Lib。他们使用这些类与彼此进行通信，他们通过网络发送序列化对象。

为什么我不能将派生的类列为基类指针？我正在使用Boost 1.51和VC11。