[c++] 面向对象课程（二）-- 带指针类的设计

class with pointer menbers

string_test.cpp

 1 #include "string.h"

 2 #include <iostream>

 3

 4 using namespace std;

 5

 6 int main()

 7 {

 8   String s1("hello");

 9   String s2("world");

10

11   String s3(s2);

12   cout << s3 << endl;

13

14   s3 = s1;

15   cout << s3 << endl;

16   cout << s2 << endl;

17   cout << s1 << endl;

18 }

string.h

 1 #ifndef __MYSTRING__

 2 #define __MYSTRING__

 3

 4 class String

 5 {

 6 public:

 7    String(const char* cstr=0);

 8    String(const String& str);

 9    String& operator=(const String& str);

10    ~String();

11    char* get_c_str() const { return m_data; }

12 private:

13    char* m_data;

14 };

15

16 #include <cstring>

17

18 inline

19 String::String(const char* cstr)

20 {

21    if (cstr) {

22       m_data = new char[strlen(cstr)+1];

23       strcpy(m_data, cstr);

24    }

25    else {

26       m_data = new char[1];

27       *m_data = '\0';

28    }

29 }

30

31 inline

32 String::~String()

33 {

34    delete[] m_data;

35 }

36

37 inline

38 String& String::operator=(const String& str)

39 {

40    if (this == &str)

41       return *this;

42

43    delete[] m_data;

44    m_data = new char[ strlen(str.m_data) + 1 ];

45    strcpy(m_data, str.m_data);

46    return *this;

47 }

48

49 inline

50 String::String(const String& str)

51 {

52    m_data = new char[ strlen(str.m_data) + 1 ];

53    strcpy(m_data, str.m_data);

54 }

55

56 #include <iostream>

57 using namespace std;

58

59 ostream& operator<<(ostream& os, const String& str)

60 {

61    os << str.get_c_str();

62    return os;

63 }

64

65 #endif

注意的点

string_test.cpp：11拷贝构造，14拷贝赋值
string.h：8拷贝构造（构造函数接受自己），9拷贝赋值，10析构函数
不知道将来要创建的对象多大，所以只放一根指针，再动态创建空间放对象
类中带指针，要关注三个特殊函数（Big Three）
结束符号“\0”判断字符串结束
21判断是否空指针
22：new:，动态分配一块内存
31-35：delete，析构函数，防止内存泄露，变量离开作用域时自动调用
11的get_c_str()是为了配合输出函数

拷贝构造（copy ctor）

String a("Hello"); String b("World"); b = a;
如果没有构造拷贝，会发生b和a的指针都指向“Hello”，“World”没有指针指向，导致内存泄露
而且a、b一个改动会影响另一个，别名在编程中是危险的事
这种拷贝方式称为“浅拷贝”，是编译器的默认版本
copy ctor 实现“深拷贝”，创建足够的新空间存放蓝本
String s2(s1); 与 String s2 = s1; 效果相同

拷贝赋值（copy op =）

String s1("hello"); String s2(s1); s2 = s1;
过程：43删除左值--44开辟新空间--45拷贝右值
40-41：检测自我赋值（self assignment），来源端和目的端是否相同
这步的意义不只是提高效率，不这样写会出错
因为43会把原空间删掉，导致45行复制的时候访问空指针

栈（stack）和堆（heap）

{Complex c1(1,2);}
{Complex* p = new Complex(3);
delete p;}
stack：存在于某作用域（scope）的一块内存空间，调用函数时，函数本身即形成一个stack用来防止它接受的参数，以及返回地址，离开作用域后，析构函数被自动调用（aoto object）
heap：system heap，操作系统提供的一块global内存空间，程序可以动态分配（dynamic allocated）从中获得若干区域，使用完后需手动释放空间
{static Complex c1(1,2);}
静态对象，离开作用域后对象仍存在，组用域是整个程序
全局对象，写在任何作用域之外（全局作用域之中），也可看做一种静态对象
new：先分配memory，再调用ctor，分解为以下三个函数
void* mem = operator new(sizeof(Complex)); // 分配内存，operator new调用malloc(n)
p = static_cast<Complex*>(mem); // 转型
p->Complex::Complex(1,2); // 构造函数，Complex::Complex(pc,1,2);
delete：先调用析构函数，再释放内存
String::~String(p); // 把字符串里面动态分配的内存删掉（字符串本身只是指针m_data）
operator delete(p); // 内部调用free(p)，删掉字符串本身的指针

new到底分配多少内存

调试模式下加上debug header 32byte，正常模式下中间为数据（一根指针4byte），上下为cookies 2*4byte，凑够16的倍数
动态分配所得的array
new []：array new
delete[]：array delete
array new 一定要搭配 array delete
String* p = new String[3]; delete[] p; // 唤起3次dtor
String* p = new String[3]; delete p; // 唤起1次dtor，另外2个指针指向的动态内存数据无法删除（注意指针是可以删除的）
虽然new complex的时候不会产生此问题，但也要注意搭配使用，养成好习惯

参考：

const在函数前面与后面的区别

https://blog.csdn.net/qq_25800311/article/details/83054129

巴特西

[c++] 面向对象课程（二）-- 带指针类的设计

最新文章

热门文章