标签: zero-initialization

我正在准备 C++ 入门课程的期末考试。我们的教授给了我们这个问题来练习：

解释为什么代码会产生以下输出：120 200 16 0

using namespace std;
int main()
{
  int x[] = {120, 200, 16};
  for (int i = 0; i < 4; i++)
    cout << x[i] << " ";
}

该问题的示例答案是：

cout 语句只是循环遍历其下标由 for 循环的增量定义的数组元素。元素大小不是由数组初始化定义的。for 循环定义了数组的大小，该大小恰好超出了初始化元素的数量，因此最后一个元素默认为零。第一个 for 循环打印元素 0 (120)，第二个循环打印元素 1 (200)，第三个循环打印元素 2 (16)，第四个循环打印默认数组值零，因为元素 3 没有任何初始化。现在 i 点超出了条件并且 for 循环终止。

我有点困惑为什么数组之外的最后一个元素总是“默认”为零。为了进行实验，我将问题中的代码粘贴到我的 IDE 中，但将 for 循环更改为for (int i = 0; i < 8; i++). 然后输出更改为120 200 16 0 4196320 0 …

According to cppreference.com, std::map::operator[] for non-existing value does zero-initialization.

However, the same site does not mention zero-initialization for std::unordered_map::operator[], except it does have an example which relies on this.

Of course this is just a reference site, not the standard. So, is the code below ok or not?

#include <unordered_map>
int main() {
    std::unordered_map<int, int> map;
    return map[42];     // is this guaranteed to return 0?
}

根据http://en.cppreference.com/w/cpp/language/zero_initialization,我无法理解何时以及为什么我的班级中的某个成员是零初始化的.

考虑以下测试程序:

#include <iostream>
#include <stdio.h>

class MyTest {
private:
    const static unsigned int dimension = 8;
    void (* myFunctions [dimension])();

public: 
    MyTest() {}

    void print() { 
        for(unsigned int i=0; i < MyTest::dimension; i++) {
            printf("myFunctions[%d] = %p\n", i, this->myFunctions[i]);
        }   
    }
};


int main() {
    //We declare and initialize an object on the stack 
    MyTest testObj = {};
    testObj.print();

    return 0;
}

我声明一个类有一个包含签名"void functionname()"的8个函数指针的数组.当我宣布和初始化类的对象main作为MyTest testObj = {};或者MyTest testObj;,我希望它是零初始化,即所有指针都是空指针.

但是,在带有g++ -m32 …

C++ 是否支持允许我们将对象及其所有填充字段初始化为零的语言构造。我在 cppreference.com 中发现了一些关于零初始化的令人鼓舞的措辞，表明在某些情况下，填充字节也将被清零。

引用自 cppreference.com： 零初始化

零初始化在以下情况下进行：

2. 作为非类类型和没有构造函数的值初始化类类型的成员的值初始化序列的一部分，包括未提供初始化程序的聚合元素的值初始化。

零初始化的效果是：

• 如果 T 是标量类型，则对象的初始值是显式转换为 T 的整数常量零。
• 如果 T 是非联合类类型，则所有基类和非静态数据成员都初始化为零，并且所有填充都初始化为零位。构造函数（如果有）将被忽略。
• ...

人们会在value-initialization、aggregate-initialization和list-initialization中找到对零初始化的引用。

我使用相当最新的 GCC 和 clang C++ 编译器进行了测试，它们的行为似乎有所不同。

坦率地说，我努力解析这些规则，特别是考虑到不同的编译器行为，我无法弄清楚如何正确解释这些规则。

请参阅此处的代码（至少需要 C++11）。结果如下：

给出： Foo

struct Foo
{
    char x;
    int y;
    char z;
};

这里[----] …

我正在修改的代码tf.get_variable用于权重变量和tf.Variable偏差初始化.经过一些搜索后,get_variable由于其在共享方面的可移植性,似乎总是应该受到青睐.因此,我尝试将偏差变量更改为get_variable但似乎无法使其工作.

