C++ 08限制构造+智能指针

最新推荐文章于 2024-10-07 19:01:55 发布
最新推荐文章于 2024-10-07 19:01:55 发布
阅读量62 收藏 1
点赞数 2
分类专栏： C++ 文章标签： c++ 单例模式 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58646511/article/details/132703074
版权

一、限制构造

限制构造：限制类直接定义对象（实现一些特殊的操作，例如单例设计模式）
方法1：将构造函数隐藏到private，通过友元函数或静态函数获取对象
方法2：将构造函数隐藏到protected，通过静态函数，或者友元函数，或者继承来使用

static A* init(int x)
{
    A* ptr=new A(x);    //new在堆区，防止对象在函数结束时被销毁，
    return ptr;         //但是注意要手动的delete内存，以防止内存泄漏
}

简单的单例设计模式
class Singleton{
private:
    static Sinleton* instance;
    Singleton(){}        //将构造函数设为私有，防止外部创建实例
public:
    static Singleton * getInstance()
    {
        if(instance == nullptr)        //判断，如果有对象了，就把该指针返回回去，
        {                              //使得多次定义不同对象时，对象都指向了一个空间（实体）  
            instance == new Singleton();        
        }    
        return instance;
    }
    freeInstance()
    {
        if(instance!=nullptr)
        {
            delete instance;    
            instance = nullptr;        
        }    
    }
    
    void showMessage()
    {
        std::out<<"hello world!"<<std::endl;    
    }
};

Singleton* Singleton::instance = nullptr;
int main()
{
    Singleton * singleton = Singleton::getInstance();
    singleton->showMessage();
    
    Singleton *ptr = Singleton ::getInstance();
    ptr->showMessage();
    ptr->freeInstance();
    
     return 0; 
}

1.将构造函数隐藏到private，通过友元函数或静态函数获取对象

#include <iostream>
using namespace std;

// 限制构造： 将构造函数 修饰为private

// 限制构造意义： 可以用来实现单例设计模型
class A
{
public:
    void print_val(void)
    {
        cout << "val:" << val << endl;
    }
    //--------------------------------------------------------------------
    static A *get_obj(int x)    // 通过静态函数 获取对象
    {                               
        A *ptr = new A(x);        //new在堆区，防止对象在函数结束时被销毁，
        return ptr;                //但是注意要手动的delete内存，以防止内存泄漏
    }
    //--------------------------------------------------------------------
    static void free_obj(A *ptr)
    {
        delete ptr;
    }
    ~A()
    {
        cout << "A析构" << endl;
    }
private:
    int val;
    A(int x = 0) : val(x)
    {
        cout << "A构造" << endl;
    }

    friend A *get_instance(int x);
};
  //--------------------------------------------------------------------
                                    // 通过友元函数实现
A *get_instance(int x)
{
    A *ptr = new A(x);
    return ptr;
}
  //--------------------------------------------------------------------
int main(void)
{
    // A a1(354);
    // a1.print_val();

    A *ptr = A::get_obj(354);  //通过静态函数获取对象    静态函数使用    类域::函数
    ptr->print_val();
    A::free_obj(ptr);          //通过静态函数释放对象

#if 0
    A *ptr = get_instance(1234);

    ptr->print_val();
    delete ptr;
#endif 
    return 0;
}

必须返回指针，不能返回对象，返回对象需要外部有一个对象来接收，但是外部不能定义对象（被private限制了）

2.将构造函数隐藏到protected，通过静态函数，或者友元函数，或者继承来使用

#include <iostream>
using namespace std;

//限制构造： 将构造函数 修饰为protected
class A
{
protected:
     A(int x=0){
         cout<<"A构造"<<endl;
     }
};

//可以用来 继承来使用
class B:public A
{
};
int main(void)
{
   // A a1;
   // A a2(34);
   
    B b1;            //构造子类时，父类也会构造
    return 0;
}

二、智能指针

注意包含头文件：#include <memory>

背景：对于new开辟的空间，需要delete释放，如果忘记delete会造成内存泄露
        因此C++设计了智能指针，用于解决该问题

智能“指针”，其实这里的指针不是真正的指针，是对象，是通过运算符重载，实现类似指针的操作，例如-> 、* ；    
智能指针的实现依赖：类模板 + 运算符重载 + 浅拷贝 + 引用计数器的设计

shared_ptr //共享智能指针，多个指针可以指向同一对象（允许拷贝构造，赋值操作）
unique_ptr //唯一智能指针，避免出现安全问题 ，不允许多个指针指向同一对象（禁止拷贝，赋值）
wake_ptr // 用于管理的共享智能指针，提供了一个方法用于判断对象是否存在 ，是shared_ptr更加安全

1.shared_ptr

