当前位置：首页 > news >正文

C++拷贝和移动

news 来源：原创 2024/9/22 13:31:15

一、赋值

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，而不是公开的拷贝构造/赋值。