小编hg_*_*git的帖子

我不知道std::atomic变量,但是知道std::mutex标准提供的(奇怪的权利!); 然而有一件事引起了我的注意:标准提供了两种看似相同(对我而言)的原子类型,如下所示:

1. std::atomic<bool> 类型

2. std::atomic_flag 类型

它也以 - 的例子提到std::atomic_flag type-

std :: atomic_flag是一种原子布尔类型.与std :: atomic的所有特化不同,它保证是无锁的.与std :: atomic不同,std :: atomic_flag不提供加载或存储操作.

我不明白.std::atomic bool type不保证是无锁的吗？那它不是原子的还是什么？

那么两者之间有什么区别呢？我应该在何时使用哪种？

我的目标是在我的代码中检测Windows 10,它必须跨平台以及不同版本的Windows(至少7及以上版本)工作.Windows提供IsWindows10OrGreater()了解决此问题的方法,但是还有另一个问题,此功能在以前的Windows版本中不存在.

你会发现无数的博客和SO问题,以及明显的疯狂,像这样和getversion等功能返回一些不同的版本,而不是正确的版本.

例如在我的机器上 - 该方法IsWindows10OrGreater()无法编译(我将安装Win10 SDK),并IsWindowsVersionOrGreater()报告6为主要版本.

那么有一种理智的多版本方式我可以解决这个问题吗？

我正在努力学习async-await.在这段代码中 -

const myFun = () => {
    let state = false;

    setTimeout(() => {state = true}, 2000);

    return new Promise((resolve, reject) => {
        setTimeout(() => {
            if(state) {
                resolve('State is true');
            } else {
                reject('State is false');
            }
        }, 3000);
    });
}

const getResult = async () => {
    return await myFun();
}

console.log(getResult());

为什么我得到输出 -

Promise { <pending> }

而不是一些价值？getResult()功能等待myFun()功能不应该解决它的承诺值吗？

我编写了一个模板代码,它以仿函数作为参数,经过一些处理后,执行它.虽然其他人可能会传递该函数一个lambda,一个函数指针甚至一个std::function但它主要是为lambda(不是我禁止其他格式).我想问一下,我应该怎样拿这个lambda - 按价值？引用？或者是其他东西.

示例代码 -

#include <iostream>
#include <functional>
using namespace std;

template<typename Functor>
void f(Functor functor)
{
    functor();
}

void g()
{
    cout << "Calling from Function\n";
}

int main() 
{
    int n = 5;

    f([](){cout << "Calling from Temp Lambda\n";});

    f([&](){cout << "Calling from Capturing Temp Lambda\n"; ++n;});

    auto l = [](){cout << "Calling from stored Lambda\n";};
    f(l);

    std::function<void()> funcSTD = []() { cout << "Calling from std::Function\n"; };
    f(funcSTD);

    f(g);
}

在上面的代码中,我可以选择将它们中的任何一个 -

template<typename Functor> …

在下面的例子中,我试图通过在课堂上将其隐藏起来来隐藏using Employee::showEveryDept最后一个子Designer类Elayer-

#include <iostream>

class Employee {
private:
    char name[5] = "abcd";
    void allDept() { std::cout << "Woo"; }

public:
    void tellName() { std::cout << name << "\n"; }
    virtual void showEveryDept()
    {
        std::cout << "Employee can see every dept\n";
        allDept();
    }
};

class ELayer : public Employee {
private:
    using Employee::showEveryDept;

protected:
    ELayer() {}

public:
    using Employee::tellName;
};

