C++六：析构函数

已于 2023-10-25 02:01:31 修改
阅读量498 收藏 1
点赞数 16
分类专栏： C++ 文章标签： c++ 开发语言
于 2023-10-23 18:46:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53809203/article/details/133968461
版权

一、析构函数

        函数名与类名相同，在函数名前面添加~，函数没有返回值，没有参数，当对象销毁的时候，系统会自动调用（析构函数可以释放成员空间）。

        作用：释放类中的数据成员（例如：堆空间，映射空间，打开的文件......）。

析构函数的特点：

1、函数名 与 类名 同名 ，且在函数前添加 ~    如：~类名

2、函数没有返回值

3、函数没有参数

4、在对象销毁时自动调用

为什么需要析构函数？

#include <iostream>

using namespace std;

class base
{
    public:
        //构造函数
        base()
        {
            cout << "Call constructor..." << endl;
            p = new char[1024];    //分配堆空间
        }
    private:
        char *p;
};

void test()
{
    //创建一个 base 的对象
    base a;    //生命周期 只在 test函数 中有效
}

int main()
{
    //调用test函数
    test();

    while(1);

    return 0;
}

分析：

二、析构函数的定义语法

class 类名

{

        public:

        ~类名()        //->析构函数

        {

        }

}

demo：

class base

{

        public:

        ~base()

        {

                cout << "析构函数" << endl;

        }

};

#include <iostream>

using namespace std;

class base
{
    public:
        //构造函数
        base()
        {
            cout << "Call constructor..." << endl;
            p = new char[1024];    //分配堆空间
        }

        //析构函数
        ~base()
        {
            cout << "Release heap space..." << endl;
            delete p;
        }
    private:
        char *p;
};

void test()
{
    //创建一个 base 的对象
    base a;    //生命周期 只在 test函数 中有效
}

int main()
{
    while(1)
    {
        //调用test函数
        test(); 
    }

    return 0;
}

编译运行：

        可以看到在调用结束后，会自动调用析构函数去释放堆空间。

三、析构函数的引用例子

#include <iostream>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>

using namespace std;

class base
{
    public:
        //构造函数
        base()
        {
            //打开一个文件
            fd = open("my.txt",O_RDWR);
            if(fd < 0)
            {
                cout << "File opening failed...." << endl;
                exit(0);
            }
            cout << "Open file success: " << fd << endl;
        }

        //析构函数
        ~base()
        {
            cout << "Close file..." << endl;
            close(fd);
        }
    private:
        int fd;
};

int main()
{
    while(1)
    {
        //创建 base 对象
        base a;    //局部对象，只在{}内有效

        //base *p = new base;    //堆空间对象，base空间不被释放，就不调用析构
        //delete p;    //释放 base 的空间，自动调用析构函数
    }

    return 0;
}

编译运行：

练习

        设计一个文件类  class file，构造函数中，默认打开一个my.txt文件，设计一个cat接口，读取文件中的所有数据。并设计析构函数，关闭文件。

#include <iostream>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>

using namespace std;

class file
{
    public:
        //带参数的构造函数
        file(const char *fileName="my.txt")
        {
            //打开一个文件
            fd = open(fileName,O_RDWR);
            if(fd < 0)
            {
                cout << "File opening failed...." << endl;
                exit(0);
            }
            cout << "Open file success: " << fd << endl;
        }

        //析构函数
        ~file()
        {
            cout << "Close file..." << endl;
            close(fd);
        }

        //读取文件所有数据接口
        void cat()
        {
            char readBuf[1024] = {0};
            while(1)
            {
                if(read(fd,readBuf,sizeof(readBuf)) <= 0)
                {
                    cout << "File read complete..." << endl;
                    break;
                }
            }
            cout << readBuf << endl;
        }
    private:
        int fd;
};

int main()
{
    //创建一个file类对象f
    file f;
    f.cat();

    file b("32test.cpp");
    b.cat();

    return 0;
}

编译运行：

四、析构函数可以重载吗？

        重载的依据是，根据参数列表的不同。但是，析构函数的特点之一就是没有参数，所以不能重载！！！

五、类的大小计算

类的大小计算与结构体的大小计算一致！！！

复习结构体的大小计算：

struct node
{
    char a;
    int b;
    short c;
};

上述结构体的大小为多少字节？

        12个字节。

