合并常量和非常量 std::list 的模板专用化

merging template specializations for const and non-const std::list

本文关键字：常量 专用 list 非常 std 合并      更新时间：2023-10-16

有没有一种简单的方法可以将两个模板专业化合并为一个，也许使用 std::enable_if ，用于以下 MWE？

#include <string>
#include <list>
#include <memory>
class A {
    // ...
};
class B {
    // ...
};
template<typename T> class C {};
template<typename T>
class C<std::list<T> &> : public A, public B
{
    std::list<T> &l_ref;
public:
    C(std::list<T> &lr) : l_ref{lr} { }
    // ...
};
template<typename T>
class C<const std::list<T> &> : public A, public B
{
    const std::list<T> &l_ref;
public:
    C(const std::list<T> &lr) : l_ref{lr} { }
    // ...
};

对于惯用语

template<typename T>
struct C<T, typename std::enable_if<
    std::is_same<T, std::list<E> &>::value ||
    std::is_same<T, const std::list<E> &>::value>::type>
    : public A, public B
{
    // ...

方式，我认为没有办法使E可推论或指定"任何std::list"的类型。

您可以先创建一个特征，然后使用 SFINAE，如下所示：

template <typename T> struct is_a_stdlist_ref : std::false_type {};
template <typename ... Ts>
struct is_a_stdlist_ref<std::list<Ts...>&> : std::true_type {};
template <typename ... Ts>
struct is_a_stdlist_ref<const std::list<Ts...>&> : std::true_type {};
template<typename T, typename Enabler = void> struct C;
template<typename T>
struct C<T, std::enable_if_t<is_a_stdlist_ref<T>::value>>
    : public A, public B
{
    //...
};

对于以下 MWE，有没有一种简单的方法可以将两个模板专业化合并为一个，也许使用 std：：enable_if？

您是否接受没有std::enable_it的解决方案？

为了使解决方案更加灵活，我建议定义一个类型特征，specIndex，以修复一个类型依赖索引，其中0是"泛型类型"，1是"std：：list&or const"，其他整数可以引用其他专用化。

template <typename>
struct specIndex
 { static constexpr std::size_t value { 0U }; }; // generic version
template <typename T>
struct specIndex<std::list<T> &>
 { static constexpr std::size_t value { 1U }; }; // pro lists
template <typename T>
struct specIndex<std::list<T> const &>
 { static constexpr std::size_t value { 1U }; }; // pro lists

下一步是为C添加默认模板整数参数 

template <typename T, std::size_t = specIndex<T>::value>
class C
 { };

最后一步是定义索引 1(std::list<T> &或常量(专用化

template<typename T>
class C<T, 1U> : public A, public B
 {
   private:
      T & l_ref;
   public:
      C (T & lr) : l_ref{lr}
       { std::cout << "- list version" << std::endl; }
 };

以下是完整示例

#include <string>
#include <list>
#include <memory>
#include <iostream>
class A
 { };
class B
 { };
template <typename>
struct specIndex
 { static constexpr std::size_t value { 0U }; }; // generic version
template <typename T>
struct specIndex<std::list<T> &>
 { static constexpr std::size_t value { 1U }; }; // pro lists
template <typename T>
struct specIndex<std::list<T> const &>
 { static constexpr std::size_t value { 1U }; }; // pro lists
template <typename T, std::size_t = specIndex<T>::value>
class C
 { };
template<typename T>
class C<T, 1U> : public A, public B
 {
   private:
      T & l_ref;
   public:
      C (T & lr) : l_ref{lr}
       { std::cout << "- list version" << std::endl; }
 };
int main ()
 {
   std::list<long>  sll;
   C<int>                     a;
   C<std::list<long> &>       b{sll};
   C<std::list<long> const &> c{sll};
 }
相关文章：