c++ - constexpr如何推导值？

Question

我正在浏览cppreference.com中提到的LiteralTypes程序。
(https://en.cppreference.com/w/cpp/named_req/LiteralType)

我知道constexpr会在编译时推断出该值。
但是在下面的情况下，第10、12和16行不直接知道输入参数。 (至少我看不出来)

那么如何推算值(value)呢？

  1 #include <iostream>
  2 #include <stdexcept>
  3 
  4 class conststr
  5 {
  6     const char* p;
  7     std::size_t sz;
  8 public:
  9     template<std::size_t N>
 10     constexpr conststr(const char(&a)[N]) : p(a), sz(N - 1) {}
 11 
 12     constexpr char operator[](std::size_t n) const
 13     {
 14         return n < sz ? p[n] : throw std::out_of_range("");
 15     }
 16     constexpr std::size_t size() const { return sz; }
 17 };
 18 
 19 constexpr std::size_t countlower(conststr s, std::size_t n = 0,
 20                                              std::size_t c = 0)
 21 {
 22     return n == s.size() ? c :
 23            s[n] >= 'a' && s[n] <= 'z' ? countlower(s, n + 1, c + 1) :
 24                                         countlower(s, n + 1, c);
 25 }
 26 
 27 // output function that requires a compile-time constant, for testing
 28 template<int n>
 29 struct constN
 30 {
 31     constN() { std::cout << n << '\n'; }
 32 };
 33 
 34 int main()
 35 {
 36     std::cout << "the number of lowercase letters in \"Hello, world!\" is ";
 37     constN<countlower("Hello, world!")>(); // implicitly converted to conststr
 38 }

Answer 1

当到达第37行constN<countlower("Hello, world!")>();时，编译器将尝试推导该值并将其替换为适当位置。
因此，编译器会调用countlower("Hello, world!")函数。然后将参数std::size_t n = 0, std::size_t c = 0设置为默认值，因为它们没有传入。
函数主体由递归return n == s.size() ? c : s[n] >= 'a' && s[n] <= 'z' ? countlower(s, n + 1, c + 1) : countlower(s, n + 1, c);组成，其中参数n和c在每次迭代时都会递增。n是用于标记当前测试的字符位置的索引。c表示小写字母的数量。
当n到达结束索引时，所有递归调用都返回值，并到达最终值。该值作为在第28行template<int n>定义的模板参数传递，并构造新的constN对象。
一切都在编译时完成。
第二眼
假设编译器是另一个C++程序，它定义了一个递归函数，该递归函数对传递的字符串中的小写字符数进行计数，并返回一个以该数字作为其成员的对象。
所以这:constN<countlower("Hello, world!")>();然后替换为:constN<9>();构造函数
好。因此，让我们将constN结构想象为一个普通的结构或类，如下所示:

struct constN
{
    int n;

    // constructor for the object taking one argument
    constN(int n) : n(n) {};
}

在像 constN(9)这样的随意调用之后，我们得到一个带有 n = 9的对象。现在，模板参数就是这样，但是您将其放在尖括号 <>中传递。
所以这些是相等的:

struct CasualObject
{
    int n;

    CasualObject(int n) : n(n) {};
}

template<int n>
struct YourObject
{
    YourObject() { std::cout << n << '\n'; }
};

CasualconstN(9) == YourconstN<9>()

现在让我们说 countlower函数只是一个返回一些整数的普通函数。因此，您可以在创建对象之前调用该函数，该对象将函数的结果传递给构造函数。
所以这些等于:

int a = countlower("Hey");
constN obj1(a);

constN obj2(countlower("Hey"));

obj1 == obj2;

最后，编译器使用 n = countlower("Hello, world!")创建对象。现在，请注意 constN在第31行定义的唯一方法: constN() { std::cout << n << '\n'; }哇。它是一个构造函数。它具有与对象类型相同的名称。因此，我们不仅可以使用 n = 9调用构造函数，而且还可以执行其主体。这意味着 n已打印到控制台。
最后，对象 constN没有分配给任何变量。这意味着永远无法再次引用它。智能编译器可能会一起删除第37行，并用简单的print语句替换它: cout << 9 << '\n; //“Hello，world!”中有9个小写字母
隐式转换
所以问题是这样的:编译器在构造 N时如何知道 conststr是什么？
为了说明，我做了一个小程序:

#include <iostream>

class conststr
{
    const char* p;
    std::size_t sz;
public:
    template<std::size_t N>
    constexpr conststr(const char(&a)[N]) : p(a), sz(N - 1) {}
    
    constexpr std::size_t size() const { return sz; }
};

int main()
{
    char a[4] = "Hey";
    const char b[4] = "Hey";
    
    conststr x(a);
    conststr y(b);
    conststr z("Hey");
    
    printf("%lu %lu %lu", x.size(), y.size(), z.size());
    return 0;
}

现在，如果运行该命令，将获得输出 3 3 3。但是我在这里让您大哭:“代码中只有4，最后一个对象的大小完全没有声明。”让我们对它进行一点一点的解密:
首先，我们创建一些类型为 char array和 const char array(本质上是指针)的字符串。

char a[4] = "Hey";
const char b[4] = "Hey";

它们包含3个字母和一个空终止符 \0，使其成为4个字符。当我们创建第一个 conststr对象时:

conststr x(a);

因此，我们传递了类型为 a的变量 char []。 char []可以转换为 const char[]。与 const修饰符基本相同。也可以将其转换为 std::string等。
因此，编译器认为它非常相似。到目前为止，我们已经定义了构造函数的以下代码:

conststr(const char(&a))
// which can be converted to all of these:
conststr(const char a[])
conststr(char* a)
conststr(char (&a))

但是定义了一个模板:

template<std::size_t N>
conststr(const char(&a)[N])

为了确定 N应该是什么，编译器将尝试重写 a参数的定义以适合功能需求。这称为隐式转换，并具有一些规则:

如果传递的参数匹配类型，就可以了

如果不这样做，请尝试转换

如果有转化，请应用

如果在编译时不知道从传递类型到参数类型的转换，则引发编译错误

// so from main() we have:
char a[4] = "Hey";
// this can be rewritten like so:
const char a[4] = "Hey";
    
// now it looks very similar to the definition of the constructor:
const char(&a)[N]
const char a[4]

正如我之前所展示的，这些是相等的。因此，现在，编译器可以将括号中的内容代替 N放置。
好。但这不是3 ...如果我们在构造函数的“body”内部查看，则会看到 size sz被分配了值 N - 1。这就是我们的3。

conststr(const char(&a)[N]) : p(a),  sz(N - 1)
conststr(const char a[4]): p("Hey"), sz(4 - 1)

现在，诸如 template<std::size_t N>之类的模板只是对编译器说，应该在编译时计算或转换该值。因此，您无法真正组成自己的 N，它始终取决于传入的字符串的长度。
好的，那这个呢？

conststr z("Hey");

再一次，编译器尝试将参数转换为合适的类型。并且因为它需要 const char a[]，所以它将被转换为那个。我已经介绍过了。