ABu's questions

以下代码片段在 gcc 8.5 至 10.5 版本中失败g++ -std=c++17（https://godbolt.org/z/od99f93Tx）：

struct T { char arr[2]; };

int main()
{
    T data;
    data = { "V" };
    return 0;
}

错误是：

source>: In function 'int main()':
<source>:6:18: error: no match for 'operator=' (operand types are 'T' and '<brace-enclosed initializer list>')
     data = { "V" };
                  ^
<source>:1:8: note: candidate: constexpr T& T::operator=(const T&)
 struct T { char arr[2]; };
        ^
<source>:1:8: note:   no known conversion for argument 1 from '<brace-enclosed initializer list>' to 'const T&'
<source>:1:8: note: candidate: constexpr T& T::operator=(T&&)
<source>:1:8: note:   no known conversion for argument 1 from '<brace-enclosed initializer list>' to 'T&&'
Compiler returned: 1

但是它在 gcc 11.1 中可以使用相同的-std=c++17标志。如果您将数组成员更改为其他非数组类型（如 int 或其他类型），并替换"V"为某个兼容值，那么它在从 8.5 到 11 的所有版本中都可以使用。这是 gcc 错误吗？该错误已在 gcc 11 中修复，还是与聚合初始化相关的某些标准缺陷直到后来才得到解决？还是什么？

考虑这个空程序：

int main()
{ return 0; }

如果我用 C++ 用 编译它g++ main.cpp && strace ./a.out，并用 分析输出strace，我观察到输出的最后几行是（你可以添加-O3效果是一样的）：

mprotect(0x7f71af154000, 45056, PROT_READ) = 0
mprotect(0x7f71af38b000, 4096, PROT_READ) = 0
brk(NULL)                               = 0xed2000
brk(0xf05000)                           = 0xf05000
exit_group(0)                           = ?
+++ exited with 0 +++

但是，如果我这样做：gcc main.cpp && strace ./a.out

mprotect(0x7f4114318000, 16384, PROT_READ) = 0
mprotect(0x7f4114547000, 4096, PROT_READ) = 0
exit_group(0)                           = ?
+++ exited with 0 +++

如您所见，在 C++ 中有一个额外的brk函数将堆扩展了 204KB（将两者均转换为十进制后，0xf05000 - 0xed2000 = 204KB）。可以通过将该程序替换为（coliru 链接）轻松验证这一点：

#include <iostream>
#include <unistd.h>

int main()
{
    char buf[1024];
    sprintf(buf, "pmap -XX %u", getpid());
    std::system(buf);
    
    return 0;
}

您可以轻松观察到，使用 进行编译的g++大小[heap]为 204KB，并且gcc行[heap]甚至从pmap输出中消失了。

注意：顺便说一下，令我惊讶的是，gcc 对于 include 和in<iostream>的存在完全没有问题。stdstd::system

这 204KB 是用来做什么的？我对这 204KB 一点也不担心，但它引起了我的注意，现在我很好奇。

在 AWK 中，为了对数组进行排序，我可以定义自己的排序函数，既可以在 for 循环中控制数组的遍历，也可以调用asort或asorti。比较函数的签名最多接受 6 个参数，但最后两个参数是可选的：

function cmp_field(i1, v1, i2, v2, l, r) { whatever; }

l和的用途是什么r？据我所知，它们只是占位符，AWK 根本不使用或检查它们，而是为了我自己方便，以便我可以在它们内部存储值，作为某种便利辅助变量。例如分配l和从和r计算出的临时值。但是，为什么我需要它们或它们的用途是什么，如果我可以像这样声明自己的变量：v1v2

function cmp_field(i1, v1, i2, v2) { 
   l = computation(v1);
   r = computation(v2);
   whatever; 
}

l除了第二个例子中的全局变量之外，还有其他区别吗r？或者除此之外还有其他原因吗？

据我了解：

• 活锁：一个线程无法取得进展，但它会永远执行（该线程无限期地处于活动状态）：例如，它处于一个循环中，无限地尝试访问永远不会再可用的共享资源。
• 死锁：线程没有进展，但甚至没有执行（线程无限期休眠，因此已死亡）：它正在等待操作系统根据永远不会发生的条件唤醒它。
• 饥饿：一个线程没有取得进展并且被阻塞（类似于死锁），但是等待被唤醒的条件确实发生了，只是碰巧有其他线程总是在我之前取代我的位置。

首先，这些定义是否正确？如果正确，它们是否也适用于单线程程序？例如：

