小编and*_*eee的帖子

OpenMP之间的区别是什么:

#pragma omp parallel sections
{
    #pragma omp section
    {
       fct1();
    }
    #pragma omp section
    {
       fct2();
    }
}

并且:

#pragma omp parallel 
{
    #pragma omp single
    {
       #pragma omp task
       fct1();
       #pragma omp task
       fct2();
    }
}

我不确定第二个代码是否正确......

考虑以下代码片段：

bool foo(const std::string& s) {
    return s == "hello"; // comparing against a const char* literal
}

bool bar(const std::string& s) {
    return s == "hello"s; // comparing against a std::string literal
}

在乍一看，它看起来像比对并const char*需要更少的组装说明¹，作为使用字符串字面量会导致就地建设std::string。

（编辑：正如答案中指出的那样，我忘记了有效地s.compare(const char*)将被调用的事实foo()，因此在这种情况下当然不会进行就地构建。因此，请在下面删除一些行。）

但是，请operator==(const char*, const std::string&)参阅参考资料：

根据我的理解，这意味着我们将需要构造一个结构std::string来执行比较，因此我怀疑最终的开销将是相同的（尽管对的调用已将其隐藏了operator==）。

• 我应该选择哪个比较？
• 一个版本是否比另一个版本具有优势（可能在特定情况下）？

¹我知道更少的汇编指令并不一定意味着更快的代码，但是我不想在这里进行微基准测试。

这是我的代码:

class test{
    public:
    constexpr test(){

    }

    constexpr int operator+(const test& rhs){
        return 1;
    }
};



int main(){

    test t;                         //constexpr word isn't necessary
    constexpr int b = t+test();     // works at compile time!


    int w = 10;                     // ERROR constexpr required
    constexpr int c = w + 2;        // Requires w to be constexpr
    return 0;
}

我注意到即使我没有指定测试,它仍然有效constexpr.我尝试通过执行相同的方式复制结果,int但我得到错误.具体来说,它希望我的int w内心constexpr int c = w + 2;成为constexpr.从我第一次尝试使用test,它是否工作,因为我constexpr已经在构造函数上使用的原因？如果是这种情况,那么假设 …

考虑下面的MCVE，其中有两个值数组，其中w两次是两次v（在此处尝试）：

#include <valarray>

using namespace std;

int main() {
  valarray<int> v { 1, 2, 3 };

  for ([[maybe_unused]] auto x : v) {} // Ok

  auto w = v * 2;     // Leads to failure in loop below
  //valarray<int> w = v * 2; // Works
  //auto w = v*=2;      // Works
  //auto w = v; w *= 2; // Works

  for ([[maybe_unused]] auto x : w) {} // Failure here
}

这个例子在最后一个循环中用clang和gcc编译失败（这里是gcc输出）：

error: …

假设我们在类中有一个简单的getter方法，该方法返回const对std::string成员的引用：

const std::string& getString() const noexcept { return someString; }

随着std::string_viewC ++ 17 的问世，我想知道编写它是否具有任何优势：

const std::string_view getString() const noexcept { return someString; }

一种方法比另一种方法有优点/缺点吗？显然（如果我错了，请纠正我），两种解决方案肯定会比这更好：

const char* getString() const noexcept { return someString.c_str(); }

我已经看到了这个相关的问题，但是我要的是稍微不同的东西。

I need to display some relevant information in #error preprocessor directive. For example:

#define myConstant 5

#if myConstant > 10
    #error myConstant has to be > 10, now %d  //should display "5"
#endif

How can I do that?

考虑以下类别：

class Foo {
  int a, b;
public:
  Foo() : a{1}, b{2} {} // Default ctor with member initializer list
  //Foo() : a{1}, b{2} = default; // Does not work but why?
};

（编辑：因为在几个答案中都提到了-我知道班级成员的初始化方法，但这不是重点）

我认为第二个ctor定义会更优雅，更适合现代C ++代码（另请参阅为什么=default必须明确使用默认语义时使用）。但是，似乎没有通用的编译器接受它。而cppreference对此保持沉默。

