一、赋值
1.使拷贝赋值非virtual,以const& 传参,并返回非const的引用
2.使移动赋值非virtual,以&&传参,并返回非const的引用
// 拷贝赋值
vector& operator = (const vector& other);
// 移动赋值
vector& operator = (vector&& other); //C++17前
vector& operator = (vector&& other) noexcept; //C++17起
3.移动操作使用noexcept.一个noexcept声明的函数对编译器来说是个优化机会。
vector(vector&& other) noexcept; //C++17起
vector& operator = (vector&& other) noexcept; //C++17起
二、自赋值
1.使拷贝赋值对自赋值安全
2.使移动赋值对自赋值安全
自赋值安全意味着操作x=x不应该改变x的值
对于STL容器、std::string和内置类型,如int等,拷贝/移动赋值对于自赋值是安全的。自动生成的拷贝/移动赋值运算符对于自赋值也是安全的。使用自赋值安全的类型自动生成的拷贝/移动赋值运算符也是如此。
class Foo
{
std::string s;
int i;
public:
Foo& Foo::operator = (const Foo& a)
{
s = a.s;
i = a.i;
return *this;
}
Foo& Foo::operator = (Foo&& a) noexcept
{
s = std::move(a.s);
i = a.i;
return *this;
}
};
这种情况下,任何多余、高开销的自赋值检查都会不必要地让性能变差。
class Foo
{
std::string s;
int i;
public:
Foo& Foo::operator = (const Foo& a)
{
if (this == &a) return *this; //多余的自赋值检查
s = a.s;
i = a.i;
return *this;
}
Foo& Foo::operator = (Foo&& a) noexcept
{
if (this == &a) return *this; //多余的自赋值检查
s = std::move(a.s);
i = a.i;
return *this;
}
// ...
};
三、语义
1.拷贝操作应该进行拷贝
- 在拷贝之后(a = b),a和b必须相同(a == b)。
- 拷贝可深可浅。深拷贝意味着对象a和b之后是相互独立的(值语义)。浅拷贝意味着对象a和b之后共享一个对象(引用语义)。
2.移动操作应该进行移动,并使源对象处于有效状态。
- C++标准要求被移动的对象之后必须处于一个未指定但有效的状态。通常情况下,这个被移动的状态是移动操作源对象的默认状态。
3.多态类应当抑制公开的拷贝/移动操作
拷贝一个多态类的操作可能会以切片而告终。切片是C++中最黑暗的部分之一。
// 切片意味着你想在赋值或初始化过程中拷贝一个对象,但你只得到该对象的一部分。举例:
struct Base
{
int base{1998};
};
struct Derived : Base
{
int derived{2011};
};
void needB(Base b)
{
//...
}
int main()
{
Derived d;
Base b = d; //(1)
Base b2(d); //(2)
needB(d); //(3)
}
表达式1,2,3,效果都相同,d的Derived部分被删除了
现在,它已经十分危险了,当你拷贝一个多态类时,切片就会发生。
#include <iostream>
#include <string>
struct Base
{
virtual std::string getName() const
{
return "Base";
}
}
struct Derived : Base
{
std::string getName() const override
{
return "Derived";
}
}
int main()
{
std::cout << "\n";
Base b;
std::cout << "b.getName()" << b.getName() << "\n";
Derived d;
std::cout << "d.getName()" << d.getName() << "\n";
Base b1 = d;
std::cout << "b1.getName()" << b1.getName() << "\n";
Base& b2 = d;
std::cout << "b2.getName()" << b2.getName() << "\n";
Base* b3 = new Derived;
std::cout << "b3->getName()" << b3->getName() << "\n";
std::cout << "\n";
}
在拷贝的情况下,编译器使用了声明的类型,即静态类型。如果你使用了间接手段,如引用或指针,那么当前类型,即动态类型,会被使用。
4.若要对多态类型进行深拷贝,应使用虚函数clone,而不是公开的拷贝构造/赋值。