C++ day20 用动态内存开发类 （三）函数返回对象，指向对象的指针

我不是女神ヾ 2023-07-16 15:59 41阅读 0赞

文章目录

  • 返回对象
    • 1 按引用传递，效率高（首选；当返回调用对象 或 返回作为参数传入的对象）
      • 1.1 返回指向const对象的const引用
      • 1.2 返回指向非const对象的非const引用
        • 例子1：重载赋值运算符
        • 例子2：重载<<运算符
    • 2 按值传递，效率低，可有时候是唯一选择（次选，没法传引用才选）
      • 2.1 返回const对象（防止a + b = c;这种赋值语句通过编译，尽量选这个）
      • 2.2 返回非const对象（比如：重载算术运算符，不能返回const对象才选这个）
    • 总结（优先级：const引用 > 非const引用 > const对象 > 非const对象）
  • 指向对象的指针
    • 对象指针用法集锦
    • 外部对象，自动对象，动态对象以及他们的析构函数什么时候被调用
    • 定位new运算符（1 容易不小心覆盖内存处原有内容；2 创建在指定内存的对象的析构函数在delete该指定内存时竟不被调用）
      • 后创建先析构
      • But, 为啥我对定位new创建的对象delete，没报错，还成功调用了他们的析构函数？？？

返回对象

好好掰扯掰扯当普通函数或者成员函数需要返回对象时的几种情况

1 按引用传递，效率高（首选；当返回调用对象 或 返回作为参数传入的对象）

返回对象要调用复制构造函数，返回引用不需要，所以返回引用需要做的工作更少，效率自然更高

但是返回引用要求引用指向的对象在调用函数结束后还存在。这是很简单的道理。

1.1 返回指向const对象的const引用

因为参数本身是const引用，当然必须把返回值声明为const引用，否则报错。很简单。不能把const给非const

例子：
在这里插入图片描述
在这里插入图片描述

1.2 返回指向非const对象的非const引用

例子1：重载赋值运算符

  1. StringBad & StringBad::operator=(const StringBad & st)
  2. { 
  3.     //首先禁止源和目标对象是同一个对象的情况，用地址判断
  4.     if (this == &st)
  5.         return *this;
  6.     strLen = st.strLen;
  7.     delete [] str;
  8.     str = new char[strLen + 1];
  9.     std::strcpy(str, st.str);
  10.     return *this;
  11. }

返回的是指向调用对象（一个非const对象）的引用、

例子2：重载<<运算符

istream类的对象在函数执行结束后会被改变，所以是非const的

  1. std::istream & operator>>(std::istream & is, StringBad & st)
  2. { 
  3.     delete [] st.str;//释放目标对象的指针成员指向的地址，否则会内存泄漏
  4.     char temp[StringBad::CINLIM];//忘记StringBad::
  5.     if (is.get(temp, StringBad::CINLIM))
  6.         st = temp;
  7.     else
  8.         is.clear();//清除错误标记
  9.     eatline();//清空输入缓存
  10.     return is;
  11. }

2 按值传递，效率低，可有时候是唯一选择（次选，没法传引用才选）

返回对象本身要调用复制构造函数，返回引用不需要，但是有时候必须要接受返回对象的开销，因为别无选择。比如当需要返回函数中的局部对象时，只能按值返回，否则如果返回引用，函数结束后局部对象就释放了，引用指向nowhere。

一般，重载算术运算符必须返回对象本身。因为必须计算，得用一个临时对象保存计算后的值。

2.1 返回const对象（防止a + b = c;这种赋值语句通过编译，尽量选这个）

以前说过一次，当时觉得好牛逼，现在竟然全忘了

用矢量类举例，这里只写主程序，类声明和类定义代码看这篇文章

  1. //main.cpp
  2. #include <iostream>
  3. #include "vector.h"
  5. int main()
  6. { 
  7.     using std::cout;
  8.     using std::endl;
  9.     VECTOR::Vector v1 = VECTOR::Vector();//默认构造函数
  10.     VECTOR::Vector v2 = VECTOR::Vector(2.0, 0);//RECT模式
  11.     VECTOR::Vector v3 = VECTOR::Vector(0.0, 2.0, VECTOR::Vector::RECT);//POL模式
  12.     VECTOR::Vector v4(0.0, 1.0);
  14.     cout << "v1: " << v1 << endl;
  15.     cout << "v2: " << v2 << endl;
  16.     cout << "v3: " << v3 << endl;
  17.     cout << "v4: " << v4 << endl;
  19.     VECTOR::Vector v5 = v1 + v2;
  20.     cout << endl;
  21.     cout << "v1: " << v1 << endl;
  22.     cout << "v2: " << v2 << endl;
  23.     cout << "v5: " << v5 << endl;
  25.     v3 + v4 = v5;//这么奇怪的代码，顺利通过了编译
  26.     cout << endl;
  27.     cout << "v3: " << v3 << endl;
  28.     cout << "v4: " << v4 << endl;
  29.     cout << "v5: " << v5 << endl;
  30.     cout << "(v3 + v4 = v5).magval() = " << (v3 + v4 = v5).magval() << endl;
  31.     return 0;
  32. }

