C++ 基础知识点

C++ 中四种 cast 转换

C++ 中四种类型转换是: static_cast, dynamic_cast, const_cast, reinterpret_cast

  1. const_cast

    用于将 const 变量转为非 const 变量

  2. static_cast

    用于各种隐式转换, 比如非 const 转 const, void* 转指针等, static_cast 能用于多态向上转化, 如果向下转能成功但是不安全, 结果未知

  3. dynamic_cast

    用于动态类型转换. 只能用于含有虚函数的类, 用于层次间的向上和向下转化. 只能转指针或引用. 向下转化时, 如果时非法的对于指针返回 null, 对于引用抛异常.

    其中:

    • 向上转换: 指的是子类向基类的转换
    • 向下转换: 指的是基类向子类的转换

    它通过判断在执行到该语句的时候变量的运行时类型和要转换的类型是否相同来判断是否能够向下转换

  4. reinterpret_cast

    几乎什么都可以转, 比如将 int 转换为指针, 可能会出问题, 建议尽量不要使用此类转换

C 的强制转换表面上看起来功能强大什么都可以进行转型, 但是转换不够明确, 不能进行错误检查, 容易出错

C/C++ 中指针和引用的区别

  1. 指针有自己的一块空间, 而引用只是一个别名
  2. 使用 sizeof 看一个指针的大小是 4, 而引用则是被引用对象的大小
  3. 指针可以被初始化为 null, 而引用必须被初始化且必须是一个已有对象的引用
  4. 作为参数传递时, 指针需要解引用才可以对对象进行操作, 而直接对引用的修改都会改变引用所指向的对象
  5. 可以有 const 指针, 但是没有 const 引用
  6. 指针在使用中可以指向其它对象, 但是引用只能是一个对象的引用, 不能被改变
  7. 指针可以有多级指针 (**p), 而引用只有一级
  8. 指针和引用使用 ++ 原算符的意义不一样
  9. 如果返回动态分配的对象或者内存, 必须使用指针, 引用可能引起内存泄漏

C++ 中的智能指针

C++ 里面的四个智能指针: auto_ptr, shared_ptr, weak_ptr, unique_ptr, 其中后三个是 C++11 支持的, 并且第一个已经被 11 弃用

为什么要使用智能指针:

