C++学习记录（九）智能指针、异常处理

这是第九天的学习。

#include <iostream>
#include <memory>

using namespace std;
class A
{
    int id;
public:
    A(int id) : id(id) { cout << "A" << endl; }
    ~A() { cout << "~A" << endl; }

    void showInfo() { cout << this->id << endl; }
};

template <class T>
class AutoPtr
{
private:
    T* p;
public:
    AutoPtr(T* _p) : p(_p) {}
    ~AutoPtr() { delete p; }

    T* get() { return this->p; }
    AutoPtr(AutoPtr& autoptr)
    {
        this->p = autoptr.p;
        autoptr.p = nullptr;
    }
};

template<class T>
class Count                     // 定义一个计数器模板
{
private:
    T* p;                       // 定义指针
    int m_count;                // 定义计数值
public:
    Count(T* _p = nullptr) : p(_p)
    {                           // 构造函数，当指针p不为空时，计数值为1
        if(p != nullptr) m_count = 1;
        cout << "Count" << endl;
    }
    ~Count() { cout << "~Count" << endl; }

    // 计数器加法
    void Add() { this->m_count++; }
    // 计数器减法
    int Sub() { return --m_count; }
    int getCount() { return this->m_count; }
};

template <class T>
class SharedPtr                     // 定义一个共享指针
{
private:
    T* p;
    //static int numb;              // 静态变量所有类共享，不安全
    Count<T>* count;                // 定义计数器
public:
    SharedPtr(T* _p = nullptr) : p(_p)
    {                               // 构造函数，新建计数器
        if (p != nullptr)
        {
            count = new Count<T>(p);
        }
    }
    //~SharedPtr() { if (numb == 0) delete p; else numb--; }
    ~SharedPtr()
    {
        if (count->Sub() == 0)
        {
            delete this->p;
            delete this->count;
            p = nullptr;
            count = nullptr;
        }
        //else numb--;
    }

    T* get() { return this->p; }
    SharedPtr(const SharedPtr& sharedptr) : p(sharedptr.p),count(sharedptr.count)
    {                                   // 拷贝构造函数
        if (p != nullptr) count->Add();
        //numb++;
        cout << "copy constructor" << endl;
    }
    SharedPtr& operator=(const SharedPtr& sharedptr)
    {
        this->p = sharedptr.p;
        this->count = sharedptr.count;
        count->Add();
        return *this;
    }
    int useCount() { return count->getCount(); }

};

//template <class T>
//int SharedPtr<T>::numb = 0;

int main()
{
    // -1- 智能指针，是一个类模板
    // auto_ptr(弃用),shard_ptr(共享智能指针),unqiue_ptr(唯一指针)

    A* p1 = new A(123);
    p1->showInfo();
    delete p1;
    /*
    auto_ptr<A> p2(new A(456));     // auto_ptr在C++17中被废弃了
    p2.get()->showInfo();

    auto_ptr<A> p3(p2);             // 调用拷贝构造
    p3.get()->showInfo();
    p2.get()->showInfo();           // p2赋值给p3后变为空指针
    */
    /*
    AutoPtr<A> p4(new A(789));
    p4.get()->showInfo();

    AutoPtr<A> p5(p4);
    p5.get()->showInfo();
    */

    //
    /*
    shared_ptr<A> p6(new A(147));
    p6.get()->showInfo();
    shared_ptr<A> p7(p6);
    p7.get()->showInfo();
    p6.get()->showInfo();
    */
    /*
    SharedPtr<A> p8(new A(258));
    p8.get()->showInfo();
    SharedPtr<A> p9(p8);
    p9.get()->showInfo();
    p8.get()->showInfo();
    */
    //
    SharedPtr<A> ptr1(new A(100));
    SharedPtr<A> ptr2(ptr1);
    SharedPtr<A> ptr3;
    ptr3 = ptr2;
    cout << "  " << ptr3.useCount() << endl;

    //cout << "Hello World!" << endl;
    return 0;
}

#include <iostream>
#include <memory>

using namespace std;
class B;                // 前置声明
class A
{
public:
    weak_ptr<B> ptr_b;
public:
    A() { cout << "A" << endl; }
    ~A() { cout << "~A" << endl; }
    void showInfo() { cout << "ShowInfo" << endl; }
};
class B
{
public:
    weak_ptr<A> ptr_a;
public:
    B() { cout << "B" << endl; }
    ~B() { cout << "~B" << endl; }

    void func()
    {
        // 提升对对象的权限
        shared_ptr<A> temp = this->ptr_a.lock();
        if( temp != nullptr )
        {
            temp->showInfo();
        }
    }
};

int main()
{
    // weak_ptr,没有对象的访问权
    // 定义对象时用shared_ptr,用new,否则用weak_ptr
    shared_ptr<A> pA(new A);
    shared_ptr<B> pB(new B);

    pA->ptr_b = pB;
    pB->ptr_a = pA;

    cout << pA.use_count() << endl;
    cout << pB.use_count() << endl;

    cout << "Hello World!" << endl;
    return 0;
}

#include <iostream>

using namespace std;

//class Error
//{
//private:
//    string errorMsg;
//public:
//    Error(string errorMsg) { this->errorMsg = errorMsg; }
//    string What() { return this->errorMsg; }

//};
//Error err("b must not be 0");
logic_error err("b must not be 0");

float fun_div(int a, int b)
{
    if ( b==0 )
    {
        //throw -1;
        throw err;
    }
    return a/b;
}
int fun_add(int a, int b)
{
    return fun_div(a,b) + a + b;
}
int fun_mul(int a, int b)
{
    return fun_add(a,b) * a * b;
}

int main()
{
    // 面向异常处理机制的框架
    // throw关键字：抛出异常, throw + 类对象 或基本类型的值
    // 捕捉异常try{...抛出异常的阐述...}catch()
    // 处理异常catch(异常数型 异常的对象或变量){...异常处理语句块...}
    int data;
    int a = 10;
    int b = 0;
    try
    {
        data = fun_mul(a,b);
        cout << "final data is " << data << endl;
    }
    /*
    catch (int e)
    {
        if ( e== -1 ) { cout << "b must not be 0" << endl; }
    }
    */
    /*
    catch (Error& e)
    {
        cout << e.What() << endl;
    }
    */
    catch (logic_error& e)
    {
        cout << e.what() << endl;
    }

    cout << "Hello World!" << endl;
    return 0;
}