v3 + v4 = v5;
编译器会先计算v3 + v4,得到的结果存储在一个临时对象中，如果赋值表达式是v5 = v3 + v4; 那编译器就把匿名临时对象复制给v5（调用编译器自定义的复制构造函数，浅复制）。

现在表达式是 v3 + v4 = v5; 所以v5被复制给这个匿名临时对象，而临时对象的计算结果则丢了。(v3 + v4 = v5)就是这个临时对象。所以(v3 + v4 = v5).magval()是临时对象的幅值，即v5的幅值了

  1. v1: (x, y) = (0, 0)
  2. v2: (x, y) = (2, 0)
  3. v3: (x, y) = (0, 2)
  4. v4: (x, y) = (0, 1)
  6. v1: (x, y) = (0, 0)
  7. v2: (x, y) = (2, 0)
  8. v5: (x, y) = (2, 0)
  10. v3: (x, y) = (0, 2)
  11. v4: (x, y) = (0, 1)
  12. v5: (x, y) = (2, 0)
  13. (v3 + v4 = v5).magval() = 2

这是因为重载的加法运算符的返回类型是非const对象，下面会说

  1. Vector Vector::operator+(const Vector & v) const
  2. { 
  3.     //操作数顺序无法反转
  4.     return Vector(x + v.x, y + v.y);//直接按矩形模式计算，用构造函数生成一个对象返回，注意这里省略了this指针
  5. }

我改为返回const对象后（原型和定义前面都要加const哈），这句奇怪赋值立马藏不住了，编译器立刻报错

在这里插入图片描述

不是说你会编写那么奇怪的代码，而是怕你不小心把==写为=，从而意外得到这种表达式
在这里插入图片描述

2.2 返回非const对象（比如：重载算术运算符，不能返回const对象才选这个）

一般，重载算术运算符必须返回对象本身。因为必须计算，得用一个临时对象保存计算后的值。当然是非const的。
在这里插入图片描述
在这里插入图片描述

其他示例，之前矢量类的三个算术运算符，都用构造函数新建一个对象然后返回，返回时会调用复制构造函数

  1. Vector Vector::operator-(const Vector & v) const
  2. { 
  3.     //操作数顺序无法反转
  4.     return     Vector(x - v.x, y - v.y);
  5. }
  7. Vector Vector::operator-() const//方向取反，负号运算符
  8. { 
  9.     return Vector(-x, -y);//简洁版，但是这需要生成一个临时对象，然后复制出去，有点低效
  10. }
  12. Vector Vector::operator*(double n) const
  13. { 
  14.     //操作数顺序无法反转
  15.     return Vector(x * n, y * n);//简洁版
  16. }

总结（优先级：const引用 > 非const引用 > const对象 > 非const对象）

指向对象的指针

类声明头文件和类定义方法文件在这里

