小编Pre*_*rag的帖子

这是一个例子:

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

void f1(double& ret) {
   ret=5.;
}

void f2(double* ret) {
   *ret=5.;
}

int main() {
   double ret=0.;
   thread t1(f1, ret);
   t1.join();
   cout << "ret=" << ret << endl;
   thread t2(f2, &ret);
   t2.join();
   cout << "ret=" << ret << endl;   
}

输出是:

ret=0
ret=5

用gcc 4.5.2编译,有和没有-O2标志.

这是预期的行为吗？

这个节目数据是否免费比赛？

谢谢

当我尝试编译这个简单的程序时:

#include<thread>

void f() {
  std::this_thread::sleep_for(std::chrono::seconds(3));
}

int main() {
  std::thread t(f);
  t.join();
}

在Ubuntu 10.04(32位)上使用gcc版本4.4.3:

$ g++ -std=c++0x -pthread a.cpp -o a

我明白了:

error: ‘sleep_for’ is not a member of ‘std::this_thread’

我看着标题'线程'.
sleep_for()受_GLIBCXX_USE_NANOSLEEP保护

#ifdef _GLIBCXX_USE_NANOSLEEP
...
/// sleep_for
template<typename _Rep, typename _Period>
  inline void
  sleep_for(const chrono::duration<_Rep, _Period>& __rtime)
...

为什么_GLIBCXX_USE_NANOSLEEP没有定义？
如何编译这个例子？

2012年9月17日更新(jogojapan):今天我使用GCC 4.7.1遇到了同样的问题.我想知道是否有关于如何避免它的消息,除了定义_GLIBCXX_USE_NANOSLEEP.我尝试过使用-std=gnu11,但无济于事.

GCC 4.4还有一个旧的未解决的错误报告:https://bugs.launchpad.net/ubuntu/+source/gcc-4.4/+bug/608145

2012年10月19日更新(jogojapan):现在,Jonathan Wakely已经解决并解决了这个问题,作为这个问题的答案:_GLIBCXX_USE_NANOSLEEP到底是什么？ 这对于自己构建GCC而不是使用现成包的任何人来说尤为重要.

如果有人能告诉我为什么编译这个程序,我真的很感激:

double data[123456789];  
int main() {}

比这个编译要长10倍:

int main() {
    double* data=new double[123456789];
}

两者都编译时:

$ g++ -O0

并且可执行文件的大小几乎相同.

我在Ubuntu 10.04上使用gcc 4.4.3.

谢谢.

有人可以解释为什么这两个专业化对编译器来说难以区分(gcc 4.5.1 @ ideone)

http://ideone.com/9tNux

template <typename... T> struct S;

template<typename A, typename B, typename... C>
struct S<A, B, C...> {
   int f() {return 1;}
};

template<typename... A, typename... C>
struct S< S<A...>, C...> {
   int f() {return 2;}
};

当我尝试实例化 S<S<a, b>, a, b> o2;编译器抱怨时:

prog.cpp:20:21: error: ambiguous class template instantiation for 'struct S<S<a, b>, a, b>'
prog.cpp:6:22: error: candidates are: struct S<A, B, C ...>
prog.cpp:11:33: error:                 struct S<S<A ...>, C ...>
prog.cpp:20:21: error: aggregate 'S<S<a, b>, …

是否可以在运行时决定调用哪个模板函数？就像是:

template<int I>
struct A {
    static void foo() {/*...*/}
};

void bar(int i) {
    A<i>::f();   // <-- ???
}

有人可以std::this_thread::yield()在c ++应用程序中提供真实的使用示例吗？

程序:

#include<vector>

int main() {
    std::vector<int>::size_type size=3;
    std::vector<int> v{size};
}

编译时

g++ (Ubuntu/Linaro 4.6.3-1ubuntu5) 4.6.3

生成错误:

ppp.cpp: In function ‘int main()’:
ppp.cpp:5:28: error: narrowing conversion of ‘size’ from ‘std::vector<int>::size_type {aka long unsigned int}’ to ‘int’ inside { } [-fpermissive]
ppp.cpp:5:28: error: narrowing conversion of ‘size’ from ‘std::vector<int>::size_type {aka long unsigned int}’ to ‘int’ inside { } [-fpermissive]

在http://www.cplusplus.com/reference/stl/vector/vector/上写了

explicit vector ( size_type n, const T& value= T(), const Allocator& = Allocator() );

我期望使用构造函数.

有人可以解释一下吗？

是否可以使用可变数量的参数构造函数调用(内部函数模板),具体取决于模板参数的数量？就像是:

void f(int i) {}
void f(int i1, int i2){}
void f(int i1, int i2, int i3){}
...

template<typename... T>
void caller() {
   f(/* sizeof...(T) number of arguments; of form T_i::value */);
}

由于没有解决这个问题的一部分,我将它作为一个单独的问题:

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

void f2(double* ret) {
   *ret=5.;
}

int main() {
   double ret=0.;
   thread t2(f2, &ret);
   t2.join();
   cout << "ret=" << ret << endl;   
}

这个节目数据是否免费比赛？
对于新的C++内存模型,是否有任何保证可以同步ret从线程t2和线程访问变量main？

我的意思是,如果程序在同一个核心上执行,很明显访问t2和main不会发生冲突.
但是,如果t2和main在不同内核上执行？
在main继续执行之前,是否有任何保证核心缓存会同步？

如果有人能提供相同的参考资料我会很感激.

谢谢.

是否有可能将最后3个元素投射 std::array<double, 4> 到 std::array<double, 3>？

例如:

void f(std::array<double,3> &);
...
int main() {
    std::array<double,4> a;
    ...
    f(/* pass a[1], a[2] and a[3] */);
}

编辑:

上下文:有几个由不同函数(不同的f() - s)计算的晶格自旋(点)属性.这些函数应该填充数组的不同部分.(数组不能是结构,因为数字元素依赖于编译时参数.)那些f() - s被调用数百万次.