小编gnz*_*lbg的帖子

基于C++ 11范围的for循环取消引用迭代器.这是否意味着使用它没有意义boost::adaptors::indexed？例:

boost::counting_range numbers(10,20);
for(auto i : numbers | indexed(0)) {
  cout << "number = " i 
  /* << " | index = " << i.index() */ // i is an integer!
  << "\n";
}

我总是可以使用计数器,但我喜欢索引迭代器.

• 是否有可能以某种方式使用基于范围的for循环？
• 使用带索引的基于范围的循环的习惯用法是什么？(只是一个普通的柜台？)

当使用gcc和-Waggregate-return标志尝试以下示例时,警告:function call has aggregate value触发器:

struct Element {
// ... stuff ...
}

Container<Element> elements(10);
for_each(begin(elements),end(elements),[](Element& e){

// ... modify elements ...

});

据我所知,-Waggregate-return标志"警告,如果任何返回结构或联合的函数被定义或调用",因为,如果我理解正确,你可能会通过返回一个足够大的对象来溢出堆栈.

然而,for_each返回类型的拉姆达,其类型为void.为什么会触发警告？我错过了什么？我该如何改进我的代码？

我想做什么:我需要以块状形式存储单元格数据,即

*cell_member1 [cell0] .. cell_member1 [cellN] ... cell_memberM [cell0] .. cell_memberM [cellN]*

然后我需要有效地访问这些数据,如果可能的话,使用一个很好的语法.如果我能够轻松地定义要存储的数据,那将是很好的,即通过将成员定义为我想要存储的数据并将其传递给为我做一切的"魔术".

动机:为什么我需要这样做？缓存垃圾.在一些内部循环中,仅访问对象的一些成员.使用未使用的内存浪费一半缓存行不是我的应用程序的选项.我可以在指向某个顺序内存区域的对象中存储指针.这会浪费内存并迫使我在这个区域使用不同的语法.

我目前是怎么做的:我有一个容器:

template<class T> struct Container {
  char* data;
  Container(const int n) {
    data = new char[n*T::spaceRequirements()]; //< Data stored "block-wise"
    new(data) typename T::Flags[n]; //< Flags stored "cell-wise"
  }
  /// Destructor ommited for briefness.
};

我存储了T类型的一些单元格的数据.我需要每个单元格一些标记,现在我使用std :: bitset来存储它们,这意味着我需要以单元格形式存储这些位集:

*cell_member1 [cell0] ... cell_memberM [cell0] ... cell_member1 [cellN] .. cell_memberM [cellN]*

我在描述每个单元需要在下面的类中存储多少数据,这也提供了对数据的访问:

template<int nd> struct CellAccessor {
  /// Cell flags are stored cell-wise:
  typedef std::bitset<64> Flags; …

是否可以/可实现否定升压滤波适配器,例如

std::vector<int> v = {1, 2, 3, 4, 5};
for(auto i : v | !filtered(is_even))
    std::cout << i << std::endl; // prints 1,3,5

而不是在lambda表达式中做出否定？

动机:我使用过滤和lambda函数工作很多,但是当我不止一次使用过滤器时,我通常将它重构为自定义过滤器,例如

for(auto i : v | even) // note: my filters are more complex than even.
    std::cout << i << std::endl; // prints 2,4

现在,当我需要否定时,我正在为它们构建一个自定义过滤器,例如

for(auto i : v | not_even)
    std::cout << i << std::endl; // prints 1,2,3

但我会发现能够否定过滤器更好,例如

for(auto i : v | !even)
    std::cout << i << std::endl; // prints 1,2,3

在 Haskell 中，我不需要写任何东西来声明一个变量。在 C++ 中，我需要编写auto，据我所知，它的工作方式与 rust 的let.

• 使用let声明变量不是退后一步吗？：

  let hi = "hi";
  

  Run Code Online (Sandbox Code Playgroud)

• 类型推断和赋值运算符应该就足够了，不是吗？：

  hi = "hi";
  

  Run Code Online (Sandbox Code Playgroud)

我只是问，因为在浏览 Rust 的教程时引起我注意的第一件事是let's 无处不在。我觉得，我不应该需要打字！编译器已经知道我在声明一个变量！对于声明未初始化的变量，人们可能会争辩说用类型声明它们可能会很好。但同样，它是可选的，是风格问题。编译器可以在第一次使用时推断出类型，如果没有使用就不要编译，因此无法推断出类型。

• 强迫用户写 let背后的基本原理是什么？特别是，反对让 let 成为可选项的理由是什么？

最近我正在写我的getter和setter(注意:真正的类在getter/setter中做更多的事情):

struct A {
  const int& value() const { return value_; } // getter
        int& value()       { return value_; } // getter/setter
 private:
  int value_;
};

这允许我做以下事情:

auto a = A{2}; // non-const object a

// create copies by "default" (value always returns a ref!):
int b = a.value();  // b = 2, is a copy of value :)
auto c = a.value(); // c = 2, is a copy of value :)

// create references explicitly:
auto& d = …

我有一个自定义目标，我希望它依赖于默认目标（使用 构建的目标make）。

add_custom_target(foo ....)
add_dependency(foo default_target_name_goes_here)

默认目标的名称是什么？

我试过了ALL，ALL_BUILD，MyProjectsName，DEFAULT，...

在 CMake 文档中查找任何内容始终是一次不成功的冒险......

更新：看来 CMake 的设计方式使得修复/实现极其困难：自 2009 年以来 bugreport 获得+1。谁确实想要一个依赖于目标的自定义目标all？或者换句话说：谁曾经写作过make && make test？...

注意:如果在读完这个问题之后你会想,"怎么会发生这种情况",这没关系.如果你想保持开放的心态,那么在你可以遵循的问题后面有一些要点,这些要点表明了这种情况如何发生以及为什么这有用.请记住,这只是一个问题,而不是任何这些主题的教程.评论已经有足够的噪音,很难遵循.如果您对这些主题有疑问,如果您将其作为问题发布在SO而不是评论中,我将不胜感激.

问题:如果我有一个类型的对象int存储在指向的地址c

int* c = /* allocate int (returns unique address) */;
*c = 3;

由两个指针称为a和b:

int* a = /* create pointer to (*c) */;
int* b = /* create pointer to (*c) */;

这样:

assert(a != b);  // the pointers point to a different address
assert(*b == 3);
*a = 2;
assert(*b == 2);  // but they refer to the same value

这是未定义的行为吗？如果是,C++标准的哪一部分不允许这样做？如果没有,C++标准的哪些部分允许这样做？

注:记忆c点分配与返回一个唯一的地址(内存分配函数new,malloc …

设置：

我有一个使用 SIMD 内在函数的函数，并希望在一些 constexpr 函数中使用它。

为此，我需要使其成为 constexpr。但是，SIMD 内在函数没有标记为 constexpr，编译器的常量评估器无法处理它们。

我尝试用执行相同操作的 C++ constexpr 实现替换 SIMD 内在函数。该函数在运行时变慢了 3.5 倍，但我能够在编译时使用它（是吗？）。

问题：

如何在常量表达式中使用此函数而不会在运行时减慢程序速度？

一些想法：

• 为所有编译器添加对编译器常量表达式求值器的常量求值所有 SIMD 内在函数的支持：可能是正确的解决方案，但这是一项不可能完成的任务。

更务实的解决方案是：

• 重载函数取决于它是否在常量表达式中执行（即提供 constexpr 和非 constexpr 版本）。
• 或者，在 constexpr 和运行时实现之间的 constexpr 函数内以某种方式分支（即，在分支中检测函数是否在常量表达式内执行）。

无论如何，我愿意接受任何解决我问题的建议。

提示：

• @RMartinhoFernandes 在 Lounge 中建议使用__builtin_constant_p来检测函数参数是否都是常量表达式，在这种情况下，编译器希望至少尝试在编译时评估函数。

失败的尝试：

• @ Jarod42 提出了只使用两个独立函数的直接建议。我想简单地指出为什么这行不通，因为它不是微不足道的。该解决方案假设在调用站点知道函数是否会被 constexpr 评估。但这种情况并非如此。考虑一个调用我的函数的 constexpr 函数，它应该选择哪个版本的函数？它必须选择 constexpr 一个才能编译，但“外部” constexpr 函数仍然可以在运行时评估。在这种情况下，它将使用“慢”编译时实现，因此，这种方法不能解决问题。

我不时地需要迭代容器元素的一个子集,或者只想提取它们而忽略其余部分.我最终boost::range::adaptors::filtered用来创建这个懒惰的集合.

for(auto&& i : container | filtered(predicate)) {
  // .. do stuff
}

是否有理由在STL中缺少收集算法(如在Ruby的收集中)(我们只有copy_if不相同)？或者反对使用它的任何理由？

可能的实现可能是:

template<class Container, class Predicate>
Container collect(Container&& c, Predicate&& p) {
  Container n;
  for(auto&& i : c) {
    if(p(i)) {
      n.push_back(i);
    }
  }
  return n;
}

但是lazy_collect也可能有助于避免复制.

以下所有答案都很棒.我希望我可以标记所有这些.我不知道std::back_inserter.收集东西现在很简单:

boost::copy( orig | filtered(predicate), std::back_inserter(collection));