其中使用下标找最短字符串和字符最前字符串，但本文使用**指向对象的指针（动态对象）**实现，只需对原来主程序做一丢丢改动，很简单。但是原理概念还是要好好弄明白的。

  1. //main.cpp
  2. #include <iostream>
  3. #include "StringBad.h"
  4. void eatline();
  5. typedef unsigned int uint;
  6. const uint ARSIZE = 10;
  8. int main()
  9. { 
  10.     { 
  11.         using std::cout;
  12.         using std::cin;
  14.         cout << "starting an inner block\n";
  15.         StringBad sayings[ARSIZE];//默认构造函数
  16.         cout << "Enter up to " << ARSIZE << " sayings (empty line to quit):\n>>";//输入提示符，很棒棒
  17.         uint i;
  18.         for (i = 0; i < ARSIZE; ++i)
  19.         { 
  20.             if (!(cin >> sayings[i]) || sayings[i][0] == '\0')
  21.                 break;
  22.         }
  24.         if (i > 0)
  25.         { 
  26.             cout << "Here is the " << i << " sayings:\n";
  29.             StringBad * shortest = &sayings[0];//指向第一个对象，用复制构造函数初始化shortest指针指向一个已有的对象
  30.             StringBad * first = new StringBad(sayings[0]);//用new给对象分配内存初始化匿名对象，并初始化为已有对象
  32.             uint j;
  33.             for (j = 0; j < i; ++j)
  34.             { 
  35.                 cout << sayings[j][0] << ": " << sayings[j] << '\n';
  36.                 if (sayings[j] < *first)
  37.                     first = &sayings[j];
  38.                 if (sayings[j].length() < (*shortest).length())//我又错误地写成sayings[j].strLen < sayings[shortest].strLen
  39.                     shortest = &sayings[j];
  40.             }
  42.             cout << "The shortest saying: " << *shortest << '\n';
  43.             cout << "The first saying alphabetically: " << *first << '\n';
  45.             delete first;//记得删除
  46.         }
  47.         else
  48.             cout << "No sayings entered!\n";
  51.     }
  52.     std::cout << "Exiting the main() function\n";
  54.     return 0;
  55. }
  57. starting an inner block
  58. 1: default object created!
  59. 2: default object created!
  60. 3: default object created!
  61. 4: default object created!
  62. 5: default object created!
  63. 6: default object created!
  64. 7: default object created!
  65. 8: default object created!
  66. 9: default object created!
  67. 10: default object created!
  68. Enter up to  10 sayings (empty line to quit):
  69. >>dfsaf
  70. Enter friend function: operator>>
  71. fdgfe
  72. Enter friend function: operator>>
  73. dfd
  74. Enter friend function: operator>>
  75. hj
  76. Enter friend function: operator>>
  77. kuib
  78. Enter friend function: operator>>
  79. kl
  80. Enter friend function: operator>>
  81. bnmsdfsvfhrtyhser
  82. Enter friend function: operator>>
  83. 23
  84. Enter friend function: operator>>
  86. Enter friend function: operator>>
  87. Here is the 8 sayings:
  88. d: dfsaf
  89. f: fdgfe
  90. d: dfd
  91. h: hj
  92. k: kuib
  93. k: kl
  94. b: bnmsdfsvfhrtyhser
  95. 2: 23
  96. The shortest saying: hj
  97. The first saying alphabetically: 23
  98. "" object deleted! 9 objects left!
  99. "" object deleted! 8 objects left!
  100. "23" object deleted! 7 objects left!
  101. "bnmsdfsvfhrtyhser" object deleted! 6 objects left!
  102. "kl" object deleted! 5 objects left!
  103. "kuib" object deleted! 4 objects left!
  104. "hj" object deleted! 3 objects left!
  105. "dfd" object deleted! 2 objects left!
  106. "fdgfe" object deleted! 1 objects left!
  107. "dfsaf" object deleted! 0 objects left!
  108. Exiting the main() function

对象指针用法集锦

  1. StringBad * glamour;//声明指向类对象的指针，但不创建对象
  2. StringBad * first = &sayings[0];//调用复制构造函数创建匿名动态对象
  3. StringBad * favourite = new StringBad;//调用默认构造函数创建匿名动态对象
  4. StringBad * gleep = new StringBad(sayings[4]);//调用复制构造函数创建匿名动态对象，原型：StringBad(const StringBad &);
  5. StringBad * glop = new StringBad("my my my");//调用原型为StringBad(const char *);的构造函数

在这里插入图片描述

外部对象，自动对象，动态对象以及他们的析构函数什么时候被调用

就是把存储期，作用域的知识用在对象身上

  1. //main.cpp
  2. #include "StringBad.h"
  3.  StringBad ext;//外部对象,external object，默认构造函数
  5.  int main()
  6.  { 
  7.      StringBad * pd = new StringBad;//匿名动态对象，dynamic object.用默认构造函数
  8.      { 
  9.         StringBad aut;//automatic object，默认构造函数
  10.      }//调用aut的默认析构
  11.      delete pd;//调用动态对象*pd的默认析构函数
  13.      return 0;//main函数结束之前调用静态外部对象ext的默认析构函数
  14.  }
  16. 1: default object created!
  17. 2: default object created!
  18. 3: default object created!
  19. "" object deleted! 2 objects left!
  20. "" object deleted! 1 objects left!
  21. "" object deleted! 0 objects left!

在这里插入图片描述

定位new运算符（1 容易不小心覆盖内存处原有内容；2 创建在指定内存的对象的析构函数在delete该指定内存时竟不被调用）

定位new运算符可以指定分配内存的位置，本示例将他和常规new运算符对比，发现2个问题，如题

