【C++】侯捷：C++面向对象笔记03-带有指针的类：String

傷城~ 2023-09-27 08:47 123阅读 0赞

## 带有指针的类-String ##

防卫式定义

#ifndef _MYSTRING_
    #define _MYSTRING_
    
    # endif

测试程序：

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

编译器给的那一套拷贝赋值与拷贝构造函数，仅仅是一个bit一个bit的拷贝，而对于带有指针的类而言，很显然，这样的构造是不满足使用场景的。

### class with pointer members必须有copy ctor和copy op= ###

![在这里插入图片描述][e6ca94b701e84831ab807b4452d6367e.png_pic_center]

### Big Three，三个特殊函数 ###

class String{
        public:
        	String(const char* cstr = 0);
        	String(const String& str);#拷贝构造函数
        	String& operator=(const String& str);#拷贝赋值函数
        	~String();#析构函数
        	char* get_c_str() const {return m_data;}
        private:
        	char* m_data;
    };

#### 析构函数 ####

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

如果让编译器自己写的拷贝构造和拷贝赋值函数，就会发生以上情况，最终造成内存泄露。

#### 拷贝构造函数(copy ctor) ####

inline #直接取另一个object的private数据（兄弟之间互为友元）
    String::String(const String& str)
    {
    m_data = new char[ strlen(str.m_data) + 1 ];
    strcpy(m_data, str.m_data);
    }
    
    {
    String s1("hello ");
    String s2(s1);
    // String s2 = s1;
    }

#### 拷贝赋值函数（copy assignment operator） ####

先把原来的数据清空，分配一块相同大小的内存，赋值。

inline
    String& String::operator=(const String& str)
    {
    if (this == &str)
    return *this;#注意这里的操作
        
    delete[] m_data;
    m_data = new char[ strlen(str.m_data) + 1 ];
    strcpy(m_data, str.m_data);
    return *this;
    }

**一定要在operator=中检查是否有self assignment（自我赋值）**

output函数

#include <iostream.h>
    ostream& operator<<(ostream& os, const String& str)
    {
    os << str.get_c_str();
    return os;
    }
    2-4
    {
    String s1("hello ");
    cout << s1;
    }

## stack 和 heap ##

stack：是存在于某作用于（scope）的一块内存空间。两个\{\}里面就形成一个stack，假如你调用函数，函数本身即会形成一个stack用来防止它所接受的参数，以及返回地址。

在函数本体内声明的任何变量，其所使用的内存块都取自上述stack。

heap：是指由操作系统提供的一块global内存空间，程序可动态分配从其中获得的若干区块。

动态取得指的是new一块内存。

动态获得的内存（堆里获得的），自己就有责任去释放掉这一块内存。

栈里获得的内存，可以由系统自动的去处理。

#### stack objects 的生命期 ####

...
    {
    Complex c1(1,2);
    }

c1便是所谓的stack object，其生命在作用域结束之后结束。这种作用域内的对象，又被称为auto object，因为它会被自动清理。

#### static local objects 的生命期 ####

class Complex { … };
    ...
    {
    static Complex c2(1,2);
    }

c2便是所谓的static object，其生命在作用域结束之后仍然存在，直到整个程序结束。

#### global objects 的生命期 ####

class Complex { … };
    ...
    Complex c3(1,2);
    int main()
    {
    ...
    }

c3 便是所谓的global object，其生命在整个程序后才結束。你也可以把它视为一种static object，其作用域是「整个程序」。

内存泄漏：自己动态申请获取的内存，由于某种原因失去了对该块内存的控制，最终无法将该块内存交还给操作系统，就造成了内存泄漏（借了东西忘了还）。

## new：先分配内存，再调用ctor. ##

![在这里插入图片描述][72dc8a5ab31e4a93ad0d5b19a669a502.png_pic_center]  
第一步获取内存，底层调用malloc，第二步进行转存，第三步调用对应对象的构造函数进行赋值。

## delete：先调用dtor再释放memory。 ##

![在这里插入图片描述][e94c23fe86f343f5971cce5e9aba6f45.png_pic_center]

### Static ###

静态函数与普通函数的区别：静态函数没有this指针。

静态函数应该单独去处理静态数据。

调用static函数的两种方式：通过类去调用 通过class name去调用。

通过一行代码使得某个变量获得内存，叫定义，而没有获得定义叫声明。

类模板：

template<typename T>
    class complex{
    	public:
    		complex(T r = 0, T i = 0):re(r),im(i){
    		}
    	complex& operator += (const complex&);
    	T real () const {return re;}
    	T imag () const {return im;}
    	private:
    		T re,im;
    };

用的时候：

{
    	complex<double> c1(2.5,1.2);
    	complex<int> c2(2,6);
    }

函数模板：

template<class T>
    inline const T& min(const T& a,const T& b){
    	return b<a?b:a;
    }

用的时候可以直接用，不用指定任何类型

关于namespace

using directive

#include <stdio.h>
    #include <vector>
    #include <iostream>
    
    using namespace std;
    
    int main() {
    	cout<<"1"<<endl;
    	return 0;
    }

using declaration

#include <iostream>
    
    using std::cout;
    
    int main() {
    	int a;
    	std::cin>>a;
    	cout<<"1"<<endl;
    	return 0;
    }

不展开：

#include <iostream>
    
    using std::cout;
    
    int main() {
    	std::cout<<"1"<<std::endl;
    	return 0;
    }

[e6ca94b701e84831ab807b4452d6367e.png_pic_center]: https://img-blog.csdnimg.cn/e6ca94b701e84831ab807b4452d6367e.png#pic_center
[72dc8a5ab31e4a93ad0d5b19a669a502.png_pic_center]: https://img-blog.csdnimg.cn/72dc8a5ab31e4a93ad0d5b19a669a502.png#pic_center
[e94c23fe86f343f5971cce5e9aba6f45.png_pic_center]: https://img-blog.csdnimg.cn/e94c23fe86f343f5971cce5e9aba6f45.png#pic_center