智能指针的作用是管理一个指针, 因为存在以下这种情况: 申请的空间在函数结束时忘记释放, 造成内存泄漏. 使用智能指针可以很大程度上避免这个问题, 因为智能指针就是一个对象, 当对象的生命周期结束时, 对象会自动调用自己的析构函数, 而析构函数会自动释放所持有的资源.所以智能指针的作用原理就是在函数(方法)结束后自动释放内存空间, 不需要手动释放申请的内存空间

  1. auto_ptr (C++ 98 的方案, cpp11 已经弃用)

    采用所有权模式

    1
    2
    3
    auto_ptr<string> p1(new string("hello world"));
    auto_ptr<string> p2;
    p2 = p1 // auto_prt 不会报错

    此时不会报错, p2 剥夺了 p1 所指向对象的所有权, 此时 p1 为空, 所以当程序运行时访问 p1 将会报错. 所以 auto_ptr的缺点是: 存在潜在的内存崩溃问题

  2. **unique_ptr ** (替换 auto_ptr)

    unique_prt 实现独占式拥有或严格拥有概念, 保证同一时间内只有一个智能指针可以指向该对象. 它对于避免资源泄漏(例如 “以 new 创建对象后因为发生异常而忘记调用 delete”)

    采用所有权模式

    1
    2
    3
    unique_ptr<string> p3(new string("auto"));
    unique_ptr<string> p4;
    p4 = p3; // 此时会报错

    编译器认为 p4 = p4 非法, 避免了 p3 不再指向有效数据的问题. 因此 unique_ptr 比 auto_ptr 更安全

    另外 unique_ptr 还有更聪明的地方: 当一个程序试图将一个 unique_ptr 赋值给另一个时, 如果原 unique_ptr 是一个临时右值, 那么编译器允许那么做; 如果源 unique_ptr 将存在一段时间, 编译器将禁止那么做, 比如:

    1
    2
    3
    4
    5
    unique_ptr<string> pu1(new string("hello world"));
    unique_ptr<string> pu2;
    pu2 = pu1; // #1 not allowed
    unique_ptr<string> pu3;
    pu3 = unique_ptr<string>(new string("You")); // #2 allowed

    其中 #1 留下的悬挂的 unique_ptr(pu1) , 这可能带来危害. 而 #2 不会留下悬挂的 unique_ptr , 因为它调用 unique_ptr 的构造函数, 该构造函数创建的临时对象在其所有权让给 pu3 后就会被销毁. 这种随情况而已的行为表明, unique_ptr 优于允许两种赋值的 auto_ptr

    注: 如果确实想执行类似像 #1 的操作, 要安全的重用这种指针, 可以给它重新赋值. C++ 提供了一个标准库 std::move() 让你能够将一个 unique_ptr 赋值给另一个. 例如:

    1
    2
    3
    4
    5
    unique_ptr<string>ps1, ps2;
    ps1 = demo("hello");
    ps2 = std::move(ps1);
    ps1 = demo("alexia");
    cout << *ps2 << *ps1 << endl;

  3. shared_ptr

    shared_ptr 实现共享式拥有概念. 多个智能指针可以指向相同对象, 该对象和其相关资源会在 “最后一个引用被销毁” 的时候释放. 从名字就可以看出了资源可以被多个指针共享, 它使用计数机制来表明资源被几个指针共享. 可以通过成员方法 use_count() 来查看资源所有者的个数, 除了通过 new 来构造, 还可以通过传入 auto_ptr, unique_ptr, weak_ptr 来构造. 当我们调用 release() 时, 当前指针会释放资源所有权, 计数减一. 当计数等于 0 时, 资源会被释放.

    shared_ptr 是为了解决 auto_ptr 在对象所有权上的局限性**(auto_ptr 是独占的)**, 在使用引用计数的机制上提供了可以共享所有权的智能指针

    成员方法:

    • use_count() 返回引用计数的个数

    • unique() 返回是否独占所有权( use_count 为 1)

    • swap() 交换两个 shared_ptr 所拥有的对象

    • reset() 放弃内部对象的所有权或者拥有对象的变更, 会引起原有对象的引用计数减少

    • get() 返回内部对象(指针), 由于已经重载了方法, 因此和直接使用对象是一样的. 如

      shared_ptr<int>sp(new int(1)); sp 和 sp.get() 是等价的

    shared_ptr 的实现:

    核心要理解引用计数, 什么时候销毁底层指针, 还有赋值, 拷贝构造的时候的引用计数的变化, 析构的时候要判断底层指针的引用计数为 0 了才能真正释放底层指针的内存

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    template <typename T>
    class SmartPtr
    {
    private:
        T* ptr; // 底层真实指针
        int* use_count; // 保存当前对象被多少指针引用
        
    public:
        SmartPtr(T* p); //SmartPtr<int>p(new int(2))
        SmartPtr(const SmartPtr<T>& other); // SmartPtr<int>q(p)
        SmartPtr<T>& operator=(const SmartPtr<T>& rhs); // q = p;
        ~SmartPtr();
        T& operator*(); // 为了能把智能指针当成普通指针操作定义解引用
        T* operator->();
        T* operator+(int); // 定义指针加一个常数
        int operator-(const SmartPtr<T>& rhs); // 获得两指针相减获得其距离
        void get_count()
        {
            return *use_count;
        }
    };

    template <typename T>
    int SmartPtr<T>::operator-(const SmartPtr<T>& rhs)
    {
        return ptr - rhs.ptr;
    }

    template <typename T>
    SmartPtr<T>::SmartPtr(T* p)
    {
        ptr = p;
        try
        {
            use_count = new int(1);
        } catch(...)
        {
            delete ptr; // 申请失败释放真实指针和引用计数的内存
            ptr = nullptr;
            delete use_count;
            use_count = nullptr;
        }
    }


    template <typename T>
    SmartPtr<T>::SmartPtr(const SmartPtr<T>& other)
    {
        // 引用计数保存在一块内存, 所有的 SmartPtr 对象的引用计数都指向这里
        use_count = other.use_count; 
        prt = other.ptr;
        ++(*use_count); // 当前对象的引用计数 + 1
    }

    template <typename T>
    SmartPtr<T>& SmartPtr<T>::operator=(const SmartPtr<T>& rhs)
    {
        // 重载=运算符, 例如 SmartPtr<int>p, q; p = q; 这个语句中, 首先给 q 指向的对象的引用计数
        // 加 1, 因为 p 重新指向了 q 所指的对象, 所有 p 需要先给原来的对象的引用计数减 1,如果减 1
        // 后为 0, 先释放掉 p 原来指向的内存, 然后将 q 指向的对象的引用计数加 1 后赋值给 p;
        ++(*rhs.use_count);
        if ((--(*use_count)) == 0) 
        {
            delete ptr;
            ptr = nullptr;
            delete use_count;
            use_count = 0;
        }
        ptr = rhs.ptr;
        use_count = rhs.use_count;
        return *this;
    }

    template <typename T>
    SmartPtr<T>::~SmartPtr()
    {
        if (--(*use_count) == 0)
        {
            delete ptr;
            ptr = nullptr;
            delete use_count;
            use_count = ptr;
        }
    }

    template <typename T>
    T& SmartPtr<T>::operator*() { return *ptr; }

    template <typename T>
    T* SmartPtr<T>::operator->() { return ptr;}

    T* SmartPtr<T>::operator+(int i) { return ptr + i; }

  4. weak_ptr

    weak_ptr 是一种不控制对象生命周期的智能指针, 它指向一个 shared_ptr 管理的对象, 进行该对象的内存管理的是那个强引用的 shared_ptr . weak_ptr 只是提供了对管理对象的一个访问手段. weak_ptr 设计的目的是为配合 shared_ptr 而引入的一种智能指针来协助 shared_ptr 或另一个 weak_ptr 对象构造, 它的构造和析构不会引起计数的增加或者减少. weak_ptr 是用来解决 shared_ptr 相互引用时的死锁问题, 如果说两个 shared_ptr 相互引用, 那么这两个指针的引用计数永远不可能下降为 0, 资源永远不会释放. 它是对对象的弱引用, 不会增加对象计数, 和 shared_ptr 之间可以相互转化, share_ptr 可以直接赋值给它, 它可以通过调用 lock 方法来获得 shared_ptr

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    class B;
    class A
    {
    public:
        shared_ptr<B> pb_;
        ~A()
        {
            cout << "A delete" << endl;
        }
    };

    class B
    {
    public:
        shared_ptr<A> pa_;
        ~B()
        {
            cout << "B delete" << endl;
        }
    };


    void fun()
    {
        shared_ptr<B> pb(new B());
        shared_ptr<A> pa(new A());
        pb->pa_ = pa;
        pa->pb_ = pb;
        cout << pb.use_count() << endl;
        cout << pa.use_count() << endl;
    }

    void main()
    {
        fun();
        return 0;
    }

    可以看到 fun() 函数中 pa, pb 之间相互引用, 两个资源的引用计数为 2, 当要跳出函数时. 智能指针 pa, pb 析构时两个资源的引用计数会减一, 但是两者的引用计数还是为 1, 导致函数结束时没有释放在堆空间内申请的内存 (A, B 的析构函数没有被调用), 如果把其中一个改为 weak_ptr 就可以了, 我们把 A 类里面的 shared_ptr; 改为 weak_ptr;这样的话, 资源 B 的引用开始就只有 1, 当 pb 析构时, B 的计数变为 0, B 得到释放, B 释放的同时也会使 A 的计数减一, 同时 pa 析构时使 A 的计数减一, 那么 A 的计数为 0, A 得到释放

    **注意:**p

    ​ 我们不能够通过 weak_ptr 直接访问对象的方法, 比如 B 对象中有一个方法 print() , 我们不能这样访问, pa->pb_>print() 因为 pb_ 是一个 weak_ptr , 应该先把它转换为shared_ptr, 如: shared_ptr p = pa->pb_.lock(); p->print();