struct node
{
    char a;    //1，其实分配了4个字节，使用了1个字节，剩下3个
    int b;     //4，而上述剩下的3个字节并不能存放int类型，则需要重新分配4字节，使用4字节，剩下0字节
    short c;   //2，分配4字节，使用2个字节，剩下2个字节
    //所以可以看出，当前结构体浪费了 5个字节 的空间
};

//大小为12个字节，为什么不是7个字节？？
//当前结构体最大的数据类型时 int ，所以就是按照 4字节对齐，每次分配 4个字节

因为，结构体空间分配是根据字节对齐原则：根据最大的数据类型进行对齐。

练习：

重新设计上述结构体，让它分配的空间最小。

struct node
{
    int b;     //4，分配4字节，使用4字节，剩下0字节
    short c;   //2，分配4字节，使用2个字节，剩下2个字节
    char a;    //1，上面分配的4字节空间，还剩下2个字节，可以存放char，不需要再分配4字节空间
    //所以可以看出，当前结构体浪费了 1个字节 的空间
};//大小为 8个字节 ，节省了4个字节的空间

类的大小

#include <iostream>

using namespace std;

struct node
{
    char a;
    int b;
    short c;
};

struct node1
{
    int b;
    short c;
    char a;
};

class base
{
    char a;
    int b;
    short c;
};

class base1
{
    int b;
    short c;
    char a;
};

int main()
{
    //计算结构体及类的大小
    cout << "node size: " << sizeof(node) << endl;
    cout << "base size: " << sizeof(base) << endl;
    cout << "node1 size: " << sizeof(node1) << endl;
    cout << "base1 size: " << sizeof(base1) << endl;

    return 0;
}

编译运行：

结论：类的空间大小分配 与 结构体是一模一样的。

        所以在定义类的数据成员时，应该把数据类型 从小到大排序 定义。这样定义出来的类，所需要的空间最小。

class base
{
    char a;        //小
    short c;       //中

    int b;           //大
};        // 8

六、类的大小分配与属性无关

#include <iostream>

using namespace std;

class base
{
    public:            //公有区
        char a;
    protected:         //保护区
        short b;
    private:           //私有区
        int c;
};

class base1
{
    private:           //私有区
        char a;
    protected:         //保护区
        short b;
    public:            //公有区
        int c;
};

int main()
{
    cout << "base: " << sizeof(base) << endl;
    cout << "base1: " << sizeof(base1) << endl;

    return 0;
}

编译运行：

结论：上述，不管属性如何修改，类的大小都是8字节。说明，类的大小与属性无关，只与数据成员的位置有关。这是因为类的空间分配，是根据数据成员 从上往下 依次分配空间的！！！

可以用一个程序，打印它们的地址来看看类是如何分配空间的：

#include <iostream>

using namespace std;

class base
{
    public:
        char a;    //占用地地址 最先分配 0xbfa50754
        int c;     //                   0xbfa50758
        short b;   //占用高地址 最后分配 0xbfa5075c    从上往下依次分配！！！
};

int main()
{
    //定义一个对象
    base a;    //&a 0xbfa50754  &a 就是 &a.a 的地址，因为最开始的就是 a.a
    
    cout << "&a: " << &a << endl;
    cout << "&a.a: " << (void *)&a.a << endl; //&a.a 0xbfa50754
    cout << "&a.c: " << &a.c << endl;         //&a.c 0xbfa50758
    cout << "&a.b: " << &a.b << endl;         //&a.b 0xbfa5075c

    return 0;
}

编译运行：

七、类的大小与成员函数无关

#include <iostream>

using namespace std;

//类的大小与成员函数无关
class base
{
    public:
        void func()
        {
            int a;    //整型数据
            //当函数调用时，才创建，结束时，自动销毁。与类中的成员无关！
        }
    private:
        int date;    //整型数据 类中的数据成员，一直存在类中
};

class base1
{
    public:
        void func()
        {
            //int a;    //整型数据
        }
    private:
        int date;    //整型数据
};

class base2
{
    public:
        void func()
        {
            int a;    //整型数据
        }
    private:
        //int date;    //整型数据
};

class base3
{
    public:
        void func()
        {
            int a;    //整型数据
            int b;
            int c;
        }
    private:
        int date;    //整型数据
};

int main()
{
    //计算类的大小
    cout << "base: " << sizeof(base) << endl;      //4
    cout << "base1: " << sizeof(base1) << endl;    //4
    cout << "base2: " << sizeof(base2) << endl;    //1
    cout << "base3: " << sizeof(base3) << endl;    //4

    return 0;
}

