非模板类的模板化构造

Question

我有一个具有公共成员的类，但需要基于枚举以有限数量的方式构造。每种类型在编译时都是已知的，因此我认为模板在这里有意义。我知道我可以通过构造函数专门化来解决这个问题，例如：

enum SensorTypes{GPS,Radar,ShaftEncoder};

template<SensorTypes>
class Sensor
{
public:
    Sensor(unsigned char* rawdata){//Format of rawdata depends on SensorTypes};
private:
    double speed;
    double time;
}
template<> Sensor<GPS>::Sensor(unsigned char* rawdata){speed = (double)rawdata[0];}

问题是我有遗留代码，它必须接受 Sensor 类而不是 Sensor 等。我怎样才能实现类似的目标编译时构造，同时保持单个类类型。

Answer 1

乍一看这似乎很简单，只需在 Sensor 类中使用模板化构造函数即可。

#include <stdio.h>

namespace sensorKind {
    struct GPS {};
    struct Radar {};
    struct ShaftEncoder {};
}

class Sensor
{
public:
    template< class Kind >
    Sensor( Kind, unsigned char const* rawdata );
private:
    double speed_;
    double time_;
};

template<>
Sensor::Sensor(
    sensorKind::GPS,
    unsigned char const* rawData
    )
{
    printf( "Sensor<GPS> object created.\n" );
}

template<>
Sensor::Sensor(
    sensorKind::Radar,
    unsigned char const* rawData
    )
{
    printf( "Sensor<Radar> object created.\n" );
}

int main()
{
    Sensor  aGPSSensor( sensorKind::GPS(), 0 );
    Sensor  aRadarSensor( sensorKind::Radar(), 0 );
}

但此时很容易看出“类型参数”实际上是在描述原始数据，而不是其他任何东西。

所以实际上，应该输入 rawdata 参数。

使原始数据的类型更加严格还可以帮助您避免错误，例如雷达原始数据被视为 GPS 原始数据。

#include <stdio.h>

namespace sensor {
    struct Kind {
        enum  Enum{ gps, radar, shaftEncoder };
    };

    template< Kind::Enum aKind >
    class DataFrom 
    {
    public:
        static Kind::Enum const kind = aKind;

        unsigned char const* ptr() const { return 0; }
        DataFrom() {}
    };
}  // namespace sensor

class Sensor
{
public:
    typedef sensor::Kind    Kind;

    template< class DataKind >
    explicit Sensor(  DataKind const& rawData );
private:
    double speed_;
    double time_;
};

template<>
Sensor::Sensor( sensor::DataFrom< Kind::gps > const& rawData )
{
    printf( "%s\n", "Sensor<GPS> object created." );
}

template<>
Sensor::Sensor( sensor::DataFrom< Kind::radar > const& rawData )
{
    printf( "%s\n", "Sensor<Radar> object created." );
}

int main()
{
    sensor::DataFrom< sensor::Kind::gps >   gpsData;
    sensor::DataFrom< sensor::Kind::radar > radarData;

    Sensor  aGPSSensor( gpsData );
    Sensor  aRadarSensor( radarData );
}

从设计角度来看，这分为原始数据提供者和原始数据解释器（Sensor 类显然是一个原始数据解释器）。

问题暗示了这种设计，但如果可能是的话，那么将解释知识移近数据源可能是有益的。

即，将雷达数据的解释从Sensor构造函数和类中移出，并转移到携带雷达原始数据的类中。

干杯&呵呵，，

Answer 2

根据您的特定需求，您也许能够创建非模板基类并派生特定于模板的版本，使用虚拟方法来选择正确的行为。

Answer 3

这看起来很简单，只需让您的模板类从现有的 Sensor 类派生即可。

template<SensorTypes>
class DerivedSensor : public Sensor
{
public:
    DerivedSensor(unsigned char* rawdata){//Format of rawdata depends on SensorTypes};
};