shared_ptr <Demo> ptr (new Demo);        //模板类
或
shared_ptr <Demo> ptr = make_shared <Demo>(Demo());

ptr实质，是一个对象
------------------------------------------------------------------------------
共享智能指针 允许拷贝构造与赋值函数
拷贝构造：
    shared_ptr <A> ptr2(ptr1);
赋值操作：
    shared_ptr <A> ptr3(new A(11));    //又单独开一片空间，方便演示
    ptr3=ptr2;
ptr2和ptr1指向的是同一片空间

在这里插入图片描述
在这里插入图片描述

eg：
#include <iostream>
#include <memory>
using namespace std;

class A
{
private:  
    int i;
public:
    A(int x=0): i(x) {    
        cout<<"A构造"<<endl;
    }
    ~A(){
        cout<<"A析构"<<endl;
    }
    void set_val(int x){
        i = x;
    }
    void print_val(void){
        cout<<"i:"<<i<<endl;
    }
};

int main(void)
{
   // A *ptr = new A(12);
   // ptr->print_val();

    shared_ptr <A> ptr1 (new A(12)); 

    ptr1->print_val();
    (*ptr1).set_val(200);
    (*ptr1).print_val();


    //共享智能指针 允许拷贝构造与赋值函数使得指针指向同一片空间
    
    shared_ptr <A> ptr2(ptr1);  
    ptr2->set_val(123);
    ptr1->print_val();

    shared_ptr <A> ptr3(new A(11));
    ptr3 = ptr1;


    return 0;
}

2.unique_ptr

unique_ptr <Demo> ptr <new Demo>;
唯一指针：不允许拷贝构造和赋值函数（拷贝构造和赋值函数被删掉了）
eg:
    unique_ptr <A> ptr (new A(12));

eg：

#include <iostream>
#include <memory>
using namespace std;

class A
{
private:  
    int i;
public:
    A(int x=0): i(x) {    
        cout<<"A构造"<<endl;
    }
    ~A(){
        cout<<"A析构"<<endl;
    }
    void set_val(int x){
        i = x;
    }
    void print_val(void){
        cout<<"i:"<<i<<endl;
    }
};

int main(void)
{
   // A *ptr = new A(12);
   // ptr->print_val();

    unique_ptr <A> ptr1 (new A(12));

    ptr1->print_val();
    (*ptr1).set_val(200);
    (*ptr1).print_val();

#if 1
    //唯一指针 不允许拷贝构造与赋值函数
    
   // unique_ptr <A> ptr2(ptr1);   //不允许拷贝构造
    //ptr2->set_val(123);
    //ptr1->print_val();

    unique_ptr <A> ptr3(new A(11));
    //ptr3 = ptr1;    //不允赋值操作

#endif 

    return 0;
}

3.wake_ptr

普通写法：
    shared_ptr <Demo> ptr1 (new Demo());
    weak_ptr <Demo> w_ptr(ptr1);    //w_ptr用于管理共享智能指针
比较安全的写法：
    shared_ptr <Demo> ptr1 = make_shared <Demo> (Demo());     //比较安全
        //如果是shared_ptr <A> ptr1 (&obj);    //obj是一个栈区的对象    Demo obj；
        //栈区对象是自动开辟自动释放的，上述操作将共享指针指向栈区，共享指针free的时候发现是栈区的会出现问题
    weak_ptr <Demo> ptr2=ptr1;
---------------------------------------------------------------------------------
w_ptr:
    
    if(w_ptr.expired())    //判断对象是否销毁了
    {
        cout<<"对象已经销毁了"<<endl;
    }

    w_ptr.reset();        //可以用来释放对象

---------------------------------------------------------------------------------
eg：
    shared_ptr <A> ptr1 (new A(123));
    weak_ptr <A> w_ptr(ptr1);   //weak_ptr用于管理共享智能指针

eg:

#include <iostream>
#include <memory>
using namespace std;

class A
{
private:  
    int i;
public:
    A(int x=0): i(x) {    
        cout<<"A构造"<<endl;
    }
    ~A(){
        cout<<"A析构"<<endl;
    }
    void set_val(int x){
        i = x;
    }
    void print_val(void){
        cout<<"i:"<<i<<endl;
    }
};

int main(void)
{
    //shared_ptr <A> ptr1 (&obj); 
    //shared_ptr <A> ptr1 = make_shared <A>(A());  //更加安全的写法
    
    shared_ptr <A> ptr1 (new A(123));
    weak_ptr <A> w_ptr(ptr1);   //weak_ptr用于管理共享智能指针

    //w_ptr.reset();

    if(w_ptr.expired()){
        cout<<"对象已经销毁了"<<endl; //不能使用共享智能指针
    }
    else{
        ptr1->print_val();
    }
    
    return 0;
}