编译运行：

为什么类的大小与成员函数无关？

        因为在函数定义的数据都属于局部变量，在函数未被调用前，这些数据是不会被分配空间的。函数调用结束时，会自动销毁。

八、this指针

        概念：在每一个类的内部都含有一个this指针，指向当前类的首地址。

        作用：用来区分 类内成员 与 类外成员。

#include <iostream>

using namespace std;

class base
{
    public:
        base()
        {
            cout << "this: " << this << endl;    //输出this指针指向的地址
            //0xbfbb814f
        }
};

int main()
{
    //创建一个base类的对象
    base a;
    cout << "&a: " << &a << endl;    //0xbfbb814f

    return  0;
}

编译运行：

#include <iostream>

using namespace std;

class base
{
    public:
        base()
        {
            cout << "this: " << this << endl;    //输出this指针指向的地址
        }

        base(int data)    //类外成员
        {
            //data = data;    //通过构造函数进行初始化，优先使用类外成员
            this->data = data;    //当前类中的data = 形参data（类外）
        }

        void show()
        {
            cout << "data: " << data << endl;
        }
    private:
        int data;    //类内
};

int main()
{
    //创建一个base类的对象
    base a;
    cout << "&a: " << &a << endl;

    base b(100);
    b.show();

    return  0;
}

分析：

练习

完成下述类的赋值：

class base

{

        public:

                base(int a,char b,short c,float d,const char *buf)

                {

                }

        private:

                int a;

                char b;

                short c;

                float d;

                char buf[100];

}

#include <iostream>
#include <string.h>

using namespace std;

class base
{
    public:
        base(int a,char b,short c,float d,const char *buf)
        {
            this->a = a;
            this->b = b;
            this->c = c;
            this->d = d;
            strcpy(this->buf,buf);
        }
        
        void show()
        {
            cout << "a: " << a << endl;
            cout << "b: " << b << endl;
            cout << "c: " << c << endl;
            cout << "d: " << d << endl;
            cout << "buf: " << buf << endl;
        }
    private:
        int a;
        char b;
        short c;
        float d;
        char buf[100];
}

int main()
{
    base a(10086,'W',20,3.14f,"hello");
    a.show();
}

        可见，this指针用于区分 类内成员 与 类外成员。同样，我们也可以用参数列表来区分 类内 与 类外成员：

九、类外定义类的成员函数

#include <iostream>

using namespace std;

class base
{
    public:
        //构造函数
        base();
        //析构函数
        ~base();
        //显示接口函数
        void show();
};

//在类外编写成员函数，需要将这个函数与这个类关联起来,使用 域操作符 关联
base::base()
{
    cout << "base()" << endl;
}

base::~base()
{
    cout << "~base()" << endl;
}

void base::show()
{
    cout << "base show" << endl;
}

int main()
{
    //定义一个 base 的对象
    base a;
    a.show();

    return 0;
}

编译运行：

提示：在实际开发中，一般在xxx.h中对类的所有接口进行声明，xxx.cpp中实现这些类内函数，main.cpp中调用该类的接口。

1、类成员函数分文件编写

1、main.cpp

#include <iostream>
//添加写好的类头文件
#include "base.h"

using namespace std;

int main()
{
    base a;
    a.show();

    base b(10);
    b.show();

    return 0;
}

2、base.h

#ifndef BASE_H
#define BASE_H

#include <iostream>

using namespace std;

//声明类接口
class base
{
    public:
        base();    //声明构造函数
        base(int date);    //声明带参的构造函数
        ~base();   //声明析构函数
        void show();    //声明函数方法
    private:
        int date;    //声明数据成员
};

#endif

3、base.cpp

#include "base.h"

//实现构造函数
base::base()
{
    cout << "base()" << endl;
    this->date = 0;
}

//实现带参构造函数
base::base(int date)
{
    cout << "base(int date)" << endl;
    this->date = date;
}

//实现析构函数
base::~base()
{
    cout << "~base()" << endl;
} 

//实现函数显示接口
void base::show()
{
    cout << "base show" << endl;
    cout << "date: " << date << endl;
}

编译运行：

2、练习

        设计一个计算器类，实现 加，减，乘，除。在设计该类的构造与析构，实现 声明在 xxx.h 实现在 xxx.cpp中。

1、calculate.h

#ifndef CALCULATE_H
#define CALCULATE_H

#include <iostream>