class Designer : public ELayer {
private:
    char color = 'r';

public:
    void showOwnDept() { …

到目前为止,我一直在使用函数指针,就像c ++中的这种格式一样.我偶尔会有一些用途,我想知道在c ++ 11/14中还有其他什么作为替代方案.

#include <iostream>
using namespace std;

void sayHello();
void someFunction(void f());

int main() {

    someFunction(sayHello);
    return 0;
}
void sayHello(){
    std::cout<<"\n Hello World";
}
void someFunction(void f()){
    f();
} 

我确实看过这个问题,但是无法理解任何优于传统使用函数指针的优点.另外我想问一下,使用函数指针有什么不对(不推荐)的事情因为我从未见过有人使用它们.或任何其他替代礼物.

我与这些说明完全失望,因为我明白,当他们自己,他们做什么,但我发现时,他们互相用他们很难理解.例如,野外的一些代码包含 -

namespace{
static constexpr char const *Hello[] = { "HelloString", "WorldString"};
...
}

这甚至做了什么？

• 当你已经在匿名命名空间内时,为什么要使用static.并且内部静态是有意义的(除非你编写缺少命名空间的C),没有类 - 为什么？
• 为什么要使用constexpr - 这里没有理由使用它.会不会很简单const呢？
• 然后const *Hello对我没有意义.这里有什么不变的？字符串或指针*Hello？

最糟糕的是,它编译:/.当然它会编译,因为它们是有效的陈述,但它甚至意味着什么？

正如问题所说，我想确认计数排序算法是否是就地排序算法。

维基百科将就地算法描述为

在计算机科学中，就地算法（或拉丁语中的 in situ）是一种使用具有少量、恒定额外存储空间的数据结构来转换输入的算法。当算法执行时，输入通常会被输出覆盖。非就地算法有时被称为非就地或异地（或拉丁语中的异地）。

稳定的排序算法维护具有相同键（即值）的记录的相对顺序。也就是说，如果每当有两个记录 R 和 S 具有相同的键并且 R 在原始列表中出现在 S 之前，则排序算法是稳定的，在排序列表中 R 将出现在 S 之前。

以及下面的某处计数排序页面：

如上所述，计数排序不是就地算法；即使忽略计数数组，它也需要单独的输入和输出数组。

如果我们假设计数排序算法为：

countsort(){
    for i = 0 .... n  //where n is size of input array arr[]
        countArr[ arr[i] ] += 1
    //and then traverse countArr[] and rewrite arr[] with sorted values where value>0

那为什么这不是一个稳定且到位的排序呢？

假设输入由和由 字符key data表示，那么对于以下数据：numeralssatellite data

arr[] = { 1a,1b,1c,2z,5c,6c,7e,8q }  // keeping in mind only keys are sorted

这个算法不会遍历 1a 然后 1b …

喜欢这段代码:

#include <iostream>

enum class A {
    a,
    b
};

std::ostream& operator<<(std::ostream& os, A val)
{
        return os << val;
}


int main() {
    auto a = A::a;
    std::cout << a;
    return 0;
}

当我没有提供std::ostream& operator<<(std::ostream& os, A val)程序时没有编译因为A :: a没有任何功能可以使用<<.但是现在当我已经提供它时,它会在我的终端和ideone上产生垃圾,它会产生运行时错误(超出时间限制).

我有一个带有一些重载构造函数的类,没有默认的构造函数.重载的构造函数基本上做同样的事情,但在type提供的params 上有所不同.假设我的课程如下 -

struct info {
  int one;    // must be filled
  int two;    // can be empty
  int three;  // can be empty
}

class A {
    int a;
    double b;
    float c;
    info I;

  public:

    A(a,b,c,one) :
      a(a),
      b(b),
      c(c)
    {
        // some processing
        I.one = one;
        // some other processing
        ....
    }

    A(a,b,c,i) :
      a(a),
      b(b),
      c(c),
      I(i)
    {
        // some processing
        // some other processing
        ....
    }

}

处理和一些处理部分是重复的,并且略微依赖于经常编辑的某些路径,迫使我们对两个地方进行相同和相同的改变.

可以通过某种方式将其缩减为相同的构造函数吗？我希望能够使用构造函数委派做一些事情,但却无法想到一个聪明的方法来执行此操作:/