C++快速讲解（八）：智能指针、动态内存、宏、枚举以及异常

前言：主要介绍智能指针、动态内存、宏、枚举、以及异常的处理。

---

1.智能指针

一般指针存在的问题：

• 野指针：指针声明而未初始化，此时指针的将会随机指向。内存已经被释放、但是指针仍然指向它。这时内存有可能被系统重新分配给程序使用，从而会导致无法估计的错误
• 重复释放：程序试图释放已经释放过的内存，或者释放已经被重新分配过的内存，就会导致重复释放错误.
• 内存泄漏：不再使用的内存，并没有释放，或者忘记释放，导致内存没有得到回收利用。 忘记调用delete

1.1 unique_ptr

unique_ptr 是一个独享所有权的智能指针，它提供了严格意义上的所有权。也就是只有这个指针能够访问这片空间，不允许拷贝，但是允许移动（转让所有权）。

#include <iostream>
#include <memory>

using namespace std;

int main() {

    //创建一个unique_ptr对象，包装一个int类型指针
    unique_ptr<int> p1(new int (10));

    //无法进行拷贝，编译错误
//    unique_ptr<int> p2 = p1;
    cout<<*p1<<endl;

    //可以移动指针到p3. 则p1不再拥有指针的控制权 p3 现在是唯一指针
    unique_ptr<int> p3 = move(p1) ;
    cout << *p3 << endl;

    //现在p1无法取值
    cout <<*p1<<endl;

    //可以使用reset显示释放内存
    p3.reset();

    //重新绑定新的指针
    p3.reset(new int (100));

    //获取到曾经包装的int类型指针
    int *p4 = p3.get() ;
    cout<<*p4<<endl;
    return 0;
}

1.2 shared_ptr

允许多个智能指针共享同一块内存，由于并不是唯一指针，所以为了保证最后的释放回收，采用了计数处理，每一次的指向计数 + 1 ， 每一次的reset会导致计数 -1 ，直到最终为0 ，内存才会最终被释放掉。

#include <iostream>
#include <memory>

using namespace std;
class Stu{
public:
    Stu(){
        cout<<"构造函数"<<endl;
    }

    ~Stu(){
        cout<<"析构函数"<<endl;
    }
};
int main() {

    shared_ptr<Stu> s1(new Stu());

    cout<<"cout = "<<s1.use_count()<<endl;//查看指针指向

    shared_ptr<Stu> s2 = s1;
    s1.reset();
    s2.reset();//至此全部解除指向 计数为0 。 会执行stu的析构函数

    return 0;
}

1.3 shared_ptr的问题

对于引用计数法实现的计数，总是避免不了循环引用（或环形引用）的问题，即我中有你，你中有我，shared_ptr也不例外。

#include <iostream>
#include <memory>

using namespace std;
class Son;

class Father {
public:
    Father(){
        cout <<"father 构造" << endl;
    }
    ~Father(){
        cout <<"father 析构" << endl;
    }

    void setSon(shared_ptr<Son> s) {
        Son = s;
    }
private:
    shared_ptr<Son> Son;
};

class Son {
public:
    Son(){cout <<"son 构造" << endl;}
    ~Son(){cout <<"son 析构" << endl;}
    void setFather(shared_ptr<Father> f) {
        father = f;
    }
private:
    shared_ptr<Father> father;
};

int main() {

    shared_ptr<Father> f(new Father());
    shared_ptr<Son> s(new Son());
    f->setSon(s);
    s->setFather(f);

    return 0;
}

1.4 weak_ptr

为了避免shared_ptr的环形引用问题，需要引入一个弱指针weak_ptr，它指向一个由shared_ptr管理的对象而不影响所指对象的生命周期，也就是将一个weak_ptr绑定到一个shared_ptr不会改变shared_ptr的引用计数。

#include <iostream>
#include <memory>

using namespace std;
class Son;

class Father {
public:
    Father(){
        cout <<"father 构造" << endl;
    }
    ~Father(){
        cout <<"father 析构" << endl;
    }

    void setSon(shared_ptr<Son> s) {
        Son = s;
    }
private:
    shared_ptr<Son> Son;
};

