我正在浏览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 }

最佳答案

当到达第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);组成,其中参数nc在每次迭代时都会递增。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 arrayconst 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[],所以它将被转换为那个。我已经介绍过了。

    关于c++ - constexpr如何推导值?,我们在Stack Overflow上找到一个类似的问题:https://stackoverflow.com/questions/61362393/

    10-13 07:00