标签: compiler-bug

注意:我们在这里谈论(据称)符合C++ 98的编译器.这不是C++ 11的问题.

我们在其中一个编译器中有一个奇怪的行为,我们不确定这是否正常或者这是否是编译器错误:

// This struct has a default constructor
struct AAA
{
   AAA() : value(0) {}
   int value ;
} ;

// This struct has a member of type AAA and an array of int, both surrounded
// by ints
struct BBB
{
   int m_a ;
   AAA m_b ;
   int m_c ;
   int m_d[42] ;
} ;

当BBB初始化时:

BBB bbb = {0} ;

我们期望BBB的所有POD成员(包括m_d,整数数组)被零初始化,并且要构建BBB的所有非POD成员.

这适用于AIX的本机编译器,在Linux/GCC-3.4上,在Windows/VisualC++上......但不适用于Solaris/SunStudio,其中只有非数组成员被零初始化.

我们在C++ 98标准(草案文档)中进行了一些研究,在那里我们发现了以下内容:

[12.6.1 - 2]

当聚合(无论是类还是数组)包含类类型的成员并由大括号括起的初始化列表(8.5.1)初始化时,每个这样的成员都由相应的赋值表达式进行复制初始化(见8.5).如果初始化列表中的初始值设定项少于聚合的成员,则未明确初始化的每个成员都应默认初始化(8.5).

然后:

[8.5 - 5]

对 …

示例代码是:

#include <unordered_map>

int main() {
    std::unordered_map<int, std::pair<int, int>> map;

    map.emplace(1, {1, 1});

    return 0;
}

哪里emplace()有签名,如:

template <class... _Args>
pair<iterator, bool> emplace(_Args&&... __args);

该gcc说的功能expectes 0参数- 2提供的.该clang说,函数需要1个参数- 2提供的.

我甚至不明白 - 这段代码有什么问题？

以下代码使用GCC 4.9.2编译,但不与Clang 3.5.0编译:

#include <string>

class Foo
{
public:
  explicit operator std::string() const;
};

std::string bar{Foo{}}; // Works in g++, fails in clang++
std::string baz(Foo{}); // Works in both

clang ++说:

foo.cpp:9:13: error: no matching constructor for initialization of 'std::string'
      (aka 'basic_string<char>')
std::string bar{Foo{}};
            ^  ~~~~~~~
...: note: candidate constructor not viable: no known conversion from 'Foo' to
      'const std::basic_string<char> &' for 1st argument
      basic_string(const basic_string& __str);
      ^

奇怪的是,如果std::string被替换为原始类型,它就可以工作int.

我试图使用64位积分作为位图,并原子地获取/释放各个位的所有权.

为此,我编写了以下无锁代码:

#include <cstdint>
#include <atomic>

static constexpr std::uint64_t NO_INDEX = ~std::uint64_t(0);

class AtomicBitMap {
public:
    static constexpr std::uint64_t occupied() noexcept {
        return ~std::uint64_t(0);
    }

    std::uint64_t acquire() noexcept {
        while (true) {
            auto map = mData.load(std::memory_order_relaxed);
            if (map == occupied()) {
                return NO_INDEX;
            }

            std::uint64_t index = __builtin_ctzl(~map);
            auto previous =
                mData.fetch_or(bit(index), std::memory_order_relaxed);
            if ((previous & bit(index)) == 0) {
                return index;
            }
        }
    }

private:
    static constexpr std::uint64_t bit(std::uint64_t index) noexcept {
        return std::uint64_t(1) << index;
    }

    std::atomic_uint64_t mData{ …

我偶然发现了一种情况，库std::vector<T>使用用户提供的比较对象对容器（例如）进行排序。对于一种特定情况，用户实际上不想对容器进行排序，但排序是无条件发生的。

因此，为了尽量避免这种情况，我想尝试使用根据元素地址排序的比较对象。等价地，我们有：

std::vector nums{1, 5, 4};
auto cmp = [](auto& a, auto& b) { return &a < &b; };
std::sort(nums.begin(), nums.end(), cmp);

这是“有效的”，因为std::vector<T>元素以与向量中元素相同的顺序存储在（连续）内存位置中。最终结果是，nums即使在排序之后，向量似乎也没有被改变。

但是，一旦我替换std::vector<T>为std::array<T, N>，我就会遇到分段冲突（请参阅https://gcc.godbolt.org/z/9srehdbhG）。

我的第一个想法是我违反了https://en.cppreference.com/w/cpp/algorithm/sort中列出的类型要求：

• RandomIt必须满足ValueSwappable和LegacyRandomAccessIterator的要求。
• 解除引用的类型必须满足MoveAssignable和MoveConstructibleRandomIt的要求。
• Compare必须满足Compare的要求。