class Son {
public:
    Son(){cout <<"son 构造" << endl;}
    ~Son(){cout <<"son 析构" << endl;}
    void setFather(shared_ptr<Father> f) {
        father = f;
    }
private:
//    shared_ptr<Father> father;
    weak_ptr<Father> father;
};

int main() {

    shared_ptr<Father> f(new Father());
    shared_ptr<Son> s(new Son());
    f->setSon(s);
    s->setFather(f);

    return 0;
}

2.动态内存

• 栈区：又叫堆栈，存储非静态局部变量、函数参数、 返回值等，栈是可以向下生长的

• 共享内存区：是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内 存，做进程间通讯

• 堆区：用于程序运行时动态内存分配，堆是可以向上增长的

• 静态区：存储全局数据和静态数据

• 代码区：存储可执行的代码、只读常量

2.1 new 和 delete

在 c++ 中 ， 如果要在堆内存中申请空间，那么需要借助 new 操作符，释放申请的空间，使用 delete操作 。而c语言使用的是malloc 和free ，实际上new 和 delete 的底层实际上就是 malloc 和 free 。

#include <iostream>

using namespace std;

class stu{
public:
    stu(){
        cout << "执行构造函数" <<endl;
    }
    ~stu(){
        cout << "执行析构函数" <<endl;
    }
};


int main(){
    int *a = new int();
    stu *s = new stu();

    delete a;
    delete s;

    //new的背后先创建
    return 0 ;
}

2.2 malloc 和 free

malloc` 和 free 实际上是C语言 申请内存的语法，在C++ 也得到了保存。只是与 new 和 delete 不同的是， 它们 是函数，而 new 和 delete是作为关键字使用。

#include <iostream>

using namespace std;

int main(){
    int *p=(int *)malloc(100); //如果申请失败，返回的是NULL
    *p = 10;
    int *p2=(int *)malloc(10); //如果申请失败，返回的是NULL
    *p2 = 18;

    cout<<*p<<endl;
    cout<<*p2<<endl;
    free(p);
    free(p2);
    return 0 ;
}

3.宏

3.1 宏变量

#define MAX 30

int main(){
    int scores[MAX]; //表示一个班30个人的成绩数组。

    return 0 ;
}

3.2 条件宏

#define DEBUG
#define REALEASE

#include<iostream>

using namespace std;

int main() {
    #ifdef DEBUG
        cout <<"debug模式下打印" << endl;
    #elif REALEASE
        cout <<"release模式下打印" << endl;
    #else
        cout <<"普通模式下打印" << endl;
    #endif

    //下面可言继续编写原有的逻辑
    cout << "继续执行逻辑代码~~~"<<endl;

    return 0 ;
}

4.枚举

枚举的目的：增加程序的可读性。枚举类型最常见也最有意义的用处之一就是用来描述状态量。

#include <iostream>
#include <vector>
using namespace std;
//枚举的使用
enum Gender{MALE,FEMALE};

class teacher{
public:
    string name;
    Gender gender;

    teacher(string name,Gender gender):name(name),gender(gender){

    }
};

int main() {
    teacher t1("zhangsan",Gender::MALE);
    teacher t2("fly" ,  Gender::FEMALE);
    teacher t3("haha" ,  Gender::MALE);

    vector<teacher> v;
    v.push_back(t1);
    v.push_back(t2);
    v.push_back(t3);

    for ( teacher t : v) {
        switch(t.gender){
            case Gender::MALE:
                cout<<"男老师"<<endl;
                break;
            case Gender::FEMALE:
                cout<<"女老师"<<endl;
                break;
            default:
                cout<<"other"<<endl;
                break;
        }
    }
    return 0;
}

5.异常处理

5.1 try catch

try{
    //执行的代码逻辑
}catch(runtime_error err ){ //捕获的异常类型。
    //捕获到异常，执行的逻辑
    cout << err.what() << endl; //打印错误信息
}

5.2 抛出异常

#include <iostream>

using namespace std;

int calcDiv(int a, int b){

    if(b == 0){
        throw  runtime_error("除数不能为0 ");
    }
    return a / b;
}

int main() {
    calcDiv(10,0);
    return 0;
}

---

结束！！！