小编cur*_*guy的帖子

我正在实现一些C++静态分析规则,其中一个规则禁止函数返回引用或指向函数引用参数的指针,即以下都是不兼容的:

int *f(int& x) { return &x; } // #1
const int *g(const int& x) { return &x; } // #2
int& h(int& x) { return x; } // #3
const int& m(const int& x) { return x; } // #4

为此给出的理由是"它是实现定义的行为,无论引用参数是临时对象还是对参数的引用."

然而,我对此感到困惑,因为C++中的流操作符是以这种方式编写的,例如

std::ostream& operator<<(std::ostream& os, const X& x) {
    //...
    return os;
}

我认为我非常有信心C++中的流操作符通常不会表现出实现定义的行为,所以发生了什么？

根据我目前的理解,我希望#1和#3能够很好地定义,因为temporaries不能绑定到非const引用,所以int& x指的是一个超出范围的实际对象函数,因此返回指向该对象的指针或引用是好的.我希望#2变得狡猾,因为一个临时的本来可以被束缚const int& x,在这种情况下,试图取其地址似乎是一个糟糕的计划.我不确定#4 - 我的直觉是,这也可能是狡猾的,但我不确定.特别是,我不清楚以下情况会发生什么:

const int& m(const int& x) { return x; }
//...
const int& r = m(23);

据我所知,编译器从不优化声明为的变量volatile.但是,我有一个像这样声明的数组.

volatile long array[8];

不同的线程读写它.数组的元素仅由其中一个线程修改,并由任何其他线程读取.但是,在某些情况下,我注意到即使我从一个线程修改一个元素,读取它的线程也不会注意到这个变化.它继续读取相同的旧值,就好像编译器已将其缓存在某处.但是编译器本身不应该缓存volatile变量,对吧？那怎么会发生这种情况.

注意:我不是volatile用于线程同步,所以请停止给我答案,如使用锁或原子变量.我知道volatile,atomic变量和互斥量之间的区别.另请注意,该体系结构是x86,具有主动缓存一致性.在我认为变量被其他线程修改后,我也读了很长时间.即使经过很长一段时间,阅读线程也看不到修改后的值.

C++内存分配运算符的形式为operator new (size_t s).当我new为类型的类对象重载运算符时T,它是否保证size_t s运算符的输入参数(即)new确切sizeof(T)？如果是,为什么这个函数仍然需要大小作为输入参数？

来自另一个问题:

由于C++ 17,auto x0{1, 2, 3, 4};以前推断出初始化列表,不再允许(当然,我们可以使用auto x0 = {1, 2, 3, 4};...).现在一如既往地避免统一初始化(例如std::vector<int> v({1, 2, 3, 4});,使用初始化列表作为参数进行显式构造函数调用),并且类似于定义良好auto x(7);(我不会自己使用的构造......),我想出了以下内容:

auto x({1, 2, 3, 4});
// -> std::initializer_list<int> x({1, 2, 3, 4});

这是用GCC 7.2.0(mingw64)编译的,但是发出警告(而评论版再次没有):

list-initializer for non-class type must not be parenthesized

我在标准中找不到任何相关内容,所以现在的问题是(出于纯粹的兴趣......):

为什么不允许这样做？(这是否被标准所涵盖,或者我们是否需要将此视为GCC错误？)

采取以下代码

#include <iostream>

void func() {
    int i = 2147483640;
    while (i < i + 1)
    {
        std::cerr << i << '\n';
        ++i;
    }

    return;
}

int main() {
    func(); 
}

这段代码显然是错误的，因为while循环仅在有符号的int i溢出（即UB）时才能终止，因此编译器可以例如将其优化为无限循环（Clang在上进行-O3）或执行其他类型的时髦操作。现在我的问题是：从我对C ++标准的阅读中，等同于签名的类型可能会别名（即指针int*和unsigned*别名）。为了进行一些时髦的签名“包装”，以下内容是否具有未定义的行为？

#include <iostream>

static int safe_inc(int a)
{
    ++reinterpret_cast<unsigned&>(a);
    return a;
}

void func() {
    int i = 2147483640;
    while (i < safe_inc(i))
    {
        std::cerr << i << '\n';
        ++i;
    }

    return;
}