using namespace std;

//声明类接口
class calculate
{
    public:
        calculate();    //声明构造函数
        calculate(int a,int b);    //声明带参的构造函数
        ~calculate();   //声明析构函数
        void show();    //声明函数方法
        //设计接口
        int add();        //加法
        int Lessen();     //减法
        int Mul();        //乘法
        float Except();   //除法
    private:
        int a;    //声明数据成员
        int b;    //声明数据成员
};

#endif

2、calculate.cpp

#include "calculate.h"

calculate::calculate()
{
    a = 0;
    b = 0;
}

calculate::calculate(int a,int b)
{
    this->a = a;
    this->b = b;
}

calculate::~calculate()
{
    cout << "~calculate()" << endl;
}

void calculate::show()
{
    cout << "a: " << a << endl;
    cout << "b: " << b << endl;
}

int calculate::add()
{
    return a+b;
}

int calculate::Lessen()
{
    return a-b;
}

int calculate::Mul()
{
    return a*b;
}

float calculate::Except()
{
    return (float)a/b;
}

3、main.cpp

#include <iostream>
#include "calculate.h"

using namespace std;

int main()
{
    //定义一个计算器类
    calculate a(10,20);
    
    a.show();
    cout << "add: " << a.add() << endl;
    cout << "Lessen: " << a.Lessen() << endl;
    cout << "Mul: " << a.Mul() << endl;
    cout << "Except: " << a.Except() << endl;

    return 0;
}

编译运行：

十、拷贝构造函数（重点）

        当一个对象 对 另外一个对象 赋值 时，就会调用拷贝构造函数。（通俗的说，就是我们在定义一个对象时，拿一个对象去初始化一个对象。）

#include <iostream>

using namespace std;

class base
{
    private:
        int date;
    public:
        base()
        {
            date = 0;
        }

        base(int date):date(date)
        {
            
        }

        void show()
        {
            cout << "date: " << date << endl;
        }
};

int main()
{
    //定义一个对象 a
    base a(10086);

    //通过对象a 对 对象b 进行赋值，系统会调用 自动生成的拷贝构造函数
    base b = a;

    a.show();
    b.show();

    return 0;
}

分析：

浅拷贝：系统自动生成的拷贝构造函数。

1、浅拷贝会出现的问题

#include <iostream>

using namespace std;

class base
{
    private:
        char *p;
    public:
        base()
        {
            p = new char[1024];    //指向一个堆空间（需要析构函数释放堆空间）
        }

        ~base()
        {
            delete p;    //释放堆空间
        }
};

int main()
{
    //定义一个对象 a
    base a;

    //通过对象a 对 对象b 进行赋值，系统会调用 自动生成的拷贝构造函数
    base b = a;

    return 0;
}

这样子运行，程序就会死掉，有问题。分析如下：

        所以，当遇到这种情况（原来的对象里面指向了一块空间、原来的对象映射了一块空间、原来的对象打开了一个文件）时，就不能使用系统自动生成的拷贝构造函数（浅拷贝），这时候，我们需要重写拷贝构造函数（深拷贝）。

2、重写拷贝构造函数（深拷贝）

深拷贝：用户自定义的拷贝构造函数。

浅拷贝：系统自动生成的拷贝构造函数。

当一个构造函数传递的参数是当前类的引用时，那么该构造函数就是，拷贝函数。

语法：

class 类名

{

        public:

                类名（类名 &引用名）       //用户自定义的拷贝构造函数（深拷贝）

                {

                }

}

例子：

class base

{

        public:

        base(base &tmp)

        {

                cout << "哈哈哈，我是拷贝构造函数" << endl;

        }

}

//提示：当用户自定义拷贝构造函数后，系统就不会自动生成拷贝构造函数。

#include <iostream>

using namespace std;

class base
{
    private:
        int date;
    public:
        base()
        {
            date = 0;
        }

        base(int date):date(date)
        {
            
        }

        //自定义拷贝构造函数
        base(base &tmp)
        {
            cout << "hahahaha,base(base &tmp)" << endl;
            //手动赋值
            this->date = tmp.date;
        }

        void show()
        {
            cout << "date: " << date << endl;
        }
};

int main()
{
    //定义一个对象 a
    base a(10086);

    //通过对象a 对 对象b 进行赋值，调用拷贝构造函数
    base b = a;

    a.show();
    b.show();

    return 0;
}

3、深拷贝，实现堆空间拷贝