// begin of useful work
until (some_buggy_condition_that_will_never_be_satisfied())
    do_something();
// end of useful work

在上面的例子中，循环将永远执行，因为与共享资源无关的条件有一个错误，并且永远不会满足。因此线程：

• 正在执行。
• 为了做有用的工作，循环必须结束
• 循环永远不会结束，因为结束条件永远不会满足

因此，该列表符合我上面的活锁定义，只是我在并发上下文之外使用了该术语。这样可以吗？

想象一下以下情况，我有一个noexceptC++ 自由函数，它作为函数指针传递给另一个具有 C 链接的函数：

extern "C" {
   void some_fun(void(*)());
}

void my_fun() noexcept { /* do stuff */; }

int main()
{
   some_fun(my_fun);
}

noexcept这是正确的和/或允许的吗？在这种情况下会发生什么？考虑到 C++17属于函数类型，这里的语义是什么？

此外，令我惊讶的是，这甚至可以编译（使用 gcc 和 clang）：

extern "C" {
   void some_fun(void(*)() noexcept);
}

void my_fun() noexcept { /* do stuff */; }

int main()
{
   some_fun(my_fun);
}

noexceptC 函数签名中的函数指针允许在其中使用限定符，这是否有意义？

我想创建一个函数clear，这样当像这样调用它时clear(v)，它会替换v为相同类型的默认构造值（对于内置类型，这是零初始化）。最简单的解决方案v = {}不适用于数组，因为您无法为其分配，因此我最终这样做：

    template<class T>
    void clear(T& v) noexcept
    {
        if constexpr (std::is_array_v<T>) {
            using base_t = std::remove_all_extents_t<T>;

            if constexpr (std::is_trivially_default_constructible_v<base_t>)
                std::memset(v, 0, sizeof(v));
            else {
                // To deal with multidimensional arrays, I make sure to get pointers
                // the first and last actual value of the array.
                base_t* it = reinterpret_cast<base_t*>(v);
                base_t* end = it + sizeof(v) / sizeof(base_t);

                for (; it != end; ++it)
                    clear(*it);
            }
        } else
            v = {};
    }

我想了解该实现的潜在缺陷，特别是关于别名和对齐规则。我认为实现没问题，但我不确定。检查普通构造函数基类型是因为我必须确保该类型的默认构造函数不会在初始化列表中或通过默认初始化程序为其成员添加自定义初始化值。换句话说，对于该类型，将其零初始化和将其默认值初始化是同义词。

但是实现起来感觉太复杂了，而且我更希望编译器能处理好这一切。我只想修复数组不可分配的问题，所以我最终这样做了：

    template<class T>
    void clear(T& v) noexcept
    {
        struct helper { T v; };
        *reinterpret_cast<helper*>(&v) = {};
    }

我也想知道这种方法的潜在缺陷。

我有一个 git repo，它有一个线性的本地历史记录，比如说有 10 个提交，其中前 5 个提交在 的branch1历史记录中，后 5 个提交在 的branch2历史记录中，我想通过修改它们来修复这 10 个提交的描述/作者/日期/其他属性。情况如下：

---(old history)---A--B--C--D--E--F--G--H--I--J
                               ^              ^
                               |              |
                            branch1       branch2

我不确定如何继续。我能想到两种策略来实现我想要的效果，但我想先了解它们的潜在影响。

1. 我宁愿branch1先切换到 ，然后对其最后 5 次提交进行交互式变基，完成后再切换到 ，然后branch2对其最后 5 次提交进行交互式变基。但由于变基意味着在“新分支”中创建新的提交，所以我不知道 的 HEAD 的父级会发生什么branch1。问题是，这种策略是否会产生某种奇怪的状态，如下所示（让我们branch1'在变基之后调用新分支）：

   ---(old history)---?--?--?--?--?--F--G--H--I--J
                    |             ^              ^
                    |             |              |
                    |          branch1(???)    branch2(???)
                    |
                    |
                    --A--B--C--D--E
                                  ^
                                  |
                               branch1'
   

   F或者 git 会以正确的方式修复的父级？

2. 另一种策略是切换到branch2并直接对其最后 10 次提交进行交互式变基；但问题branch1又来了，变基之后HEAD 会指向哪里？指向branch2不再存在于历史记录中的提交？

在 Pro*C 文件中，我有一个非常简单的匿名 PL/SQL 块，如下所示：

EXEC SQL BEGIN DECLARE SECTION;
     unsigned long long stuff = 0;
