constexpr 如何推导出值？

Question

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

我知道 constexpr 在编译时推导值。但在下面的情况下，第 10、12 和 16 行并不能直接知道输入参数。（至少我看不出来）

那它是怎么推算出来的呢？

  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到达结束索引时，所有递归调用return值和最终值都达到了。该值作为第 28 行定义的模板参数传递 template<int n> 并构造新的 constN 对象。

这一切都在编译时完成。

再看

将编译器想象成另一个 C++ 程序，它定义了一个递归函数，该函数计算传递的字符串中低位字符的数量，returns 一个以数字作为其成员的对象。

所以这个：

constN<countlower("Hello, world!")>();

然后替换为：

constN<9>();

构造函数

好的。因此，让我们将 constN 结构想象成一个普通结构或 class，如下所示：

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 函数只是 return 一些整数的普通函数。因此，您可以在创建对象之前调用该函数，该对象将函数的结果传递给构造函数。

所以这些等于：

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 行一起删除并用简单的打印语句替换它：

cout << 9 << '\n; // "Hello, world!" 中有 9 个小写字母`

隐式转换

所以问题是这样的：编译器如何知道构造conststr时N应该是什么？

为了说明，我做了一个小程序：

#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。但是我在这里你哭了：“代码中只有 4s，最后一个对象没有完全声明大小。”让我们一点一点来解密：

首先我们创建一些类型为 char array 和 const char array 的字符串（本质上是指针）。

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

它们包含 3 个字母和一个空终止符 [=52=]，这使得它有 4 个字符。当我们创建第一个 conststr 对象时：

conststr x(a);

所以我们传递类型为char []的变量a。 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... 如果我们查看构造函数的“主体”内部，我们会看到 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[]，所以它会被转换成那个。我已经介绍过了。

constexpr 如何推导出值？

How constexpr deduces the value?

c++

constexpr

c++11

再看

构造函数

隐式转换