三、异常处理

异常处理思想：分离思想
将问题监测和问题处理相分离    ：出现异常暂时性不做处理，抛出异常，留给使用者去处理

基本流程：三个部分组成
try（检查）----throw（抛出）-----catch（捕获）

异常会一级一级抛出，到最高一级还无法处理的话，运行系统会自动调用系统函数treminate

捕获类型，需要按类型进行捕获

#include <iostream>
using namespace std;

// 定义数组类
class Array
{
private:
    int *data;
    int len;
    int index;

public:
    Array(int len = 20)
    {
#if 1
        if (len <= 0)
        {
            throw "len error"; // 抛出异常   
        }
#endif 
        data = new int[len]; // 开辟空间
        this->len = len;
        this->index = -1;
    }
    Array(const Array &obj)
    { // 拷贝构造

        this->len = obj.len;
        this->index = obj.index;

        this->data = new int[obj.len];

        for (int i = 0; i <= index; i++)
        {
            this->data[i] = obj.data[i];
        }
    }

    ~Array()
    {
        delete[] data; // 释放空间
    }
    bool full()
    {
        if (index == len - 1)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    bool empty()
    {
        if (index == -1)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    int push_back(int val)
    {
        if (full())
        {
            return -1;
        }
        index++;
        data[index] = val;
        return 0;
    }
    int print()
    {
        for (int i = 0; i <= index; i++)
        {
            cout << data[i] << ",";
        }
        cout << endl;
        return 0;
    }
    int at(int index)
    {
        if (index < 0 || index > this->index)
        {
            throw "index error"; //异常类型 可以是基本类型 也可以是对象
        }
        return data[index];
    }
    int lenth()
    { // 数组有效数据长度
        return index + 1;
    }
    int space()
    { // 数组空间大小字节数
        return sizeof(int) * len;
    }
    int &operator[](int i)
    {
        if (i < 0 || i > this->index)
        {
            throw  -1;
        }
        return data[i];
    }
};

int main(void)
{

    try
    {
        Array a1(-100);

        a1.push_back(54);
        a1.push_back(83);
        a1.push_back(182);

        a1.at(-5);

        a1[-10];

        a1.print();
    }
    //根据类型 进行捕获，然后进行处理
    catch (const char *str)
    {
        cout << str << endl;
    }
    catch (const int errnum){
        cout<< errnum<<endl;
    }
    catch (const std::exception &e)
    {
        std::cerr << e.what() << '\n';
    }

    return 0;
}
飞机场的十点半后
关注
专栏目录
C++11 weak_ptr智能指针详解
二进制君
04-10 4807
weak_ptr这个指针天生一副“小弟”的模样，也是在C++11的时候引入的标准库，它的出现完全是为了弥补它老大shared_ptr天生有缺陷的问题，其实相比于上一代的智能指针auto_ptr来说，新进老大shared_ptr可以说近乎完美，但是通过引用计数实现的它，虽然解决了指针独占的问题，但也引来了引用成环的问题，这种问题靠它自己是没办法解决的，所以在C++11的时候将shared_ptr和weak_ptr一起引入了标准库，用来解决循环引用的问题。weak_ptr本身也是一个模板类，但是不能直接用它来定
C++利用构造函数限制对象的创建
qq_28938511的博客
02-12 397
总的一句话概括：限制创建那些完全没有初始化的对象。那种对象没意义。所以我们要尽量限制掉默认构造函数，自己写一个带参数的初始化构造函数。 首先需要知道的是我们是在什么样的情况下才需要限制对象的创建。限制对象的创建不代表我们想禁止创建对象，只是加以限制而已，限制创建对象时能够按照我们需要的那样创建，而不能随意的创建对象。 比如下面代码，我们定义了一个book类，声明对象的时候自然是为了描述某一本具...
C++构造函数与析构函数的访问权限问题
qq_32931387的博客
03-19 2972
默认情况下C++的构造函数和析构都是public类型的，但有时候我们会将其设为private类型：    1.将析构函数设为private类型,构造函数public类型：        这种情况下由于系统不能在对象离开作用域是调用析构函数进行清理工作，故不能通过定义对象的方式来获取对象，但是可以通过new从堆上来分配对象，然后通过定义一个public类型的接口调用析构函数进行清理工作   2.将构...
C++ STL 四种智能指针
热门推荐
Dablelv 的博客专栏。
08-07 7万+
auto_ptrunique_ptrshared_ptrweak_ptrauto_ptr 是 C++98 提出的，C++11 已将其摒弃，并提出了 unique_ptr 替代 auto_ptr。虽然 auto_ptr 已被摒弃，但在实际项目中仍可使用，但建议使用更加安全的 unique_ptr，后文会详细叙述。shared_ptr 和 weak_ptr 则是 C+11 从准标准库 Boost 中引入的两种智能指针。
C++智能指针基础用法详解
mahuifa的博客
04-21 1272
智能指针是C++中用于管理动态分配资源的强大工具，通过正确使用智能指针，可以显著减少内存泄漏的可能性，并提高代码的安全性和可维护性。
【C++】异常+智能指针+特殊类和类型转换
The porters of knowledge
05-23 731
处理错误的异常体系，智能指针unique_ptr，shared_ptr，引用计数，线程安全，循环引用，weak_ptr，定制删除器，常见特殊类，单例模式，C++的四种类型转换…
C++——智能指针
kk阿彬
07-27 3109
智能指针是代理模式的具体应用，它使用RAII技术代理了裸指针，能够自动释放内存，无需程序员干预。如果指针是“独占”使用，就应该选择unique_ptr，它为裸指针添加了很多限制，更加安全。如果指针是“共享”使用，就应该选择shared_ptr，它的功能非常完善，用法几乎与原始指针一样。应当使用工厂函数make_unique()、make_shared()来创建智能指针，强制初始化，而且还能使用auto来简化声明。..........................................
C++ 指针、智能指针、引用
暮色尽染的博客
07-16 856
控制块中有强弱引用计数，如果是使用make_shared初始化的函数则它所在的控制块空间是在所引用的shared_ptr中同一块的空间，若是new则控制器所分配的内存与shared_ptr本身所在的空间不在同一块内存。但是，悬空指针不能直接访问对象的成员变量或成员函数，因为编译器不知道指针所指向的对象的类型。也就是说，一个指针指针是一个指针，它的值是另一个指针的地址。悬空指针（Void Pointer）是一种特殊类型的指针，它可以指向任何类型的对象，但不能直接访问对象的成员变量或成员函数。
C++：智能指针（RAII思想）
decade777555的博客
05-04 1228
智能指针是一种用于管理动态分配的内存的 C++ 类。它们提供了对堆内存的自动分配和释放，以防止内存泄漏和悬挂指针的情况。常见的智能指针包括 std::unique_ptr、std::shared_ptr 和 std::weak_ptr。
C++如何用智能指针管理内存资源
09-07
- 使用智能指针时，理解其工作原理和限制至关重要，以避免错误的使用导致新的问题。 总之，C++的智能指针如`unique_ptr`和`shared_ptr`是管理内存资源的强大工具，它们通过RAII原则简化了内存管理，减少了程序员的...
C++中auto_ptr智能指针的用法详解
09-02
了解并掌握`auto_ptr`的用法和限制，可以帮助开发者更好地理解智能指针的概念，并为过渡到现代C++标准打下基础。虽然在新的代码中不应再使用`auto_ptr`，但理解其工作原理有助于理解现代C++智能指针的设计决策。
C++基础篇：09 智能指针与异常处理
snowysc的博客
06-18 718
只能指针与异常处理
【C语言】数据类型和变量
2302_76713442的博客
10-06 1100
一、数据类型分类（内置数据类型：字符型、整型、浮点型和布尔类型）（自定义数据类型：数组、结构体、枚举和联合体）二~三、深入研究内置数据类型（内置数据类型的大小、使用内置数据类型创建变量、signed 和 unsigned）四、自定义数据类型的内容过于庞大，所以每种自定义数据类型都专门写了一篇博客来介绍，文中有相应链接。
第 21 章 一条记录的多幅面孔——事务的隔离级别与 MVCC
weixin_45740473的博客
10-02 993
并发的事务在运行过程中会出现一些可能的引发一致性问题SQL 标准中有4种隔离级别版本链ReadView。
C - Separated Lunch
m0_74304371的博客
10-05 276
C - Separated Lunch(KEYENCE Programming Contest 2024 (AtCoder Beginner Contest 374))
贪心算法c++
最新发布
hjxxlsx的博客
10-07 791
贪心选择性质活动安排问题问题描述选择。
【C++】类与对象基础概念解析
A Charmer 的博客
10-03 1387
在 C++ 编程中，类与对象是核心概念之一，它们为程序设计提供了一种强大而灵活的方式来组织代码和管理数据。理解类与对象的基础概念对于掌握 C++ 编程至关重要。
C语言 | Leetcode C语言题解之第448题找到所有数组中消失的数字
m0_59237910的博客
10-01 415
C语言 | Leetcode C语言题解之第448题找到所有数组中消失的数字
C++ String类详解与智能指针应用
"C++的String类是用于处理字符串的重要工具，它包含了丰富的成员函数和操作符，同时也涉及到智能指针的概念。String类在C++中是一个类模板的基本实现，允许动态存储和管理字符序列。学习C++时，理解并熟练掌握String...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值