EXEC SQL END DECLARE SECTION;

EXEC SQL EXECUTE
DECLARE
    nrows pls_integer := 0;
BEGIN
    select count(*) into nrows from tbl;

    if nrows != 1 then
        RAISE_APPLICATION_ERROR(-20000,
                    'The table must contain exactly one row');
    else
        select stuff into :stuff FROM tbl;
    end if;
END; 
END-EXEC;

Pro*C 抗议：

CSF-S-00201, identifier 'RAISE_APPLICATION_ERROR' must be declared

但是，将匿名 PL/SQL 块移至 SQL 开发人员（并添加 stuff 变量）：

VARIABLE stuff NUMBER;

DECLARE
    nrows pls_integer := 0;
BEGIN
    select count(*) into nrows from tbl;

    if nrows != 1 then
        RAISE_APPLICATION_ERROR(-20000,
                    'The table must contain exactly one row');
    else
        select stuff into :stuff FROM tbl;
    end if;
END;
/

工作正常。可能发生什么事？我用来编译 Pro*C 文件和在 SQL Developer 中执行块的架构是相同的。

我设置了以下选项：

sqlcheck=semantics
parse=partial
code=cpp
common_parser=yes

sqlcheck=semantics如果文件包含 PL/SQL 块，则 是强制性的，我尝试删除common_parser=yes但错误是相同的，并且我无法删除parse=partialand code=cpp，但我认为这不会对其产生任何影响。

假设我有一个如下所示的编译行：

gcc <flags...> -o a.out obj1.o obj2.o

其中 和obj1.o都obj2.o定义void f(int). 我将收到多重定义错误（违反了单一定义规则）。

好的，现在，想象一下：

gcc <flags...> -o a.out obj1.o -lstatic_lib

其中 和obj1.o都static_lib.a定义f(int). 我知道静态库是.o文件的串联，对于每个待解决的符号，都可以在.o静态库的任何文件中找到，然后解析该符号的整个 .o符号将与任何符号一起链接到二进制文件中同样.o提供的其他符号。

这种行为让我感到好奇。想象一下static_lib.a由两个对象组成，static_obj1.o并且static_obj2.o，其中static_obj1.o是由谁定义的f(int)。由于也obj1.o已定义f(int)，因此链接器不会在 中查找它static_lib.a，因此static_obj1.o理论上不会包含在内，但是，这就是问题：

• 如果obj2.o需要f2(int)，谁也定义了呢static_obj1.o？链接器在集成后是否会static_obj1.o因为现在是两次f2(int)而发出多重定义警告f1(int)？

注意：我同时标记了 C 和 C++，因为我猜想两者在这方面的行为是相同的。如果不是，请澄清，我很想知道任何行为差异。另外，如果 gcc/clang/visual studio/linux/windows 之间的行为有很大不同，请澄清。如果行为大致相同，那么重点关注 gcc 而不是 linux。

在使用 gcc 编译的文件（几个 .c 和 .cpp 文件）中，我目前有类似的内容：

#if defined(__GNUC__) && !defined(__clang__)
    #pragma GCC diagnostic warning "-Wall"
#endif

指定内联选项而不是仅使用命令行的目的是控制在哪些点之后我有兴趣变得更严格（例如，在列表之后#include）。

效果很好。然后我尝试添加-Wextra：

#if defined(__GNUC__) && !defined(__clang__)
    #pragma GCC diagnostic warning "-Wall -Wextra"
#endif

它失败。显然，您不能在单个 中使用多个选项pragma，而必须使用多行：

#if defined(__GNUC__) && !defined(__clang__)
    #pragma GCC diagnostic warning "-Wall"
    #pragma GCC diagnostic warning "-Wextra"
#endif

• Q1：有没有办法内联指定多个选项？

接下来，我尝试添加-Werrorand -pedantic，但既不使用diagnostic warning也不diagnostic error工作。例子：

    #pragma GCC diagnostic error "-Werror"

失败并显示：warning: ‘-Werror’ is not an option that controls warnings. 我该如何解决这个问题？除此之外还有哪些其他选择diagnostic [warning|error]？-pedantic或呢-pedantic-errors？因为我知道迂腐主要与标准合规性而不是诊断控制有关，而且我不知道我是否可以内联指定它。

前向范围r要求其迭代器又是前向迭代器，而前向迭代器又要求迭代器充当其自己的哨兵。但是，这是否意味着实际的哨兵类型（例如，返回的类型r.end()）与迭代器本身的类型相同或不同？