c++ - 将模板与类模板推导占位符参数匹配

Question

尝试在 GCC 10.1 中使用字符串文字作为非类型模板参数。有以下代码:

#include <cstddef>
#include <algorithm>
#include <iostream>

template<std::size_t n> struct fixed_string {
  constexpr fixed_string(char const (&s)[n]) {
    std::copy_n(s, n, this->el);
  }
  constexpr fixed_string(fixed_string<n> const& s) {
    std::copy_n(s.el, n, this->el);
  }
  constexpr bool operator==(fixed_string const&) const = default;
  constexpr auto operator<=>(fixed_string const&) const = default;
  char el[n];
};
template<std::size_t n> fixed_string(char const(&)[n])->fixed_string<n>;

template<fixed_string str>
class Base {
public:
  Base() {
    std::cout << str.el << std::endl;
  }
};

template<fixed_string str>
class Derived : public Base<str> {
};


int main(void) {
  Derived<"Hello World"> x;
}

Base它自己工作正常，试图弄清楚如何将字符串文字向上传递到类层次结构中。我认为复制构造函数可以工作，GCC 吐出这个可爱的错误消息并 mock 我的尝试:

error: no matching function for call to ‘fixed_string(fixed_string<...auto...>)’
note: candidate: ‘template<long unsigned int n> fixed_string(const fixed_string<n>&)-> fixed_string<n>’
constexpr fixed_string(fixed_string<n> const& s) {
                       ^~~~~~~~~~~~
note:   template argument deduction/substitution failed:
note:   mismatched types ‘const fixed_string<n>’ and ‘fixed_string<...auto...>’

很酷。所以<...auto...>是GCC speak对于 "Class Template Deduction Placeholder"而且我不知道如何威胁编译器将其与我的函数调用相匹配。有谁知道如何在这里强制 GCC？或者如何通过类层次结构传播字符串文字？

有趣的事实，路过str.el到 Base模板crashes GCC .

Answer 1

这肯定是一个 gcc 错误。我已经体验过并找到了这个解决方法:

template<std::size_t n> struct fixed_string {
    consteval fixed_string(char const (&s)[n]) {
        std::copy_n(s, n, this->el);
    }
    consteval fixed_string(const fixed_string<n>& s) = default;
    consteval bool operator==(fixed_string const&) const = default;
    consteval auto operator<=>(fixed_string const&) const = default;
    char el[n];
    static const std::size_t size = n;
};
template<std::size_t n> fixed_string(char const(&)[n])->fixed_string<n>;

template<std::size_t n, fixed_string<n> str>
class BaseImpl {
    public:
        BaseImpl() {
            std::cout << str.el << std::endl;
        }
};

template <fixed_string s>
using Base = BaseImpl<s.size, s>;

template<std::size_t n, fixed_string<n> str>
class DerivedImpl : public BaseImpl<n, str> {
};

template <fixed_string s>
using Derived = DerivedImpl<s.size, s>;

int main(void) {
    Derived<"Hello World"> x;
}

或者另一种方式

template<fixed_string str>
class Base {
    public:
        Base() {
            std::cout << str.el << std::endl;
        }
};

template <std::size_t n, fixed_string<n> s>
using BaseWrapper = Base<s>;

template<fixed_string str>
class Derived : public BaseWrapper<str.size, str> {
};

一般的想法是避免使用一个推导出的参数来推导出另一个参数。