我首先想到的是，成员初始化程序列表以某种方式更改了“默认语义”，如链接的FAQ中所述，因为它可能会也可能不会默认构造成员。但是对于类内初始化器，我们将遇到同样的问题，只是这里的Foo() = default;工作很好。

那么，为什么不允许呢？

在研究一些代码时，我遇到了下面一行的结构：

if (const auto& foo = std::get_if<MyType>(&bar)) // note the ampersand!

哪里bar是std::variant<MyType, OtherType>。这里的问题是，get_if 可能返回空指针，但我不明白该语句为什么起作用。

考虑以下类似的MCVE：

#include <iostream>

struct Foo { int a = 42; };

Foo* f() { return nullptr; }

int main() {
    const auto& foo = f();          // Returns a nullptr that binds to Foo*& - UB?
    //static_assert(std::is_same<decltype(foo), const Foo*&>::value); // -> Fails
    //const Foo*& bar = f(); // -> Fails

    if (foo)    std::cout << foo->a << std::endl;
    else        std::cout << "nullpointer" …

对于盖驱动腔（CFD）的Lattice Boltzmann模拟，我将立方域分解为（也是立方）8个子域，这些子域由8个等级独立计算。每个MPI等级都会为每个时间步生成一个VTK文件，并且由于我使用的是ParaView，因此我希望将整个内容可视化为一个多维数据集。更具体地说明我要实现的目标：

• 我有一个长度为8（每个方向的元素数）=> 8x8x8 = 512个元素的多维数据集。
• 每个维度分配给2个等级，即每个等级处理4x4x4 = 64个元素。
• 每个等级都会将结果写入lbm_out_<rank>.<timestep>.vtsVTK StructuredGrid格式的文件中。
• 我想生成一个.pvts文件，该*.vts文件收集文件并将包含子域的文件合并为一个文件，ParaView可以将其视为整个域。

不幸的是，我遇到了许多问题，因为我觉得ParaView和VTK的文档记录非常差，并且来自ParaView的错误消息完全没有用。

我有以下*.pvts文件，其中包括一个幽灵层和：

<?xml version="1.0"?>
<VTKFile type="PStructuredGrid" version="0.1" byte_order="LittleEndian">
    <PStructuredGrid WholeExtent="0 7 0 7 0 7 " GhostLevel="1">
        <PPoints>
            <PDataArray NumberOfComponents="3" type="Float32" />
        </PPoints>
        <Piece Extent="0 4 0 4 0 4" Source="lbm_out_0.0.vts"/>
        <Piece Extent="3 7 0 4 0 4" Source="lbm_out_1.0.vts"/>
        <Piece Extent="0 4 3 7 0 4" Source="lbm_out_2.0.vts"/>
        <Piece Extent="3 7 3 7 0 4" Source="lbm_out_3.0.vts"/>
        <Piece Extent="0 4 0 …

我有一个CMakePresets.json利用继承和宏扩展的文件。这是摘录，实际上我使用了“Foo”的多个版本：

{
 "configurePresets": [
        {
            "name": "default",
            "hidden": true,
            "generator": "Unix Makefiles",
            "binaryDir": "cmake-build-${presetName}",
            "environment": {
                "PATH":  "/opt/foo/$env{FOO_VERSION}/bin:$penv{PATH}",
                "LD_LIBRARY_PATH": "/opt/foo/$env{FOO_VERSION}.0/lib"
            },
            "cacheVariables": {
                "FOO_VERSION": "$env{FOO_VERSION}",
            }
        },
        {
            "name": "debug-foo1",
            "inherits": "default",
            "environment": { "FOO_VERSION": "1" }
        },
        {
            "name": "release-foo1",
            "inherits": "debug-foo1",
            "cacheVariables": { "CMAKE_BUILD_TYPE": "Release" }
        }
    ],
    "buildPresets": [
        {
            "name": "debug-foo1",
            "configurePreset": "debug-foo1"
        },
        {
            "name": "release-foo1",
            "configurePreset": "release-foo1"
        }
    ]
}

现在假设我选择预设release-foo1。这将呈现以下变量等：

• binaryDir = "cmake-build-release-foo1"
• FOO_VERSION = "1"
• LD_LIBRARY_PATH = "/opt/foo/1.0/lib" …