原版的: tf.Variable(tf.zeros([128]), trainable=True, name="b1")

我的尝试: tf.get_variable(name="b1", shape=[128], initializer=tf.zeros_initializer(shape=[128]))

我得到一个错误,说不应该为常量指定形状.但删除形状然后抛出错误没有参数.

我很新,tf所以我可能误解了一些基本的东西.我在这里先向您的帮助表示感谢 :)

使用yarn-berry时，在实现零安装时是否应该将拔出的内容应用到git存储库？

据我所知，在零安装的情况下，我们从 git 存储库yarn start收到后立即 继续。git clone

然而，由于未插入文件夹，我们yarn installs不可避免地必须继续。

当然，有多种方法可以使用 git-ignore 将 UnpluggedFolder 放入 git 存储库中，但我不确定这是否是运行零安装的正确方法。

当我尝试时yarnstart

$ yarn start
C:\Users\com\Desktop\zero3\project\.pnp.cjs:25991
      Error.captureStackTrace(firstError);
            ^

Error: Required unplugged package missing from disk. This may happen when switching branches without running unplugged packages must be fully materialized on disk to work).

Missing package: open@npm:8.4.0
Expected package location: C:\Users\com\Desktop\zero3\project\.yarn\unplugged\open-npm-8.4.0-df63cfe5dules\open\

吉蒂诺尔

# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.

# dependencies
/node_modules

# testing
/coverage

# production
/build

# …

在做了大量测试并写下这个答案之后（注意：在我完全重写它之前对它的反对票），我不明白为什么= {0}不将结构的所有成员设置为零！

如果你这样做：

struct data_t
{
    int num1 = 100;
    int num2 = -100;
    int num3;
    int num4 = 150;
};

data_t d3 = {0};
printf("d3.num1 = %i\nd3.num2 = %i\nd3.num3 = %i\nd3.num4 = %i\n\n",
       d3.num1, d3.num2, d3.num3, d3.num4);

...输出是：

d3.num1 = 0
d3.num2 = -100
d3.num3 = 0
d3.num4 = 150

...虽然我预计输出是这样的：

d3.num1 = 0
d3.num2 = 0
d3.num3 = 0
d3.num4 = 0

...这意味着只有 FIRST 成员被设置为零，其余的都被设置为默认值。

我一直认为以这 3 种方式中的任何一种初始化结构都会将其初始化为零，但显然我错了！

1. data_t d{}
2. data_t d …

#include <stdio.h>
#include <string.h>

int main(int argc, const char * argv[]) {
    int i;
    char s1[100] = "Computer Programming Class";
    char s2[100] = "ECE";
    
    int length = (int)strlen(s1);
    for (i = 0; i < length; i++) {
        s2[i] = s1[length - 1 - i];
    }
    
    s2[i] = '\n';
    printf("%s", s2);
    
    return 0;
}

这是我的一项测试，我不明白为什么它会按预期工作。就是一段代码，将s1的顺序颠倒过来，存到s2中，然后打印出来。在我看来，当 s1 向后存储时，s2 中的空字符将被覆盖，而且 s1 中的空字符永远不会写入 s2 中，因为它是从最后一个字符开始的。但打印出来效果很好。为什么？

鉴于此数组声明和初始化：

std::array<bool, 20> invalid_params{};

我可以假设数组中的所有元素都将始终初始化为 false，还是最好明确地进行初始化？

考虑到如/sf/answers/2356780681/ 中详述的考虑，这似乎xor reg, reg是将寄存器清零的最佳方法。但是当我审视现实世界的汇编代码（如Windows Bootloader代码，IIRC），我看到这两个xor reg, reg和sub reg, reg使用了。

为什么sub完全用于此目的？sub在某些特殊情况下有什么理由更喜欢吗？例如，它设置的标志是否与xor?