0

好吧，我有一个问题，我不知道如何正确表达，但我已经包含了下面的代码。我已经从代码中删减了很多，以便更容易理解问题，但现在它可能无法 100% 工作，这只是为了说明。

问题是模板专业化不起作用。

例如：

#include <iostream>
#include <swift.hpp>
#include <swift/event.hpp>
#include <swift/event/primitives.tpl>

using namespace swift;

template<class T> void print(const T& value)
{
    std::cout << event::representate(value) << std::endl;
}

int main()
{
    Int32 x = 23;
    print(x);
}

这里的问题是，“~”将被打印出来。所以在这个例子中 event::representate() 指向定义在“swift/event.hpp”中的函数，而不是定义在“swift/event/primitives.hpp”中的特殊函数。

好的，这不是真正的问题，因为它可以通过将“swift/event.hpp”中的表示函数更改为专用表示的函数体来轻松解决。

但由于以下原因，我无法做到这一点：

  1. 它不适用于自定义类，如果没有为自定义类定义 std::stream 运算符 << （对于自由函数，它可能是可能的）。
  2. 不仅 event::representate 函数需要专门化。还有 event::serialize 和 event::deserialize。

很好看第2点；OStream 类在模板化成员函数中使用 event::serialize 和 event::deserialize。但是 event::serialize 和 event:: deserialize 的特化必须能够使用 OStream（模板）方法。

好吧，我被困在了这一点上。我希望有人能指出我正确的方向！

资源

快速.hpp：

#ifndef HG_swift
#define HG_swift

// C++ Includes
#include <boost/cstdint.hpp>
#include <string>

namespace swift
{
    // Cross-platform primairy types:
    typedef void Void;
    typedef bool Bool;
    typedef Bool Bit;
    typedef char Char;
    typedef unsigned char UChar;
    typedef uint8_t Byte;
    typedef int16_t Int16;
    typedef uint16_t UInt16;
    typedef int32_t Int32;
    typedef uint32_t UInt32;
    typedef Int16 Short;
    typedef UInt16 UShort;
    typedef Int32 Int;
    typedef UInt32 UInt; 
    typedef double Double;
    typedef float Float;
    typedef std::string String;     
} 

#endif //HG_swift

迅速/事件.hpp

#ifndef swift_event
#define swift_event

#include <iostream>
#include <sstream>
#include <exception>

#include <swift/String.hpp>

namespace swift
{   
    class OStream;
    class IStream;

    namespace event
    {       
        template<class T> String representate(T& value)
        {
            return "~";
        }

        template<class T> void serialize(T& value, OStream& stream) { }
        template<class T> void deserialize(T& value, IStream& stream) { }
    }
}

#endif //swift_event

快速/OStream.hpp：

#ifndef HG_swift_OStream
#define HG_swift_OStream

// Imports:
#include "swift.hpp"

// C++ includes:
#include <iostream>
#include <boost/archive/binary_oarchive.hpp>

namespace swift 
{
    struct OStream
    {
        boost::archive::binary_oarchive archive;

        OStream(std::ostream& os) : archive(os, boost::archive::no_header) {}

        template<class T> void write(T value)
        {
            event::serialize(value, *this);
        }
    };
}

#endif //HG_swift_io_OStream

快速/事件/primitives.tpl：

#include <swift.hpp>
#include <swift/event.hpp>
//#include <swift/IStream.hpp>
#include <swift/OStream.hpp>
#include <iostream>
#include <sstream>

namespace swift
{
    // Events
    namespace event
    {
        // Events for primary types:
        // Int32
        template<> String representate<Int32>(Int32& value)
        {
            std::stringstream str;
            str << value;
            return str.str();
        }

        template<> void serialize<Int32>(Int32& value, OStream& stream)
        {
            stream.archive & value;
        }

        template<> void deserialize<Int32>(Int32& value, IStream& stream)
        {
           stream.archive & value;
        }
}
}
4

1 回答 1

0

问题是 aconst Int32&不能转换为 a Int32&。所以专业是无法匹配的。改为swift/event/primitives.tpl使用它会起作用：

    template<> String representate<const Int32>(const Int32& value)
    {

或者您可以将主模板更改为采用 aconst T&而不是T&.

对于函数，重载实际上比specialize 更好（参见Template Specialization VS Function Overloading）：

    String representate(Int32 value)
    {
于 2012-10-17T15:13:12.147 回答