之前说过定位new，第一个问题我们早就知道，也可以解决；但是现在进一步加深，说说析构函数为啥不被调用，并且我们该怎么确保析构函数被调用——显式调用析构。

  1. //main.cpp
  2. #include <iostream>
  3. #include <string>
  4. #include <new>
  5. typedef unsigned int uint;
  6. const uint BUF = 512;
  8. class JustTesting{ 
  9. private:
  10.     std::string word;
  11.     uint num;
  12. public:
  13.     //参数全部是默认参数的内联构造函数，所以编译器无需自己生成默认构造函数了
  14.     JustTesting(const std::string & w = "JustTesting", uint n = 0)
  15.     { 
  16.         word = w;
  17.         num = n;
  18.         std::cout << w << " constructed!\n";
  19.     }
  20.     ~JustTesting()
  21.     { 
  22.         std::cout << word << " destroyed!\n";
  23.     }
  24.     void show() const
  25.     { 
  26.         std::cout << word << ", " << num << '\n';
  27.     }
  28. };
  30. int main()
  31. { 
  32.     char * buffer = new char[BUF];
  34.     JustTesting * p1, * p2;
  35.     p1 = new (buffer) JustTesting;
  36.     p2 = new JustTesting("Heap1", 20);
  37.     std::cout << "Memory addresses:\n";
  38.     std::cout << (void *)buffer << '\t' << p1 << '\t' << p2 << '\n';
  39.     std::cout << "Contents:\n";
  40.     std::cout << p1 << ": ";
  41.     p1->JustTesting::show();
  42.     std::cout << p2 << ": ";
  43.     p2->JustTesting::show();
  45.     std::cout << '\n';
  46.     JustTesting * p3, * p4;
  47.     p3 = new (buffer) JustTesting("Bad idea", 18);
  48.     p4 = new JustTesting("Heap2", 40);
  49.     std::cout << "Memory addresses:\n";
  50.     std::cout << (void *)buffer << '\t' << p3 << '\t' << p4 << '\n';
  51.     std::cout << "Contents:\n";
  52.     std::cout << p3 << ": ";
  53.     p3->JustTesting::show();
  54.     std::cout << p4 << ": ";
  55.     p4->JustTesting::show();
  57.     delete p2;
  58.     delete p4;
  59.     delete [] buffer;//释放了buffer指向的内存块，但是却并没有为该内存块的对象们比如p4调用析构函数
  61.     return 0;
  62. }

可以看到，p3对象的内容把p1的覆盖了，这是因为定位new两次分配同一个位置

  1. JustTesting constructed!
  2. Heap1 constructed!
  3. Memory addresses:
  4. 0x81a638        0x81a638        0x816c50
  5. Contents:
  6. 0x81a638: JustTesting, 0
  7. 0x816c50: Heap1, 20
  9. Bad idea constructed!
  10. Heap2 constructed!
  11. Memory addresses:
  12. 0x81a638        0x81a638        0x81a478
  13. Contents:
  14. 0x81a638: Bad idea, 18
  15. 0x81a478: Heap2, 40
  16. Heap1 destroyed!
  17. Heap2 destroyed!

要想不覆盖，就自己改一下定位new运算符后面圆括号的指针，加个偏移量，偏移量的大小可以用sizeof运算符计算：

  1. p3 = new (buffer + sizeof(JustTesting)) JustTesting("Bad idea", 18);//sizeof运算符可以用于自己定义的类诶！！
  3. JustTesting constructed!
  4. Heap1 constructed!
  5. Memory addresses:
  6. 0xaea638        0xaea638        0xae6c50
  7. Contents:
  8. 0xaea638: JustTesting, 0
  9. 0xae6c50: Heap1, 20
  11. Bad idea constructed!
  12. Heap2 constructed!
  13. Memory addresses:
  14. 0xaea638        0xaea654        0xaea478
  15. Contents:
  16. 0xaea654: Bad idea, 18
  17. 0xaea478: Heap2, 40
  18. Heap1 destroyed!
  19. Heap2 destroyed!

那现在聚焦于第二个问题，为啥对象p3的析构函数没被调用，p1就不管了，毕竟被p3覆盖了，已经没了

这是因为和delete搭配的是常规new，不是定位new，所以程序中我们没有delete p2, delete p4,这会导致运行阶段错误（可是后面我试了，并没有任何错误？？？）

正确的办法是显式在程序中自己调用析构函数

  1. p1->~JustTesting();
  2. delete p2;
  3. p3->~JustTesting();
  4. delete p4;

成功

  1. JustTesting destroyed!
  2. Heap1 destroyed!
  3. Bad idea destroyed!
  4. Heap2 destroyed!

后创建先析构

