在编译时确保模板类型的一致性

Question

我有这个模板类：

template <class Tin, class Tout>
class Foo
{
    Tin input;
    Tout output;

    static inline void __ensure_type_consistency
    {
        int16_t* p = (int16_t *)0;
        // uint16_t* p1 = p;
        Tin* check_type_in = p;
        Tout* check_type_out = p;  
    }
public:
    ...
}

我想确保 Tin 和 Tout 都是 typedef 类型以键入 int16_t 而不是其他类型。 （注意： 请在下结论之前阅读完整的问题）

如果我取消注释注释行，我会得到预期的错误；编译器不允许不同类型的指针在没有强制转换的情况下相互分配：

"src\foo.h", line 47: error #145: a value of type "int16_t *" 
cannot be used to initialize an entity of type "uint16_t *"

但如果我把它注释掉，我会实例化：

Foo<uint16_t, int32_t> illegalFoo;

即使使用相同类型的检查，我也没有收到编译器错误（在从未实际调用的静态函数中创建不兼容的指针分配，但这会导致编译器错误）

有没有办法创建静态编译时类型一致性检查？为什么我使用的那个不起作用？

注意：暂时忽略摆脱模板参数的明显解决方案。这将“解决”这个问题，但是我的调试工具在这里发生了一些带外的事情，其中​​ typedef 被用于传递重要的元数据：我想确保 Foo.input 的类型为 Tin Tin 是 int16_t 或解析为 int16_t 的 typedef，与 Foo.output 和 Tout 类似。从我的调试工具的角度来看，存在细微差别，可以区分 typedef 的类型和它们的基类型，即使在 C++ 程序中它们是相同的。

---

编辑：顺便说一句，这是一个嵌入式系统，我不能使用 Boost。它也不是 C++0x。

Answer 1

您可以在static_assert 中使用is_same 类型特征。 C++0x 看起来像：

static_assert(std::is_same<Tin, std::int16_t>::value &&
              std::is_same<Tout, std::int16_t>::value, "o noez");

您也可以在 Boost 中找到 the is_same type trait 和 static assert。即使您正在为嵌入式系统进行编译，也可以直接从 Boost 中提取类型特征和静态断言标头，并且这些库都没有任何运行时开销。

Answer 2

一种简单的方法：

template <class, class> class Foo;

template <>
class Foo<int16_t, int16_t> {
  ...
};

如果您的条件实际上更复杂，另一种方法是使用 Boost 中的 BOOST_STATIC_ASSERT 或 C++0x 中的 static_assert。由于您想要非 Boost 选项并且 C++0x 可能无法正常工作，因此这里的内容与您在示例中发布的内容更相似：

(void)(true ? (int16_t**)0 : (Tin**)0);

Tout 也是如此。这需要在某种被调用或获取地址的方法中（这样做的习惯用法在the Boost.Concept_check implementation documentation 的末尾）。如果您想要其他人发布但没有 Boost 或 C++0x 的 is_same/static_assert 解决方案，请尝试：

template <class, class> struct types_valid {static const int value = -1;};
template <> struct types_valid<int16_t, int16_t> {static const int value = 1;};

然后将static char foo[types_valid<Tin, Tout>::value]; 放在你的类中，放在任何方法之外。我相信你不需要真正定义foo，只要你不在任何地方引用它。

Answer 3

虽然你不能使用 boost 或 C++1x，但你可以制作自己的 is_same 编译时类型比较器并破解一些穷人的编译时断言

// Beware, brain-compiled code ahead!
template< typename T1, typename T2>
struct is_same      { static const bool result = false; };

template< typename T > 
struct is_same<T,T> { static const bool result = true; };

template< bool Condition, typename Dummy = void >
struct static_assert {
  typedef bool result;
};

template<typename IntentionalError>
struct static_assert<false,IntentionalError> {
  typedef typename IntentionalError::does_not_exist result;
};

并像这样使用它：

template <class Tin, class Tout>
class Foo
{
    Tin input;
    Tout output;

    typedef typename static_assert<is_same<Tin ,int16_t>::result>::result Tin_test;
    typedef typename static_assert<is_same<Tout,int16_t>::result>::result Tout_test;
    typedef typename static_assert<is_same<Tout,Tout   >::result>::result Tout_test;
// ...
};

Answer 4

您的方法有效，但您必须在某处实际调用 __ensure_type_consistency ( ) 以便编译器抛出错误。如果该方法从未被调用，那么编译器认为它可以忽略它。

我刚刚在 VC++ 2010 中尝试过，它可以工作。

---

您在使用 GCC 吗？尝试在 __ensure_type_consistency 上使用 attribute ((used))。

Answer 5

您可以使用 Boost 概念检查：

BOOST_CONCEPT_ASSERT((boost::Integer<Tin>));
BOOST_CONCEPT_ASSERT((boost::Integer<Tout>));

见http://www.boost.org/doc/libs/1_45_0/libs/concept_check/using_concept_check.htm

Answer 6

我已经调整了对这个问题的几个回答，这似乎很好地解决了这个问题：

辅助类：

template <typename T1, typename T2>
struct TypeConsistency
{
private:
    static inline void checkfunction()
    {
        T1* p1 = (T1 *)0;
        T2* p2 = p1;
    }
public:
    static inline void check() { checkfunction; }
    /* The above line does nothing at runtime,
     * but takes the address of checkfunction(),
     * which causes a compile-time type check.
     */ 
};

在我的 foo 类中应用它：

template <class Tin, class Tout> 
class Foo
{
    Tin input;
    Tout output;

public:
    Foo() { 
        TypeConsistency<int16_t, Tin>::check();
        TypeConsistency<int16_t, Tout>::check();
    }
    ...
}