我正在回答一个问题并建议为大型类型返回按值,因为我相信编译器会执行返回值优化(RVO).但后来有人向我指出Visual Studio 2013没有在我的代码上执行RVO.
我在这里发现了一个关于Visual Studio无法执行RVO的问题,但在这种情况下,结论似乎是,如果真的很重要Visual Studio将执行RVO.在我的情况下它确实很重要,它对性能产生了重大影响,我已经通过分析结果证实了这一点.这是简化的代码:
#include <vector>
#include <numeric>
#include <iostream>
struct Foo {
std::vector<double> v;
Foo(std::vector<double> _v) : v(std::move(_v)) {}
};
Foo getBigFoo() {
std::vector<double> v(1000000);
std::iota(v.begin(), v.end(), 0); // Fill vector with non-trivial data
return Foo(std::move(v)); // Expecting RVO to happen here.
}
int main() {
std::cout << "Press any key to start test...";
std::cin.ignore();
for (int i = 0; i != 100; ++i) { …在C++11我们可以将对象的所有权转移到另一个unique_ptr使用std::move().所有权转移后,放弃所有权的智能指针变为null并get()返回nullptr.
std::unique_ptr<int> p1(new int(42));
std::unique_ptr<int> p2 = std::move(p1); // Transfer ownership
在将所有权转让给另一个所有权的情况下,这有什么用unique_ptr？
我在"A Tour of C++"中看到了以下函数,第12页:
int count_x(char const* p, char x)
{
int count = 0;
while (p)
{
if (*p == x) ++count;
++p;
}
return count;
}
这条线while (p)听起来不对我.我以为它应该是while (*p).但是,不想过于放肆,我用下面的代码测试了这个函数.
int main(int argc, char** argv)
{
char* p = argv[1];
char x = argv[2][0];
int count = count_x(p, x);
std::cout
<< "Number of occurences of "
<< x << " in " << p << ": " << count << std::endl;
return 0;
}
当我运行该程序时,它退出了 …
我有一个不可复制的类(即复制构造函数和赋值运算符被标记为'delete').我想将它们保存在std :: vector中.
它是一个RAII类,所以简单地存储指针或引用它不是我想要的.
我对新的初始化列表和移动构造函数的了解有限,这可能吗？
我试图理解移动语义和复制/移动省略.
我想要一个包含一些数据的类.我想在构造函数中传递数据,我想拥有数据.
看完这个,这个和这个给我的感觉是,在C++ 11,如果我想保存一个副本,然后从增加的代码大小的小问题,通过按值应至少与任何其他的选择,因为有效的(除).
然后,如果调用代码想要避免复制,则可以通过传递右值而不是左值.(例如使用std :: move)
所以我试了一下:
#include <iostream>
struct Data {
Data() { std::cout << " constructor\n";}
Data(const Data& data) { std::cout << " copy constructor\n";}
Data(Data&& data) { std::cout << " move constructor\n";}
};
struct DataWrapperWithMove {
Data data_;
DataWrapperWithMove(Data&& data) : data_(std::move(data)) { }
};
struct DataWrapperByValue {
Data data_;
DataWrapperByValue(Data data) : data_(std::move(data)) { }
};
Data
function_returning_data() {
Data d;
return d;
}
int main() {
std::cout << …在Scott Meyers的Effective C++中,第18项使接口易于正确使用且难以正确使用,他提到了null shared_ptr:
std::tr1::shared_ptr<Investment> pInv(static_cast<Investment*>(0), getRidOfInvestment)
和一个时尚分配操作
pInv = ... //make retVal point to the correct object
在这种情况下,可能需要创建一个null shared_ptr并稍后进行分配？为什么不在有资源(原始指针)时创建shared_ptr？
由于Scott Meyers没有在前面的例子中显示完整的赋值,我认为shared_ptr的assign运算符是重载的,可以这样做:
pInv = new Investment; // pInv will take charge of the pointer
// but meanwhile keep the delete function it already had
但我尝试使用boost的实现它不会这样工作.那么null shared_ptr是什么意思？
我几乎可以肯定我在这里遗漏了一些东西,有人帮我解决了.
PS.更多关于shared_ptr的初始化和赋值
#include <boost/shared_ptr.hpp>
int main(int argc, char *argv[])
{
boost::shared_ptr<int> ptr1(new int);
boost::shared_ptr<int> ptr2;
ptr2.reset(new int);
boost::shared_ptr<int> ptr3 = new int;
return 0;
}
这个例子不能由g ++(Ubuntu/Linaro …
例如,我有一个可以处理const T &和T &&值的函数:
template <typename T>
/* ... */ foo(const T &) {
std::cout << "const T & as arg" << std::endl;
}
template <typename T>
/* ... */ foo(T &&) {
std::cout << "T && as arg" << std::endl;
}
有没有办法可以编写单个函数,自动处理这两种类型？如:
template <typename T>
/* ... */ bar(T t) {
foo(t);
}
以便:
T a;
bar(a); // Handles as const T &
T b;
bar(std::move(b)); // Handles as T &&
谢谢!
我是一名物理学家,编写的程序涉及从高斯分布中生成几个(数十亿的数量级)随机数.我正在尝试使用C++ 11.这些随机数的生成由一个应该花费很少时间的操作分开.我最担心的是,如果我生成如此多的随机数,并且时间间隔很小,则可能导致性能欠佳.我正在测试某些统计属性,这些属性严重依赖于数字随机性的独立性,因此,我的结果对这些问题特别敏感.我的问题是,我在下面的代码中提到的数字类型(我的实际代码的简化版本),我做的事情显然(甚至是巧妙地)错了吗？
#include <random>
// Several other includes, etc.
int main () {
int dim_vec(400), nStats(1e8);
vector<double> vec1(dim_vec), vec2(dim_vec);
// Initialize the above vectors, which are order 1 numbers.
random_device rd;
mt19937 generator(rd());
double y(0.0);
double l(0.0);
for (int i(0);i<nStats;i++)
{
for (int j(0);j<dim_vec;j++)
{
normal_distribution<double> distribution(0.0,1/sqrt(vec1[j]));
l=distribution(generator);
y+=l*vec2[j];
}
cout << y << endl;
y=0.0;
}
}
我可能误解了explicit说明符.但是为什么以下代码编译？
struct A {
};
struct B : A {
};
struct C {
A* a_;
explicit C(A* a) : a_(a) { }
};
int main() {
B b;
C c(&b);
}
C调用基类构造函数,B*其中隐式向上转换为A*.我认为说明explicit符是为了防止隐式转换参数？
我问,因为我理解将说明explicit符添加到单个参数构造函数是一个好习惯,我想检查我的编译器是不是让我做了一些我不应该做的事情.
我正在按照本教程使用auto关键字和STL迭代器.
它说这种语法适用于C++ 11.
vector<int> vec;
auto itr = vec.iterator(); // instead of vector<int>::iterator itr
但是,当我尝试它时,我得到这个编译错误？
错误:无效使用'std :: vector :: iterator'