但是我这么做还不够正确，必须要把后创建的对象先析构（后创建先析构），因为后创建的对象有可能会依赖先创建的一些对象，如果按照先创建先析构的顺序，也许会出现错误（这里后来者没有依赖于先来者，所以没出错）

  1. delete p4;
  2. p3->~JustTesting();
  3. delete p2;
  4. p1->~JustTesting();
  6. Heap2 destroyed!
  7. Bad idea destroyed!
  8. Heap1 destroyed!
  9. JustTesting destroyed!

But, 为啥我对定位new创建的对象delete，没报错，还成功调用了他们的析构函数？？？

生活处处有惊喜

本来想写成这样看看报什么错误，结果没报错没警告，也没有运行时异常，一切完美，甚至还调用了定位new创建的对象的析构函数！！！

？？？

一脸懵逼

  1. //main.cpp
  2. #include <iostream>
  3. #include <string>
  4. #include <new>
  5. typedef unsigned int uint;
  6. const uint BUF = 512;
  8. class JustTesting{ 
  9. private:
  10.     std::string word;
  11.     uint num;
  12. public:
  13.     //参数全部是默认参数的内联构造函数，所以编译器无需自己生成默认构造函数了
  14.     JustTesting(const std::string & w = "JustTesting", uint n = 0)
  15.     { 
  16.         word = w;
  17.         num = n;
  18.         std::cout << w << " constructed!\n";
  19.     }
  20.     ~JustTesting()
  21.     { 
  22.         std::cout << word << " destroyed!\n";
  23.     }
  24.     void show() const
  25.     { 
  26.         std::cout << word << ", " << num << '\n';
  27.     }
  28. };
  30. int main()
  31. { 
  32.     char * buffer = new char[BUF];
  34.     JustTesting * p1, * p2;
  35.     p1 = new (buffer) JustTesting;
  36.     p2 = new JustTesting("Heap1", 20);
  37.     std::cout << "Memory addresses:\n";
  38.     std::cout << (void *)buffer << '\t' << p1 << '\t' << p2 << '\n';
  39.     std::cout << "Contents:\n";
  40.     std::cout << p1 << ": ";
  41.     p1->JustTesting::show();
  42.     std::cout << p2 << ": ";
  43.     p2->JustTesting::show();
  45.     std::cout << '\n';
  46.     JustTesting * p3, * p4;
  47.     p3 = new (buffer + sizeof(JustTesting)) JustTesting("Bad idea", 18);
  48.     p4 = new JustTesting("Heap2", 40);
  49.     std::cout << "Memory addresses:\n";
  50.     std::cout << (void *)buffer << '\t' << p3 << '\t' << p4 << '\n';
  51.     std::cout << "Contents:\n";
  52.     std::cout << p3 << ": ";
  53.     p3->JustTesting::show();
  54.     std::cout << p4 << ": ";
  55.     p4->JustTesting::show();
  56.     std::cout << '\n';
  58.     //后创建先析构
  59.     delete p4;
  60.     delete p3;
  61.     delete p2;
  62.     delete p1;
  63.     delete [] buffer;
  65.     return 0;
  66. }
  68. JustTesting constructed!
  69. Heap1 constructed!
  70. Memory addresses:
  71. 0x76a638        0x76a638        0x766c50
  72. Contents:
  73. 0x76a638: JustTesting, 0
  74. 0x766c50: Heap1, 20
  76. Bad idea constructed!
  77. Heap2 constructed!
  78. Memory addresses:
  79. 0x76a638        0x76a654        0x76a478
  80. Contents:
  81. 0x76a654: Bad idea, 18
  82. 0x76a478: Heap2, 40
  84. Heap2 destroyed!
  85. Bad idea destroyed!
  86. Heap1 destroyed!
  87. JustTesting destroyed!

我猜想大概是因为buffer的地址也是new分配的，所以也是堆内存，所以可以和delete搭配，没有出错。但是这个猜想立刻被证明是错误的：

因为我把char * buffer = new char[BUF];换为

  1. char temp[BUF];
  2. char * buffer = temp;

这样buffer指向的就不是堆内存，而是栈内存，但是结果还是完美无瑕，？？？

至今仍是迷雾重重，不得其解

发表评论

表情：
评论列表 （有 0 条评论，41人围观）

还没有评论，来说两句吧...

相关阅读

    相关 指向类成员/函数的指针

    C++扩展了指针在类中的使用,使其可以指向类成员,这种行为是类层面的,而不是对象层面的。 指向类成员/函数的指针的本质并不是取地址.而是利用了对象地址的偏移量 我们创建了一

    谁践踏了优雅谁践踏了优雅/ 0 赞/ 306 阅读