• C++右值引用赋值语句的探索

    本文主要对右值引用的赋值语句的移动过程进行了探索，看看C++能不能自动帮我们处理好对象的“移动 ”操作。

    实验一：对包含向量的类进行移动赋值

    1. class Ref final
    2. {
    3. public:
    4.     std::vector<int> m_data;
    5.  
    6.     std::string to_string() {
    7.         std::stringstream ss;
    8.         for (auto v: m_data) {
    9.             ss << v << ", ";
    10.         }
    11.         return ss.str();
    12.     }
    13. };
    14.  
    15.  
    16. void test_move_ref() {
    17.     new_section(__FUNCTION__, "");
    18.  
    19.     Ref o;
    20.     Ref n;
    21.  
    22.     o.m_data = std::vector<int>{1, 2, 3};
    23.  
    24.     cout << "Ref before move: " << endl;
    25.     cout << "   o: " << o.to_string() << endl;
    26.     cout << "   n: " << n.to_string() << endl;
    27.  
    28.     n = std::move(o);
    29.     cout << "Ref after move: " << endl;
    30.     cout << "   o: " << o.to_string() << endl;
    31.     cout << "   n: " << n.to_string() << endl;
    32. }

    类 Ref 只包含了一个数组，通过 std::move，试图将 o 的数据，转移给 n，得到的日志输出为 

    Ref before move:
       o: 1, 2, 3,
       n:
    Ref after move:
       o:
       n: 1, 2, 3,

    从结果来看，是完美做到了数据的移动的。 

    实验二：对级联包含向量的类进行移动赋值

    1. class Cover final {
    2. public:
    3.     Ref m_ref;
    4.  
    5.     std::string to_string() {
    6.         std::stringstream ss;
    7.         ss << "cover(" << m_ref.to_string() << "), ";
    8.         return ss.str();
    9.     }
    10. };
    11.  
    12. void test_move_cover() {
    13.     new_section(__FUNCTION__, "");
    14.  
    15.     Cover o;
    16.     Cover n;
    17.  
    18.     o.m_ref.m_data = std::vector<int>{1, 2, 3};
    19.  
    20.     cout << "Cover before move: " << endl;
    21.     cout << "   o: " << o.to_string() << endl;
    22.     cout << "   n: " << n.to_string() << endl;
    23.  
    24.     n = std::move(o);
    25.     cout << "Cover after move: " << endl;
    26.     cout << "   o: " << o.to_string() << endl;
    27.     cout << "   n: " << n.to_string() << endl;
    28. }

    类 Cover 只包含了一个 Ref，通过 std::move，试图将 o 的数据，转移给 n，得到的日志输出为 

    Cover before move:
       o: cover(1, 2, 3, ),
       n: cover(),
    Cover after move:
       o: cover(),
       n: cover(1, 2, 3, ),

     从结果来看，即使是在 Ref 外再包装一层，只要没有额外的成员，也是可以完美做到数据的移动的。 

    实验三：对包含向量和值的类进行移动赋值

    1. class Mix final
    2. {
    3. public:
    4.     std::vector<int> m_data;
    5.     int m_index{0};
    6.  
    7.     std::string to_string() {
    8.         std::stringstream ss;
    9.         for (auto v: m_data) {
    10.             ss << v << ", ";
    11.         }
    12.         ss << ": " << m_index;
    13.         return ss.str();
    14.     }
    15. };
    16.  
    17. void test_move_mix() {
    18.     new_section(__FUNCTION__, "");
    19.  
    20.     Mix o;
    21.     Mix n;
    22.  
    23.     o.m_data = std::vector<int>{1, 2, 3};
    24.     o.m_index = 5;
    25.  
    26.     cout << "Mix before move: " << endl;
    27.     cout << "   o: " << o.to_string() << endl;
    28.     cout << "   n: " << n.to_string() << endl;
    29.  
    30.     n = std::move(o);
    31.     cout << "Mix after move: " << endl;
    32.     cout << "   o: " << o.to_string() << endl;
    33.     cout << "   n: " << n.to_string() << endl;
    34. }

    类 Mix 包含了一个数组，还有一个数值类型成员。通过 std::move，试图将 o 的数据，转移给 n，得到的日志输出为 

    Mix before move:
       o: 1, 2, 3, : 5
       n: : 0
    Mix after move:
       o: : 5
       n: 1, 2, 3, : 5

     从结果来看，数组这部分数据，是完美做到数据的移动的，然而数值类型成员，仅仅做到了拷贝。 

    实验四：对包含向量和指针的类进行移动赋值

    1. class MixAddr final
    2. {
    3. public:
    4.     std::vector<int> m_data;
    5.     std::vector<int>* m_dynamic{nullptr};
    6.  
    7.     std::string to_string() {
    8.         std::stringstream ss;
    9.         for (auto v: m_data) {
    10.             ss << v << ", ";
    11.         }
    12.         ss << ": ";
    13.         if (nullptr == m_dynamic) {
    14.             ss << "nullptr";
    15.         } else {
    16.             ss << m_dynamic << "(";
    17.             for (auto v: *m_dynamic) {
    18.                 ss << v << ", ";
    19.             }
    20.             ss << ")";
    21.         }
    22.         return ss.str();
    23.     }
    24.     ~MixAddr() {
    25.         if (nullptr != m_dynamic) {
    26.             // // deleting m_dynamic will cause program crash
    27.             // //   because 'n = std::move(o)' only copy m_dynamic,
    28.             // //   but only one instance of std::vector is created,
    29.             // //   so 'delete m_dynamic' will be executed twice,
    30.             // //   this will trigger program crash
    31.             // delete m_dynamic;
    32.             m_dynamic = nullptr;
    33.         }
    34.     }
    35. };
    36.  
    37. void test_move_mixaddr() {
    38.     new_section(__FUNCTION__, "");
    39.  
    40.     MixAddr o;
    41.     MixAddr n;
    42.  
    43.     o.m_data = std::vector<int>{1, 2, 3};
    44.     o.m_dynamic = new std::vector<int>{5, 6, 7};
    45.  
    46.     cout << "MixAddr before move: " << endl;
    47.     cout << "   o: " << o.to_string() << endl;
    48.     cout << "   n: " << n.to_string() << endl;
    49.  
    50.     n = std::move(o);
    51.     cout << "MixAddr after move: " << endl;
    52.     cout << "   o: " << o.to_string() << endl;
    53.     cout << "   n: " << n.to_string() << endl;
    54. }

    类 MixAddr 包含了一个数组，还有一个数组指针。通过 std::move，试图将 o 的数据，转移给 n，得到的日志输出为 

    MixAddr before move:
       o: 1, 2, 3, : 0000024984E42370(5, 6, 7, )
       n: : nullptr
    MixAddr after move:
       o: 1, 2, 3, : 0000024984E42370(5, 6, 7, )
       n: 1, 2, 3, : 0000024984E42370(5, 6, 7, )
     

     从结果来看，数组这部分数据没有移动，而是拷贝的；指针也是同样，仅仅做到了拷贝。

    实验五：对级联包含向量和指针的类进行移动赋值

    1. class Head final {
    2. public:
    3.     Ref m_ref;
    4.     Ref* m_dynamic{nullptr};
    5.  
    6.     std::string to_string() {
    7.         std::stringstream ss;
    8.         ss << "head(" << m_ref.to_string() << "), ";
    9.         if (nullptr == m_dynamic) {
    10.             ss << "nullptr";
    11.         } else {
    12.             ss << m_dynamic << "(" << m_dynamic->to_string() << ")";
    13.         }
    14.         return ss.str();
    15.     }
    16.     ~Head() {
    17.         if (nullptr == m_dynamic) {
    18.             // // this should cause program crash like MixAddr, but not.
    19.             // //   why? maybe latency of cleanup ?
    20.             delete m_dynamic;
    21.             m_dynamic = nullptr;
    22.         }
    23.     }
    24. };
    25.  
    26. void test_move_head() {
    27.     new_section(__FUNCTION__, "");
    28.  
    29.     Head o;
    30.     Head n;
    31.  
    32.     o.m_ref.m_data = std::vector<int>{1, 2, 3};
    33.     o.m_dynamic = new Ref{};
    34.     o.m_dynamic->m_data = std::vector<int>{4, 5, 6};
    35.  
    36.     cout << "Head before move: " << endl;
    37.     cout << "   o: " << o.to_string() << endl;
    38.     cout << "   n: " << n.to_string() << endl;
    39.  
    40.     n = std::move(o);
    41.     cout << "Head after move: " << endl;
    42.     cout << "   o: " << o.to_string() << endl;
    43.     cout << "   n: " << n.to_string() << endl;
    44. }

    类 Head 包含了一个 Ref，还有一个 Ref 指针。通过 std::move，试图将 o 的数据，转移给 n，得到的日志输出为 

    Head before move:
       o: head(1, 2, 3, ), 0000024984E42250(4, 5, 6, )
       n: head(), nullptr
    Head after move:
       o: head(1, 2, 3, ), 0000024984E42250(4, 5, 6, )
       n: head(1, 2, 3, ), 0000024984E42250(4, 5, 6, )

     从结果来看，实验结果与实验四一致，Ref 数据没有移动，而是拷贝的；Ref 指针也是同样，仅仅做到了拷贝。

    小结

    通过实验来看，只包含对象（非指针引用）的类，应该可以不用定义 operator= (Ref&&)，即可完成数据的转移 。

    不过对于工程实践来讲，如果每个类都需要去分析他包含的成员变量再考虑移动的情况，那么代码的可读性和可维护性就比较差了。

    综上，如果希望支持移动赋值方式，将数据转移，那么最好明确、完整的定义 operator=(Ref&&) ，至于构造函数 Ref(Ref&&)，有空可能会再来一个实验做起来。

    另外，本文只进行了对比实现，分析了现象，但是并未对原理和原因做深入探究，有兴趣的朋友欢迎在评论区分享一下，共同学习。

    本文的所有示例，已同步到 Github，欢迎拉下来做测试和扩展实验。

    如果对C++创建实例有兴趣，可以看看之前的另一篇文章：C++对象实例创建实验_DAVIED9的博客-CSDN博客

  • 相关阅读:
    全网最详细的自动化测试（Jenkins 篇）
    在 Linux 程序中使用 breakpad
    【萌新解题】斐波那契数列
    最全的各版本PostGis下载
    javaweb学习（一）：jsp
    Word处理控件Aspose.Words功能演示：在 Python 中将 Word 文档拆分为多个文件
    基于若依ruoyi-nbcio支持flowable流程增加自定义业务表单（一）
    sipp3.6多方案压测脚本
    企业安全—培训
    Download Quartz持久化数据库下载地址
  • 原文地址：https://blog.csdn.net/davied9/article/details/128167889