int main() {
    func(); …

考虑以下示例：

struct Parent
{
    Parent ();

    Parent (const Parent &);
};

struct Child : public Parent
{
    using Parent::Parent;
};

Parent p;

Child c (p);

这是从以下问题中得出的：为什么“继承的构造函数不是从相同或派生类型的表达式初始化的候选对象”？

最初的问题是关于C ++ 11的。在C ++ 11中，有一些措辞阻止Child获取采用以下内容的构造函数const Parent&：

对于继承的构造函数候选集中的每个非模板构造函数，除了没有参数的构造函数或具有单个参数的复制/移动构造函数之外，除非具有用户声明的构造函数，否则该构造函数将隐式声明为具有相同的构造函数特性类中出现使用声明的相同签名。

N4429极大地改变了继承构造函数的规范，并被认为可追溯到C ++ 11（我认为？）。N4429的目的是使基类构造函数看起来像是派生类构造函数一样可见，而不是声明委派给基类构造函数的派生类构造函数。在N4429的第一个版本中，有以下措词，保留了C ++ 11的限制：

当using声明声明类从基类继承构造函数时，基类的默认构造函数，复制构造函数和move构造函数（如果有）将从引入的声明集中排除。

但是，在本文的更新版本P0136R0中，该措辞不再存在，并且没有给出原因的解释。该文件再次进行了修订，然后被合并为标准。因此，在C ++ 17中，我看不到任何阻止上述代码编译的规则。

尽管如此，GCC和Clang都拒绝了它。lang声：

继承的构造方法不是从相同或派生类型的表达式初始化的候选对象

但是，我无法在标准中找到类似这样的内容。

这段代码在C ++ 17中格式错误吗？如果是这样，为什么？

看着经过一大堆 的 其他 问题 和 他们的 答案，我得到的印象是有什么在C“挥发性”关键字表示正好没有广泛的协议。

即使标准本身似乎也不够清晰，以至于每个人都无法理解其含义。

除其他问题外：

1. 根据您的硬件和编译器，它似乎提供了不同的保证。
2. 它影响编译器优化，但不影响硬件优化，因此在执行自己的运行时优化的高级处理器上，甚至不清楚编译器是否可以阻止您要阻止的任何优化。（某些编译器确实会生成指令来阻止某些系统上的某些硬件优化，但这似乎并未以任何方式进行标准化。）

总结一下问题，似乎（经过大量阅读）“ volatile”保证了类似的结果：该值将不但从/向寄存器，而且至少向内核的L1缓存中读/写，其顺序与读/写出现在代码中。但这似乎没有用，因为在同一线程内从寄存器中读取/写入寄存器已经足够，而与L1缓存进行协调并不能保证与其他线程进行协调。我无法想象仅与L1缓存进行同步的重要性。

用途1
唯一广泛同意使用volatile的似乎是旧的或嵌入式系统，其中某些内存位置通过硬件映射到I / O功能，例如内存中的某个位（直接在硬件中）控制灯光。 ，或内存中的某个位告诉您键盘键是否按下（因为它是通过硬件直接连接到键的）。

看来，“用1”不移植的代码，其目标包括多核系统发生。

USE 2
与“ use 1”没什么不同，是可由中断处理程序（可以控制灯光或存储来自按键的信息）随时读取或写入的内存。但是为此已经存在一个问题，即取决于系统，中断处理程序可能会在 具有自己的内存缓存的不同内核上运行，并且“ volatile”不能保证所有系统上的缓存一致性。

因此，“使用2”似乎超出了“易失性”所能提供的范围。

用途3
我看到的唯一其他无可争议的用途是防止通过指向编译器未意识到的同一内存的不同变量的不同变量对访问进行错误优化。但这可能只是无可争议的，因为人们没有在谈论它-我只看到其中一个提及。而且我认为C标准已经认识到“不同”的指针（例如指向函数的不同args）可能指向同一项目或附近的项目，并且已经指定编译器必须生成即使在这种情况下也可以工作的代码。但是，我无法在最新的标准（500页！）中快速找到此主题。

那么“使用3”也许根本不存在？

因此，我的问题是：

在多核系统的可移植C代码中，“ volatile”是否可以保证任何东西？

编辑-更新

浏览最新标准后，答案似乎至少是非常有限的：
1.该标准针对特定类型“ volatile sig_atomic_t”反复指定特殊处理。但是该标准还说，在多线程程序中使用信号功能会导致不确定的行为。因此，该用例似乎仅限于单线程程序与其信号处理程序之间的通信。
2.该标准还为setjmp / longjmp指定了“ volatile”的明确含义。（在其他问题和答案中给出了重要示例代码）。

因此，更精确的问题变成了：
除了（1）允许单线程程序从其信号处理程序接收信息之外，还是（2）允许setjmp，“ volatile”对于多核系统的便携式C代码是否有任何保证？代码以查看在setjmp和longjmp之间修改的变量？

这仍然是一个是/否问题。

如果为“是”，那么最好显示一个无错误的可移植代码示例，如果省略了“ volatile”，则该示例会出现错误。如果为“ no”，那么我认为对于多核目标，在这两种非常特殊的情况下，编译器可以随意忽略“ volatile”。

下一个例子的汇编:

class A
{
  public:
    void foo()
    {
    }
};

class B : private A
{
  public:
    using A::foo;
};

int main()
{
    typedef void (B::*mf)();
    mf func = &B::foo;

    B b;
    (b.*func)();
}

失败并出现以下错误:

main.cpp||In function ‘int main()’:  
main.cpp|18|error: ‘A’ is an inaccessible base of ‘B’  
main.cpp|18|error:    in pointer to member function conversion

我知道A不是B的可访问基础,但我使用的是using关键字.它不应该允许访问函数foo吗？

标准中哪些相关段落阻止上述编译？

假设我有以下代码:

class B { /* */ };

class A {
    vector<B*> vb;
public:
    void add(B* b) { vb.push_back(b); }
};


int main() {

    A a;
    B* b(new B());
    a.add(b);
}

假设在这种情况下,B*可以处理所有原始指针unique_ptr<B>.

令人惊讶的是,我无法找到如何使用转换此代码unique_ptr.经过几次尝试,我想出了以下代码,它编译:

class A {
    vector<unique_ptr<B>> vb;
public:
    void add(unique_ptr<B> b) { vb.push_back(move(b)); }
};


int main() {

    A a;
    unique_ptr<B> b(new B());
    a.add(move(b));
}

所以我的简单问题是:这是实现它的方式,特别是,这是move(b)唯一的方法吗？(我在想rvalue引用,但我不完全理解它们.)

如果你有一个完整的移动语义解释链接unique_ptr,我无法找到,请不要犹豫,分享它.

编辑根据http://thbecker.net/articles/rvalue_references/section_01.html,我的代码似乎没问题.

实际上,std :: move只是语法糖.对于类X的对象x,move(x)与以下内容相同:

static_cast <X&&>(x)

需要这两个移动函数,因为转换为右值引用:

1. 防止函数"add"传递值
2. 使得 …

这个问题是一种消除未使用的虚函数的后续问题,对我的兴趣不够深入.

问题:在定义具有虚函数的类时,编译器为虚函数表分配存储,并存储指向表中函数的指针.这会导致链接器保留这些函数的代码,无论它们是否被调用.即使编译器优化设置要求消除死代码,这也可能导致大量死代码保留在可执行文件中.

现在,如果在可执行文件中没有任何地方存在特定虚函数的调用(或者换句话说,访问虚函数表的相应槽),则可以从虚函数表中省略相应的函数指针,并且链接器将删除函数的代码,可能会进一步遗漏其他未引用的代码.

显然,这不能由编译器完成,因为它只在链接时变得清楚是否调用了特定的虚函数(假设静态链接 - 很明显它不能用动态链接完成).我对链接器不够熟悉,以便判断编译器是否能够以链接器可以选择性地忽略表中各个未使用的条目的方式发出虚函数表.

基本上,我的思路是这样的:虚函数表中的函数指针是对函数的引用,链接器使用该函数来确定函数的代码需要保留在可执行文件中.以类似的方式,虚函数调用是对从其虚函数被调用的类派生的所有虚函数表中的特定槽的引用.这种引用是否可以通过这样一种方式传递给链接器:当它没有引用时,它可以忽略虚函数表槽？

请注意,当编译器可以在编译时确定调用目标时,这与使用直接调用替换虚函数调用不同.我知道一些编译器可以做到这一点,但这是一个不同的情况,因为函数实际上被调用,并且它是被删除的虚函数调度的开销.在我的情况下,我希望删除未调用的函数的整个代码.

如果我可以控制所有类定义,我可以手动删除所有未调用的虚函数.但是在使用库时这是不现实的.

这可以通过"链接时间优化"或"整个程序优化"来完成吗？是否有成功的编译器？