小编mat*_*ort的帖子

如果我理解的临时的寿命正确的规则,因为临时的寿命这段代码应该是安全的stringstream在make_string()持续,直到完全表达的结束.我不是100%有信心这里没有一个微妙的问题,任何人都可以确认这种使用模式是否安全吗？它似乎在clang和gcc中运行良好.

#include <iomanip>
#include <iostream>
#include <sstream>

using namespace std;

ostringstream& make_string_impl(ostringstream&& s) { return s; }

template<typename T, typename... Ts>
ostringstream& make_string_impl(ostringstream&& s, T&& t, Ts&&... ts) {
    s << t;
    return make_string_impl(std::move(s), std::forward<Ts>(ts)...);
}

template<typename... Ts>
string make_string(Ts&&... ts) {
    return make_string_impl(ostringstream{}, std::forward<Ts>(ts)...).str();
}

int main() {
    cout << make_string("Hello, ", 5, " World!", '\n', 10.0, "\n0x", hex, 15, "\n");
}

我正在观看Jonathan Blow 关于游戏新编程语言的视频,其中他讨论了游戏编程中他称之为"联合分配"的常见模式.这个想法是当你有一个具有动态分配数组的成员的类时(可能std::vector因为它们是固定大小,更像是建议的std::dynarray)你预分配足够的内存来存储所有数组数据并只执行一次分配所有数组都足够大,而不是每个数组都有一个数组.

他建议对这种模式提供直接语言支持,让我想知道C++标准是否允许实现以这种方式合并分配？令我感到震惊的是,这需要编译器的一些英雄努力才能实际实现为优化,但我没有看到原因无法完成的明显原因.有谁知道在标准下是否允许这样做,或者即使已经有实现在实践中进行这种优化的实现？

我有两组(std :: set from <set>),我想知道它的大小.我可以使用std :: set_intersection <algorithm>,但我必须提供一个输出迭代器来将交集复制到其他容器中.

一种直截了当的方式

  set<int> s1{1,2,3,4,5};
  set<int> s2{4,5,6,7,8,9,0,1};

  vector<int> v;

  set_intersection(
      s1.begin(), s1.end(), s2.begin(), s2.end(),
      inserter(v, v.begin()));

之后v.size()给出了交集的大小.但是,即使我们不对它进行任何操作,也必须存储交集.

为了避免这种情况,我试图实现一个虚拟输出迭代器类,它只计算,但它不分配:

template<typename T>
class CountingOutputIterator {
 private:
  int* counter_;
  T dummy_;
 public:
  explicit CountingOutputIterator(int* counter) :counter_(counter) {}
  T& operator*() {return dummy_;}
  CountingOutputIterator& operator++() { // ++t
    (*counter_)++;
    return *this;
  }
  CountingOutputIterator operator++(int) { // t++
    CountingOutputIterator ret(*this);
    (*counter_)++;
    return ret;
  }
  bool operator==(const CountingOutputIterator& c) {
    return counter_ == c.counter_; // same pointer …

下面的代码编译并按照我想要的方式使用clang和gcc,但在Visual Studio 2015 RTM中出错.我认为clang和gcc是正确的,但我不确定.这段代码应该编译吗？

#include <iostream>
#include <type_traits>
#include <utility>

template <typename T, size_t N, typename IS = decltype(std::make_index_sequence<N>{})>
struct Vector {
    T e_[N];
};

template <typename T, typename U, size_t N, size_t... Is>
constexpr auto operator+(const Vector<T, N, std::index_sequence<Is...>>& x,
                         const Vector<U, N>& y) {
    using V = std::common_type_t<T, U>;
    return Vector<V, N>{x.e_[Is] + y.e_[Is]...};
}

int main() {
    const auto v0 = Vector<float, 4>{1, 2, 3, 4};
    const auto v1 = Vector<float, 4>{5, 6, 7, 8};
    const auto …

我有一个class Foo我需要初始化对另一个类的引用的地方,但首先我需要从另一个类获得一些引用接口.

这只是一个虚拟代码,可以更好地解释我的两个问题:

class Foo
{
public:
  Foo();
  ~Foo();
private:
  int m_number;
  OtherClass& m_foo;
};

Foo::Foo() :
  m_number(10)
{
  // I really need to do this get's
  Class1& c1 = Singleton::getC1();
  Class2& c2 = c1.getC2();
  Class3& c3 = c2.getC3();

  //How can I put the m_foo initialization in the initialization list?
  m_foo(c3);
}

问题是:

1 -在初始化我的成员之前,我需要检索上面的所有引用m_foo.但我想初始化m_foo初始化列表.如果没有一条线,那么最好的方法是什么.有什么办法吗？

2 -通过上面的代码,我得到错误:

error: uninitialized reference member 'OtherClass::m_foo' [-fpermissive]

因为我正在初始化括号,因为它将在初始化列表中完成.我怎样才能m_foo正确初始化？