#include <iostream>

using namespace std;

class base
{
    private:
        char *p;
    public:
        base()
        {
            p = new char[1024];    //指向一个堆空间（需要析构函数释放堆空间）
            cout << "堆空间首地址：" << (void *)p << endl;
        }

        //重写拷贝构造函数，实现堆空间的拷贝 深拷贝
        base(base &t)
        {
            cout << "调用重写后的拷贝构造函数" << endl;
            //重新分配一块 1024 个字节的堆空间
            this->p = new char[1024];
            cout << "堆空间首地址：" << (void *)p << endl;
        }

        ~base()
        {
            delete p;    //释放堆空间
        }
};

int main()
{
    //定义一个对象 a
    base a;

    //通过对象a 对 对象b 进行赋值，系统会调用 自动生成的拷贝构造函数
    base b = a;

    return 0;
}

 分析：

阿哈、小吴
关注
专栏目录
简析析构函数
weixin_41927555的博客
11-20 176
析构函数百度百科定义： 析构函数(destructor) 与构造函数相反，当对象结束其生命周期，如对象所在的函数已调用完毕时，系统自动执行析构函数。析构函数往往用来做“清理善后” 的工作（例如在建立对象时用new开辟了一片内存空间，delete会自动调用析构函数后释放内存）。 解释很清楚， 析构函数作用：在释放内存时会调用类中的析构函数； 什么时候调用：这个没有确定的，当堆上内存不够时...
C++小结 析构函数、函数后面接冒号 等等
愚人国度的king的博客
04-21 2032
讲在前面 本小结有析构函数、C++函数后面接：的含义 、C++中public、protected及private用法、条件运算符、fabs()和abs()区别、C++中的结构体内的函数、类中成员函数声明后面接 const、C++中函数定义前加virtual关键字的作用。 析构函数 析构函数主要作用就是释放资源,避免内存泄漏。析构函数与构造函数对应，当对象结束其生命周期，如对象所在的函数已调用完毕时...
exit(0)析构函数不被执行
m0_62749134的博客
03-22 714
在编辑储存文件的时候突然发现一个bug， 为什么我在析构函数里编辑了存储程序却无法储存？ 仔细看了一下代码发现正常运行到exit(0)后就结束了， 难道exit(0)后,直接退出程序，就不执行析构函数了吗？ 对此我写了简单的代码测试了一下，结果是exit(0);后析构函数不在被执行！ #include <iostream> using namespace std; #include <fstream> class fun { public: fun(); ~fun
详谈构造函数加括号与不加括号的区别
11-26
如下所示： //首先定义一个构造函数Hello function Hello（）{ 　　alert（1）； } //定义一个函数表达式 var getName = function（）{ 　　alert（2）； } //实例化对象，下面这两个如果构造函数没有形参的话，实例化的时候构造函数可以不加括号（推荐加上）； var p = new Hello； var p1 = new Hello（）； //但是用下边的方式调用getName函数的时候，构造函数有没有括号可就不一样了； new Hello.getName（）； //这种执行顺序是先执行Hello.getName（），然后在使用new关
析构函数与构造函数的区别
qq_38769551的博客
03-27 4541
构造函数： 什么是构造函数？通俗的讲，在类中，函数名和类名相同的函数称为构造函数。它的作用是在建立一个对象时，作某些初始化的工作（例如对数据赋予初值）。C++允许同名函数，也就允许在一个类中有多个构造函数。如果一个都没有，编译器将为该类产生一个默认的构造函数。 构造函数上惟一的语法限制是它不能指定返回类型，甚至void 也不行。 不带参数的构造函数：一般形式为 类名 对象名(){函数体} 带参数的...
C/C++编程：析构函数
OceanStar的博客
05-09 2212
析构函数是一个成员函数，该函数在对象(自动变量)超出范围时自动调用，或者通过delete显式调用，每个类只能有一个析构函数。析构函数具有与类相同的名称，前面有一个波形符 (~)。~String()。如果未定义析构函数，则编译器将提供一个默认析构函数。对于许多类，这就足够了。仅当类将句柄存储到需要释放的系统资源或拥有它们指向的内存的指针时，才需要定义自定义析构函数。多个规则管理析构函数的声明。不接受任何参数不要将值返回 (或 void)。......
C++ 学习 ::【基础篇：14】：C++ 类的基本成员函数：析构函数的作用 及 自定义析构函数情形
weixin_53202576的博客
06-02 1276
**析构函数**：与构造函数功能相反，**析构函数不是完成对对象本身的销毁**，**局部对象销毁工作是由编译器完成的**。**而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作**。**注意：先销毁，再调用析构函数！**析构函数的使用情形：1. 如果没有主动动态申请空间一般不必写析构函数！、2. 若使用了 malloc 、new 等形式申请了空间需要手动写析构函数（手动释放空间）！**
C++析构函数
qq_74013365的博客
04-15 1775
类的6个默认成员函数：如果一个类中什么成员都没有，简称为空类。空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。
【C++ | 析构函数】类的析构函数详解
wkd_007的博客
06-06 1920
👉本文主要介绍类的析构函数的声明、定义、使用，以及析构函数在什么时候被调用。其实析构函数很简单，当你需要在对象被销毁时释放资源或内存时，就自己定义一个析构函数。
C++箴言:避免析构函数调用虚函数
07-26
### C++箴言：避免析构函数调用虚函数 #### 概述 在C++编程中，理解和遵循良好的设计模式对于确保程序的稳定性和可维护性至关重要。其中一个经常被提及的原则是“避免在析构函数中调用虚函数”。这一原则在C++语言...
详解C++中虚析构函数的作用及其原理分析
08-26
C++中虚析构函数的作用及其原理分析 C++中的虚析构函数是一种特殊的析构函数，用于避免内存泄露和防止内存泄露。当子类中有指针成员变量时，虚析构函数可以确保在删除基类指针时调用子类的析构函数，以释放子类中的...
解析C++中虚析构函数的作用
09-05
在C++编程语言中，虚析构函数（Virtual Destructor）是一个非常关键的概念，它主要用于处理多态性（Polymorphism）和动态类型（Dynamic Type）。本文将深入探讨虚析构函数的作用，以及为何在基类中声明虚析构函数是...
C++虚析构函数、纯虚析构函数
01-20
　因为在C++中，当一个派生类对象通过使用一个基类指针删除，而这个基类有一个非虚的析构函数，则结果是未定义的。运行时比较有代表性的后果是对象的派生部分不会被销毁。然而，基类部分很可能已被销毁，这导致了一...
c++语言基础：析构函数为什么要用virtual，static和const
qq_51046087的博客
06-27 1381
c++基础
析构函数与构造函数的区别联系
爱.NET
08-30 247
在备战C++的学习当中，由于很多都用到函数，再次要求自己加深对函数的理解，C++中知识是并不多，我们只有不断的理解函数的真正用法，下面学习才会顺水推舟！加油！ 析构函数(destructor) 与构造函数相反，当对象脱离其作用域时（例如对象所在的函数已调用完毕），系统自动执行析构函数。析构函数往往用来做“清理善后” 的工作（例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用d...
使用socket编程来实现一个简单的C/S模型（TCP协议）
caiji0169的博客
10-02 1685
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
【YOLOv8改进[SPPF]】使用SPPFCSPC替换SPPF模块 + 含全部代码和详细修改方式
静谧、淡雅
09-29 276
【YOLOv8改进[SPPF]】使用SPPFCSPC替换SPPF模块 + 含全部代码和详细修改方式
C++：图的最短路径问题
最新发布
han2205277149的博客
10-04 642
最短路径问题是图的一个比较典型的应用问题。例如，给定某公路网的n个城市以及这些城市之间相通公路的距离，能否找到城市A到城市B之间一条距离最近的通路呢？如果将城市用顶点表示城市间的公路用边表示，公路的长度作为边的权值，这个问题就归结为在网图中求顶点A和顶点B的最短路径。
C++的类型转换
2401_83427936的博客
09-27 1721
在自定义类型中重载string，这里涉及到文件的写入，string的str转c_str,弄成char类型才能插入直接重载int和bool的，就支持A转int值和bool了。这里加explcit不影响转换，更支持了与其他的相反，不加explcit，A不能转double，只能转int，加了就可以了。放宽了标准C++为了加强类型转换的可视性，引入了四种命名的强制类型转换操作符：static_cast用于非多态类型的转换（静态转换），编译器隐式执行的任何类型转换都可用。
C++教程：析构函数详解
"析构函数-c++语言教程" 析构函数是C++编程中一个至关重要的概念，它与构造函数在对象生命周期中的角色相反。析构函数的目的是在对象不再使用时，自动释放对象占用的内存资源，确保内存管理的正确性。在C++中，每个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值