C++ class with pointer member(s)

• 正如标题所示：这篇复习带有指针类型成员的class

设计类

考虑到会有以下操作，来设计类

 {
     String s1();
     String s2("hello");
     String s3(s1);
     cout << s3 << endl;
     s3 = s2;
     cout << s3 << endl;
 }

函数体内第二行和第三行都是构造函数，一个含参数，一个不含参数。第四行创建一个以s1为初值的对象s3,是一个拷贝的动作，需要一个拷贝构造函数，之后会讲到；下一行是输出，需要一个操作符重载。第六行是一个赋值的操作，是一个拷贝的动作，这样第四行和第六行都是拷贝动作，所以这两个操作需要的是不同的函数，第六行需要的是拷贝赋值操作。如果，我们自己不写，编译器会给出默认的这两个操作函数，像上个复数的例子，就使用编译器给的，而这个string的例子，使用默认的就会出现不好的，想象一下，我们现在有个指针对象，指向一个地址，现在又创建一个新的对象，若只是拷贝，把指针拷贝过来，指向了同一个地方去，这并不是真正的拷贝，所以，只要class中含有带指针的成员，就不要使用默认的拷贝构造函数和拷贝赋值操作。so,string类的大致设计如下：

 class String {
 public:
     String(const char* cstr = );//construct func
     //if only the calss with pointer pamater(s),we need design two functions as follow
     String(const String& str);//copy construct func,the parameter type is itsown type
     String& operator=(const String& str);//copy assign,the parameter is itsown type

     ~String();
     char* get_c_str()const { return m_data; }
 private:
     char* m_data;//因为字符串长度不定，所以设置成动态的数组-指针
 };

设计类内函数

构造函数和析构函数

 inline
 String::String(const char* cstr = )
 {
     if (cstr) {//有初值
         m_data = new char[strlen(cstr + )];
         strcpy(m_data, cstr);
     }
     else {
         m_data = new char[];
         *m_data = '\0';
     }
 }

 inline
 String::~String()
 {
     delete[] m_data;//clean up
 }

使用上述函数

{
String s1();
    String s2("hello");
    String* p = new String("hello");
    delete p;//离开前，释放掉
}

前面两个，离开时会自动释放掉，也是调用析构函数，所以上述函数作用域内离开时会调用三次析构函数

先前的复数类，不需要清理，因为它们本来就要死亡了，所以不必要，但是，这里是动态分配内存，如果不释放的，就是内存泄漏了。so ,Note:如果class中含指针成员，多半要动态分配内存，那么对象死亡之前，就是析构函数调用时，将动态分配的内存释放掉

拷贝构造函数和拷贝赋值操作

class with pointer member(s)，一定要这样做,看下面的图片（来源于侯捷老师的课件）

首先，看第一种情况（第二幅图），使用default copy construct function，对象的data是指针，至于指针中的内容（‘hello’）是不属于这个指针的，在做copy动作的时候，b也也只是指针，所以两个指针指向同一块内容了。虽然a和b 也有相同内容了，但是b中内容，没有指针指向它了，而此处‘hello‘’所在的内存块，有两个指针同时指向它了，将来若改变a，b指向的内容也会被改变。，着就是浅拷贝；与之对应的就是深拷贝，就是我们自己写的函数要做的操作.下面看看什么是深拷贝

//copy construct fuction
inline
String::String(const String& str)
{
    m_data = new char[strlen(str.m_data) + ];
    strcpy(m_data, str.m_data);
}

使用：

 String s3(s1);

这里s3也是新创建出来的对象，就要调用构造函数，先开辟足够的空间，然后将要拷贝的内容拷贝进来，这就是深拷贝，如果使用编译器默认的拷贝构造函数，只是把指针拷贝过来

拷贝赋值操作操作

要把右边的东西赋值给左边（Note：左右都有东西），正常思路就是先把左边清空，然后创建出与右边一样大的空间，再将右边内容拷贝给左边，so，实现如下：

inline
String& String::operator=(const String& str)
{
    if (this == &str)//self assignment or not
        return *this;
    delete[] m_data;//kill
    m_data = new char[strlen(str.m_data) + ];
    strcpy(m_data, str.m_data);
    return *this;
}
//使用
String s4=s1;

output 函数

#include <iostream>
#include "string.h"

using namespace std;
ostream& operator<<(ostream& os, const String& str)
{
    os << str.get_c_str();
    return os;
}
//使用

String s1("Hello");
cout<<s1;

output 函数，必须为全域函数，这样才能保证是左边调用“<<”

总结

下面，我们回顾一下String 类的设计，设计一个class，首先，我们考虑class中需要什么样的数据，这里是字符串，我们字符串中会存放很多字符，当然，我们很容易想到使用数组存放，但是，对于设计字符串却不是一个好的选择，因为，数组声明时必须要指定数组大小，所以，我们选择指针，将来放多大的内容，使用new的方式动态分配大小，在32位系统中，一个指针占4个byte,所以不管字符串多大，字符串这个对象本身就是4byte；Then,考虑设计哪些函数，构造函数，前面讲过了，这里不多讲；上面讲过了，因为成员是指针，所以需要设计拷贝构造函数、拷贝赋值操作函数，析构函数（Big Three），设计完这三个函数后，再思考还需要设计哪些函数，由于，我们需要输出字符串，即需要cout,,所以，我们需要取出m_data中的字符，cout是可以接收这种东西的，所以，设计  char* get_c_str() const {return m_data;} ,只是返回，不改变，所以设计成const型的。

下面是完整的String类的设计的头文件

 #pragma once
 #ifndef __STRING__
 #define __STRING__
 #include <cstring>
 class String {
 public:
     String(const char* cstr = );//construct func
     //if only the calss with pointer pamater(s),we need design two functions as follow
     String(const String& str);//copy construct func,the parameter type is itsown type
     String& operator=(const String& str);//copy assign,the parameter is itsown type

     ~String();
     char* get_c_str()const { return m_data; }
 private:
     char* m_data;//因为字符串长度不定，所以设置成动态的数组-指针
 };

 inline
 String::String(const char* cstr = )
 {
     if (cstr) {//有初值
         m_data = new char[strlen(cstr + )];
         strcpy(m_data, cstr);
     }
     else {
         m_data = new char[];
         *m_data = '\0';
     }
 }

 inline
 String::~String()
 {
     delete[] m_data;//clean up
 }
 //copy construct fuction
 inline
 String::String(const String& str)
 {
     m_data = new char[strlen(str.m_data) + ];
     strcpy(m_data, str.m_data);
 }

 inline
 String& String::operator=(const String& str)//String&:& is reference
 {
     if (this == &str)//self assignment or not,&str:& is getting address
         return *this;
     delete[] m_data;//kill
     m_data = new char[strlen(str.m_data) + ];
     strcpy(m_data, str.m_data);
     return *this;
 }
 #endif