小编Edu*_*yan的帖子

我正在读Fedor Pikus 的这本书，他有一些非常非常有趣的例子，对我来说是一个惊喜。
特别是这个基准测试吸引了我，唯一的区别是在其中一个我们使用 || 在 if 和另一个中我们使用 |。

void BM_misspredict(benchmark::State& state)
{

    std::srand(1);
    const unsigned int N = 10000;;
    std::vector<unsigned long> v1(N), v2(N);
    std::vector<int> c1(N), c2(N);

    for (int i = 0; i < N; ++i) 
    {
        v1[i] = rand();
        v2[i] = rand();
        c1[i] = rand() & 0x1;
        c2[i] = !c1[i];
    }

    unsigned long* p1 = v1.data();
    unsigned long* p2 = v2.data();
    int* b1 = c1.data();
    int* b2 = c2.data();

    for (auto _ : state)
    {
        unsigned long a1 …

假设以下代码:

#include <iostream>
using namespace std;

namespace X
{
  class A{};

  void f(A a){}

  void g(int a){}
}

int main()
{
  X::A a;
  f(a);
  g(5);
}

编译代码时,会发生以下编译错误:

main.cpp:在函数'int main()'中:
main.cpp:error:'g'未在此范围内声明

所以函数f编译得很完美,但事实g并非如此.怎么样？它们都属于同一名称空间.编译器是否从类型的参数中推断出该函数f属于X命名空间X::A？在这种情况下编译器如何表现？

假设我有：

template<int... N>
class seq
{
};

template<int... N>
struct uniq{
    using type = seq<N...>;
};

我需要以某种方式使序列唯一，以便

std::is_same_v<uniq<1,2,2,2,3,3,3>::type, seq<1, 2, 3>>; 

最终是真的。换句话说，使序列唯一，然后创建一个 seq。
有没有办法在编译时实现这一点？

我正在阅读一篇非常棒的C++ 11教程,作者在解释final关键字的同时提供了这个例子:

struct B {
    virtual void f() const final;   // do not override
    virtual void g();
};
struct D : B {
    void f() const;     // error: D::f attempts to override final B::f
    void g();       // OK
};

那么在这里使用final关键字是否有意义？在我看来,你可以避免在virtual这里使用关键字,防止f()被覆盖.

最近我正在重读ISO C++标准,并发现了非常有趣的说明:

请注意,std::vector上式的唯一约束T的std::vector<T>是该类型T必须有拷贝构造函数.实际上,如果在插入时向量的内存已满,则分配一个新的内存size = 2 * oldSize(这是依赖于实现的),然后在其中复制旧元素并插入该元素.

可是等等？？

要分配类型的新内存,我们需要这样的东西, ptr = new T[2*size];

1. 如何做到这一点,因为类型T可能没有默认构造函数？
2. 然后分配,在分配内存之后我们必须将旧值分配给新内存,对吧？
3. 考虑到这两件事,如何std::vector用"仅复制构造器"来做到这一点？使用了哪些实现和语言习语？

我知道标题没有多大意义，但代码将解释我的问题。

template<typename T>
void foo(T...) {std::cout << 'A';}

template<typename... Ts>
void foo(Ts...) {std::cout << 'B';}

int main(){  
   foo(1); 
   foo(1,2);
}

在阅读续篇之前尝试猜测这个程序的输出：

所以输出是 AB

谁能解释为什么 1 个参数函数优先考虑省略号，而 2 个参数优先考虑可变参数模板？

这是一个用 实现的基本自旋锁std::atomic_flag。该书
的作者声称第二次可以提高性能。lock()

class Spinlock
{
    std::atomic_flag flag{};
public:
    void lock() {
        while (flag.test_and_set(std::memory_order_acquire)) {
            while (flag.test(std::memory_order_acquire)); //Spin here
        }
    }
    void unlock() {
        flag.clear(std::memory_order_release);
    }
};

test()我们在额外的内部循环中 使用的原因是性能：test()不会使缓存行无效，而test_and_set()会使。

有人可以详细解释一下这个报价吗？测试还是读操作，需要从内存中读取对吗？

根据我最喜欢的作者斯科特迈耶斯先生的说法,私人继承和组合意味着同样的事情,即Has-A关系.因此,可以通过私有继承获得从组合中获得的所有东西(包含A类,其中A类具有B类成员),反之亦然.

所以下面的代码应该是Has-A关系,但从我的观点来看,它不是!

class A : private boost::noncopyable {.. this is irrelevant };

任何人都可以告诉我,我失踪了吗？或者如何通过合成实现此代码？

有一次,我在读一个真棒C++ FAQ(这是真的好!)并阅读主题如何防止静态初始化命令"惨败".因此作者建议将静态变量包装到函数中,从而通过维护变量的创建顺序来防止"惨败".但在我看来,这是一个粗鲁的解决方法.所以我的问题是,是否有任何现代的,更多的模式导向的方法来防止这种"惨败",但将"静态东西"包装成函数???

我是 C++ 栖息地，致力于 C# 项目。
我遇到过以下情况。

我已经class MyClass并且希望避免任何 2 个 MyClass 类型的对象共享缓存行，即使我有一个数组或任何 MyClass 类型的顺序集合。
在 C++ 中，我们可以声明class alignas(hardware_destructive_interference_size) Myclass，这将确保任何 2 个对象永远不会共享缓存行。

C#中有等效的方法吗？