我刚刚听完了Scott Meyers关于C++ 0x的软件工程电台播客采访.大多数新功能对我来说都很有意义,我现在对C++ 0x感到兴奋,除了一个.我仍然没有得到移动语义 ......它们究竟是什么？
有什么理由喜欢static_cast<>超过C风格的演员吗？它们是等价的吗？他们有什么速度差异吗？
我目前正在学习有关所有c ++ 11/14功能的信息，并想知道何时在函数调用中使用std :: move。
我知道在返回局部变量时不应该使用它，因为这会破坏返回值的优化，但是我真的不明白在函数调用中将值转换为rvalue真正有帮助。
我在C++ 11中阅读了一篇关于移动语义的精彩文章.本文以非常直观的方式编写.下面给出了本文中的示例类.
class ArrayWrapper
{
public:
// default constructor produces a moderately sized array
ArrayWrapper ()
: _p_vals( new int[ 64 ] )
, _metadata( 64, "ArrayWrapper" )
{}
ArrayWrapper (int n)
: _p_vals( new int[ n ] )
, _metadata( n, "ArrayWrapper" )
{}
// move constructor
ArrayWrapper (ArrayWrapper&& other)
: _p_vals( other._p_vals )
, _metadata( other._metadata )
{
other._p_vals = NULL;
}
// copy constructor
ArrayWrapper (const ArrayWrapper& other)
: _p_vals( new int[ other._metadata.getSize() …考虑以下程序:
struct list_wrapper
{
std::vector<int> m_list;
};
int main()
{
std::vector<int> myList { 1, 1, 2, 3, 5 };
const std::vector<int>::iterator iter = myList.begin();
list_wrapper wrappedList;
wrappedList.m_list = std::move(myList);
// Can I still dereference iter?
return 0;
}
在调用之后std::move(myList),iter现在指向内部的有效项wrappedList.m_list,或者移动构造函数/赋值使所有迭代器无效？
在下面的代码中,如何为函数main中的对象A分配rvalue？
#include <iostream>
using namespace std;
class A
{
public:
int* x;
A(int arg) : x(new int(arg)) { cout << "ctor" << endl;}
A(const A& RVal) {
x = new int(*RVal.x);
cout << "copy ctor" << endl;
}
A(A&& RVal) {
this->x = new int(*RVal.x);
cout << "move ctor" << endl;
}
~A()
{
delete x;
}
};
int main()
{
A a(8);
A b = a;
A&& c = A(4); // it does not call move ctor? why?
cin.ignore(); …示例 A 中使用的移动语义是否必要，哪个结构更好？
示例 A：
struct A
{
std::string a;
A( std::string a ) : a( std::move(a) ){ }
};
示例 B：
struct B
{
std::string b;
B( const std::string& b ) : b( b ){ }
};
我不相信这是一个重复的问题。我特别询问从在类构造函数中使用成员初始化的角度来看，哪个示例更好。另一个问题中列出的示例或答案均未涉及成员初始化。
我不喜欢使用引用参数调用构造函数，然后将其复制到成员中。似乎有多个复制操作可能很浪费。
我想尽可能有效地将数据“管道”到成员中，但我不想将右值作为构造函数参数。
我有一个引用std::vector<char>，希望将其用作接受函数的参数std::vector<unsigned char>。我可以不复制就做吗？
我有以下功能，它可以工作；但是我不确定是否真的要进行复制-有人可以帮我理解吗？是否std::move可以避免复制或是否尚未复制？
static void showDataBlock(bool usefold, bool usecolor,
std::vector<char> &chunkdata)
{
char* buf = chunkdata.data();
unsigned char* membuf = reinterpret_cast<unsigned char*>(buf);
std::vector<unsigned char> vec(membuf, membuf + chunkdata.size());
showDataBlock(usefold, usecolor, vec);
}
我以为我可以写：
std::vector<unsigned char> vec(std::move(membuf),
std::move(membuf) + chunkdata.size());
这是过度杀伤力吗？实际发生了什么？
此代码按预期工作(在线处).最后v是空的,w因为它已经窃取了内容,所以不是空的v.
vector<int> v;
v.push_back(1);
cout << "v.size(): " << v.size() << endl;
auto vp = move(v);
vector<int> w(vp);
cout << "w.size(): " << w.size() << endl;
cout << "v.size(): " << v.size() << endl;
但是,如果我取代auto vp=move(v)用
vector<int> && vp = move (v);
然后它不动.相反,它复制,两个向量最后都是非空的.如图所示这里.
澄清:更具体地说,什么是自动衍生类型vp？如果不是vector<int> &&,那还有什么呢？为什么这两个例子虽然如此相似但却给出了不同的结果？
额外:我也试过这个,它仍然复制而不是移动
std :: remove_reference< vector<int> > :: type && vp = move(v);
是否有任何案例或具体示例我们需要指针来完成这项工作？即可以在不使用指针的情况下完成需要指针的事情吗？我们可以将指针作为函数参数发送,但可以使用返回的数据完成.我们可以使用指针来更改函数中的多个变量,但也有一个解决方法.
我们真的需要指针吗？
我知道这是一个愚蠢的问题,对不起,但在这种情况下对我来说似乎是正确的我只是想知道是否有一些我们用指针做不到的事情.