小编use*_*390的帖子

我正在尝试理解变量模板。我尝试了下面的代码，它执行整数幂。为什么 clang++ 返回0而不是8？

#include <iostream>

template<int n, int e>
int r = n * r<n, e - 1>;

template<int n>
int r<n, 0> = 1;

int main() {
    std::cout << r<2, 3>;
}

是否有任何表达式,其中一个对象的toString方法被隐式调用覆盖其valueOf方法？

在下面的示例中,valueOf始终是隐式调用的(重写toString).

"4" + {
    toString: function () {
        return "4";
    },
    valueOf: function () {
        return 6;
    }
};    // => "46", was expecting "44"

4 + {
    toString: function () {
        return "6";
    },
    valueOf: function () {
        return 4;
    }
};    // => 8

4 + {
    toString: function () {
        return 6;
    },
    valueOf: function() {
        return "4";
    }
};    // => "44"

即:

我们可以写一个表达式,其中toString被隐式调用valueOf(即没有显式调用toString)？

C 标准的第 6.11.2 节说明了在未来版本中可能会被弃用的功能之一：

在没有静态存储类说明符的情况下在文件范围内声明具有内部链接的标识符是一个过时的功能。

在没有静态存储类说明符的情况下，如何声明文件范围标识符以具有内部链接？

鉴于以下定义：

• 对象——保存某种类型值的连续内存区域。
• value -- 根据对象类型解释的对象的位。

C++ 编程语言书 [第 4 版] 的第 6.4.1 节在讨论值类别时指出：

可移动：对象可以被移动（即，我们可以将它的值移动到另一个位置，并使对象处于有效但未指定的状态，而不是复制。

题：

1. “将其价值转移到另一个位置”的真正含义是什么？
2. 如何移动值（位解释）？
3. 如何在没有副本的情况下“移动”对象的字节？只是没有意义。

有人可以解释一下吗？

考虑下面的两个翻译单元。我的目标是内联函数addinfile1.c和main.c.

文件1.c：

extern inline int add(int x, int y)
{
 return x + y;
}

void g(void)
{
  add(1, 1);     // this will probably be inlined
}

主文件：

extern int add(int, int);

void f(void)
{
  add(2, 4);    // this doesn't appear to be inlined
}

int main(void)
{
  f();
  return 0;
}

生成的程序集表明 add(2, 4) 未内联。为什么？或者是它的规则，对于在翻译单元内联函数，因此它必须被内嵌在翻译单元中声明，因此其定义必须被视为？

FLT_DIG、DBL_DIG、LDBL_DIG分别是float、double、long double类型可以准确表示的十进制位数。

#include <stdio.h>
#include <float.h>

int main(void)
{
  printf("%d, %d, %d\n", FLT_DIG, DBL_DIG, LDBL_DIG);
  return 0;
}

打印6，15和18。该标准在第 5.2.4.2.2 节中给出了准确的公式——例如对于浮点数，p = 24 和 b = 2：

但我不清楚上述公式（“否则”）是如何推导出来的。有人可以解释一下吗？

以下是我遵循的推理，但没有回答问题。考虑在有效数中有 23 位的 float 类型（IEEE-754 标准）。可以准确表示的最大二进制整数为：

  100...00 (25 digits total, because we have an implicit 1)
  = 2^24
  = 10^(24*log(2)) 

因此 # 十进制数字：

= floor(24*log(2)) = 7

而且不像floor(23 * log(2)) = 6标准规定的那样。

C17 标准第 7.17.2.2 节规定了以下有关中void atomic_init(volatile A *obj, C value)定义的内容<stdatomic.h>：

虽然这个函数初始化了一个原子对象，但它并不能避免数据竞争；即使通过原子操作，对正在初始化的变量的并发访问也会构成数据竞争。

既然拥有原子对象和原子操作的全部目的是为了避免数据竞争，那么为什么这个atomic_init函数存在呢？例如，为什么不执行以下操作呢？

_Atomic int x = 7; 

代替：

_Atomic int x; 
atomic_init(&x, 7);

另外，atomic_init当它确实是一个作业时，为什么要调用它？

C标准的第3.15.3节规定：

“如果在它们之间声明的所有成员也是非零长度位域，则在同一结构中同时更新两个非原子位域是不安全的，无论这些中间位域的大小是多少”。

考虑以下示例：

struct S {
  unsigned a: 8;
  unsigned b: 4;
  unsigned c: 4;
  unsigned d: 8;
};

根据标准，这不是安全更新位字段a和d兼任。

为什么不？

C99 标准第 6.2.6.1 8 节规定：

当运算符应用于具有多个对象表示的值时，使用哪种对象表示不应影响结果的值 (43)。如果值存储在使用具有多个对象表示的 类型的对象中，则未指定使用哪种表示，但不应生成陷阱表示。

我将 object 理解为内存中的一个位置（字节），并将值作为基于用于访问它的类型对这些字节的解释。如果是这样，那么：

1. 一个值如何有多个对象表示？
2. 一个类型如何可以有多个对象表示一个值？

该标准在脚注中增加了以下内容：

不过，我还不清楚。有人可以为我简化它并用例子解释吗？

闭包通过引用(而不是值)存储它们的外部变量.但是,在下面的代码中,我想按值存储.任何人都可以告诉我如何使用IIFE吗？

var i = -1;
var f = function () {
    return i; // I want to capture i = -1 here!
};
i = 1;
f();    // => 1, but I want -1