C++的类与对象（三）

news2025/1/18 1:56:35

目录

类的6个默认成员函数

构造函数

语法

特性

析构函数

特性

对象的销毁顺序​​​​​​​

类的6个默认成员函数

问题：一个什么成员都没的类叫做空类，空类中真的什么都没有吗？

基本概念：任何类在什么都不写时，编译器会自动生成以下六个默认成员函数（无参的）

定义：用户没有显式实现，编译器会生成的成员函数称为默认成员函数

注意事项：如果我们自己实现了这些函数，那么编译器就不会生成默认的成员函数 

构造函数

产生原因：初始化容易被遗忘，且有时候会太麻烦

作用：完成初始化工作（Init）

class Date
{
public:
     void Init(int year, int month, int day)
     {
         _year = year;
         _month = month;
         _day = day;
     }

     void Print()
     {
         cout << _year << "-" << _month << "-" << _day << endl;
     }

private:
     int _year;
     int _month;
     int _day;
};

int main()
{
 Date d1;
 d1.Init(2022, 7, 5);
 d1.Print();
 Date d2;
 d2.Init(2022, 7, 6);
 d2.Print();
 return 0;
}

        对于Data类，之前我们会通过Init公有方法给对象设置日期，但每次创建对象时都需要调用该方法设置信息就显得有点麻烦，C++的构造函数就可以做到在对象创建时，就将信息设置进去

语法

1、构造函数是特殊的成员函数

2、构造函数的主要任务是在类实例化对象时初始化对象，而不是去开空间创建对象

3、构造函数的函数名与所在类的类名相同（类名是A，构造函数的名字就叫A，客随主便）

4、构造函数无返回值（不是void，而是连void都没）

5、对象实例化时编译器会自动调用合适的构造函数（对象后没括号就调无参构造函数，有实参就调用带参构造函数）

#include <iostream>
using namespace std;

 class Date
 {
  public:
      // 1.无参构造函数
      Date()
     {
        _year = 1;
        _month = 1;
        _day = 1;
     }

      void Print()
     {
        cout << _year << "-" << _month << "-" << _day << endl;
     }

  private:
      int _year;
      int _month;
      int _day;
 };

int main()
{
    Date d1; // 调用无参构造函数
    d1.Print();
    return 0;
}

6、构造函数可以重载

#include <iostream>
using namespace std;

class Date
{
public:
    // 1.无参构造函数
    Date()
    {
        _year = 1;
        _month = 1;
        _day = 1;
    }
    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
    // 2.带参构造函数
    Date(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
};

int main()
{
    Date d1; // 调用无参构造函数
    d1.Print();

    Date d2(2015, 1, 1); // 调用带参的构造函数
    d2.Print();
    return 0;
}

7、构造参数没有形参时，对象实例化时不能在对象后加括号

8、 对象实例化时必须调用构造函数，没有或者没有合适的构造函数就会报错（d1原本想要调用无参的构造函数，但是只有带参的构造函数，有了带参的构造参数编译器就算像提供不带参的默认构造参数也没办法了）

#include <iostream>
using namespace std;

class Date
{
public:
    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }

    //带参构造函数
    Date(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }

private:
    int _year;
    int _month;
    int _day;
};

int main()
{
    Date d1;
    d1.Print();
    return 0;
}

9、无参的构造函数和全缺省的构造函数在语法上因为函数重载可以同时存在，但是在实践中不可以，会造成调用歧义

#include <iostream>
using namespace std;

class Date
{
public:

    Date()
    {
        _year = 1;
        _month = 1;
        _day = 1;
    }
    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }

    Date(int year = 1, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
};

int main()
{
    Date d1;
    d1.Print();
    return 0;
}

特性

1（重点）、实例化对象时我们不写构造函数（包括默认构造函数和普通的构造函数），编译器就会生成默认构造函数，从而初始化对象，我们写了构造参数编译器就不会生成默认构造参数（普通的构造参数是指带参的构造参数）

2、编译器生成的默认构造参数什么也不干，为什么？（我们程序员没有定义一个构造参数是我们的问题，但是你编译器既然为我们自动生成了一个默认构造参数，你总得让它起点作用吧，就是只让成员变量初始化为0也行啊）

#include <iostream>
using namespace std;

class Date
{
public:
    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }

private:
    int _year;
    int _month;
    int _day;
};

int main()
{
    Date d1;
    d1.Print();
    return 0;
}

这是因为，C++将数据分为了内置（基本）类型和自定义类型：

  • 内置类型：语言自身定义的类型（int、char、double、任何类型的指针等）
  • 自定义类型：程序员根据自己需求定义的类型（struct、class等）

3、C++98规定编译器生成的默认构造函数（程序员没提过时），对内置类型不做处理，对自定义类型会去调用它的！！默认构造函数！！（一定是默认构造函数而不是普通的构造函数）

#include <iostream>
using namespace std;

//编译器对自定义类型会调用它的默认构造
class A
{
public:
    A()
    {
        cout << "A()" << endl;
        _a = 0;
    }
private:
    int _a;

};

//编译器对内置类型不做处理
class Date
{
public:

//这里没有自定义构造函数，编译器默认生成构成函数

    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }

private:
    int _year;
    int _month;
    int _day;

    A _aa;
};

int main()
{
    Date d1;
    d1.Print();
    return 0;
}

大致步骤如下：
①Date d1：实例化对象d1

②Data{}：编译器自动生成默认构造函数，并开始对成员变量开始初始化 

③__aa：_aa的类型是A类，属于自定义类型，调用A类的提供的！默认！构造函数

如果A类也没提供默认构造函数，那么_aa也是随机值（虽然编译器也可以为A提供但是没用）：

#include <iostream>
using namespace std;

class A
{
public:
    int getA() // 添加一个公共方法以获取 _a 的值
    {
        return _a;
    }

private:
    int _a;

};

class Date
{
public:

    void Print()
    {
        cout << "Year: " << _year << ", Month: " << _month << ", Day: " << _day << endl;
        cout << "Value of '_aa' member variable in class 'Date': " << _aa.getA() << endl; // 打印_aa对象内部_a变量的值
    }

private:
    int _year;
    int _month;
    int	_day;

    A _aa;
};


int main()
{
    Date d1;
    d1.Print();
    return 0;
}

④_year、_month、_day：是int类型，属于内置类型，不做任何操作，结果为随机值

为什么在调试时，先初始化对象_aa？

答：C++中，类的成员变量初始化顺序是由它们在类中声明的顺序决定的，而不是由它们在构造函数初始化列表中出现的顺序决定

注意事项：有些新的编译器会对内置类型也做处理，但是C++的标准没有规定 

4、C++11规定内置类型的成员变量声明时可给默认值（为C++98打补丁，没给的依然是随机值）

#include <iostream>
using namespace std;

class A
{
public:
    A()
    {
        cout << "A()" << endl;
        _a = 0;
    }

private:
    int _a;

};

class Date
{
public:
    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }

private:
    //声明时给缺省值
    int _year = 2024;
    int _month =3 ;
    int _day;

    A _aa;
};

int main()
{
    Date d1;
    d1.Print();
    return 0;
}

5、 只有无参 / 全缺省构造函数、编译器默认生成的构造函数都叫默认构造函数，其余的都是构造函数而不是默认构造函数，默认构造函数只能有一个 

//默认构造参数只能有一个：
#include <iostream>
using namespace std;
class Date
{
public:
    //无参的构造函数是默认构造函数
    Date()
    {
        _year = 1900;
        _month = 1;
        _day = 1;
    }

    //全缺省的构造函数是默认构造函数
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
};

int main()
{
    Date d1;
    return 0;
}

//成员变量在声明时未给缺省值
#include <iostream>
using namespace std;
class Date
{
public:

    Date(int year = 1, int month , int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }

    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }

     ~Date()
    {
         cout << this << endl;
         cout << " ~Date()" << endl;
    }

private:
    int _year;
    int _month;
    int _day;

};

int main()
{
    Date d1;
    d1.Print();

    return 0;
}


//成员变量在声明时提供缺省值：
#include <iostream>
using namespace std;
class Date
{
public:

    Date(int year = 1, int month , int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }

    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }

     ~Date()
    {
         cout << this << endl;
         cout << " ~Date()" << endl;
    }

private:
    int _year = 1;
    int _month = 1;
    int _day =1;
};

int main()
{
    Date d1;
    d1.Print();
    return 0;
}

为什么成员变量在声明时已经给了缺省值，为什么Data还要再给？

答：虽然为 Date 类中的私有成员变量 _year, _month, 和 _day 提供了默认值（1, 1, 1），但这些缺省值仅在默认构造函数未初始化成员变量时才会被用于初始化成员变量。实例化d1时，类中定义了一个貌似是全缺省的构造函数，因此编译器不会自动生成默认构造函数（那个位置上已经有人了，只是那个人有点缺陷），且因为该貌似的全缺省构造函数缺少两个缺省值所以报错

#include <iostream>
using namespace std;

class Time
{
public:
    //带参构造函数，不是默认构造函数
    Time(int hour)
    {
        cout << "Time()" << endl;
        _hour = 0;
        _minute = 0;
        _second = 0;
    }
private:
    int _hour;
    int _minute;
    int _second;
};

class Date
{
private:
    //声明给缺省值
    int _year;
    int _month;
    int _day;

    Time _t;
};

int main() 
{
    Date d;
    return 0;
}

为什么会提示_t没有默认构造函数？

答：实例化对象d时，Date类没给构造函数，编译器自动生成默认构造函数（无参），_year、_month、_day是内置类型不做处理，_t是自定义类型会调用Time类的默认构造函数，但是Time类中已经有了一个带参的构造函数（普通构造函数）所以Time类中不会有默认构造函数了（只要我们写了构造函数，即使它是带参的普通构造函数，编译器就不会给我们提供默认构造参数了）故报错

 结论：绝大多数场景下都需要自己实现构造函数，且更推荐用全缺省构造函数​​​​​​​

析构函数

 产生原因：需要人为销毁的空间容易忘记销毁，内存泄漏可能不会报错

#include <iostream>
using namespace std;
class Date
{
public:
    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }

    ~Date()
    {
        cout << this << endl;
        cout << " ~Date()" << endl;
    }

private:
    //声明给缺省值
    int _year = 1;
    int _month = 1;
    int _day = 1;

};

void func()
{
    Date d2;
}

class Stack
{
public:
    Stack(size_t capacity = 4)
    {
        _array = (int*)malloc(sizeof(int*) * capacity);
        if (NULL == _array)
        {
            perror("malloc申请空间失败!!!");
            return;
        }
        _capacity = capacity;
        _size = 0;
    }
    void Push(int data)
    {
        // CheckCapacity();
        _array[_size] = data;
        _size++;
    }

    //~Stack()
    //{
    //    cout << "~Stack()" << endl;
    //    if (_array)
    //    {
    //        free(_array);
    //        _array = nullptr;
    //    }
    //    _size = _capacity = 0;

    //}

private:
    int* _array;
    int _capacity;
    int _size;
};

int main()
{
    func();
    Date d1;
    Stack st1; //内存泄漏
    return 0;
}

        如果Stack类中没有自定义的析构函数就会出现内存泄漏，因为我们即没有定义Destory函数去销毁在堆上开辟的空间，析构函数也不起作用

作用：完成清理工作（Destory）

基本概念：析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的，而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作

特性

1、析构函数名是在类名前加上字符~

2、析构函数无参数无返回值类型

3、一个类只能有一个析构函数，若未显示定义，编译器会自动生成默认的析构函数

4、析构函数不能重载（清理一遍数据就应该被清理完成）

5、对象生命周期结束（函数结束）时，程序会自动调用析构函数

#include <iostream>
using namespace std;
class Date
{
public:

     ~Date()
    {
         cout << this << endl;
         cout << " ~Date()" << endl;
    }

private:
    //声明给缺省值
    int _year = 1;
    int _month = 1;
    int _day =1;
};

void func()
{
    Date d2;//实例化对象d2
}//函数结束，调用析构函数销毁数据

int main()
{
    func();  
    Date d1;//实例化对象d1
    return 0;
}//函数结束，调用析构函数销毁数据

6、编译器生成的析构函数，对内置成员变量不做处理，对自定成员变量会调用它的析构函数

#include <iostream>
using namespace std;

class Time
{
public:
	~Time()
	{
		cout << "~Time()" << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
};

class Date
{
private:
	// 基本类型(内置类型)
	int _year = 1970;
	int _month = 1;
	int _day = 1;
	// 自定义类型
	Time _t;
};
int main()
{
	Date d;
	return 0;
}

在main函数中没有直接创建Time类的对象，为什么最后会调用Time类的析构函数？

答：main函数中创建了Date类的对象d，d中包含了四个成员变量，其中_year、_month、_day是内置类型的成员变量，销毁时不需要人为清理资源main函数结束后系统直接回收，而_t是Time类的对象，为了销毁_t就需要Data类的析构函数，但是我们并没有给Date类定义析构函数，所以编译器就会为Date类提供一个默认析构函数，该函数对于自定义类型的成员变量就会调用它（_t）的析构函数（Time提供的析构函数），

7、后定义的先析构（定义->开辟帧栈->压栈，栈后进先出）

#include <iostream>
using namespace std;
class Date
{
public:
    ~Date()
    {
        cout << this << endl;
        cout << " ~Date()" << endl;
    }

private:
    //声明给缺省值
    int _year = 1;
    int _month = 1;
    int _day = 1;

};

class Stack
{
public:
    Stack(int capacity = 4)
    {
        _array = (int*)malloc(sizeof(int*) * capacity);
        if (NULL == _array)
        {
            perror("malloc申请空间失败!!!");
            return;
        }
        _capacity = capacity;
        _size = 0;
    }
    void Push(int data)
    {
        // CheckCapacity();
        _array[_size] = data;
        _size++;
    }

    ~Stack()
    {
        cout << this << endl;
        cout << "~Stack()" << endl;
        if (_array)
        {
            free(_array);
            _array = nullptr;
        }
        _size = _capacity = 0;

    }
private:
    int* _array;
    int _capacity;
    int _size;
};

int main()
{
    Date d1;
    Stack st1;
    return 0;
}

 8、如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数（Date类）；有资源申请时，一定要写，否则会造成资源泄漏（Stack类）

 9、自定义类型的本质还是内置类型

对象的销毁顺序

从左至右：局部变量（后定义的先析构）——>局部的静态——>全局（后定义的先析构）

当成栈来理解，先进后出 

#include <iostream>
using namespace std;
class Date
{
public:
    //全缺省构造函数
    Date(int year = 1)
    {
        _year = year;
    }

    ~Date()
    {
        cout << " ~Date()->" << _year << endl;
    }

private:
    //声明给缺省值
    int _year;
    int _month;
    int _day;

};

Date d5(5);//全局
Date d6(6);//全局
static Date d7(7);//全局
static Date d8(8);//全局

void func()
{
    Date d3(3);//局部
    static Date d4(4);//局部的静态
}

int main() 
{
    Date d1(1);//局部
    Date d2(2);//局部
    func();
    return 0;
}




#include <iostream>
using namespace std;
class Date
{
public:
    //全缺省构造函数
    Date(int year = 1)
    {
        _year = year;
    }

    ~Date()
    {
        cout << " ~Date()->" << _year << endl;
    }

private:
    int _year;
    int _month;
    int _day;

};

int main()
{
    Date d1(1);//局部
    Date d2(2);//局部
    static Date d3(3);//局部的静态
    return 0;
}

~over~

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1496556.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【Linux C | 网络编程】多播的概念、多播地址、UDP实现广播的C语言例子

【Linux C | 网络编程】多播的概念、多播地址、UDP实现广播的C语言例子

&#x1f601;博客主页&#x1f601;&#xff1a;&#x1f680;https://blog.csdn.net/wkd_007&#x1f680; &#x1f911;博客内容&#x1f911;&#xff1a;&#x1f36d;嵌入式开发、Linux、C语言、C、数据结构、音视频&#x1f36d; &#x1f923;本文内容&#x1f923;&a…
阅读更多...
[OpenWrt 22.03] ttylogin添加登录密码与禁止登录的配置

[OpenWrt 22.03] ttylogin添加登录密码与禁止登录的配置

ttylogin 的使用 Openwrt 串口默认是没有密码的。Openwrt启动后，一个默认的密码将被启用去保护ssh登录和页面（http）登录，而串口登录密码却是空缺的。 对于 Openwrt，当内核初始化后，就会启动第一个进程 init，init进程会进行一系列的系统初始化工作，然后会读取 /etc/in…
阅读更多...
vue 使用element plus 菜单时，折叠文字不消失

vue 使用element plus 菜单时，折叠文字不消失

问题&#xff1a; 菜单折叠时&#xff0c;title文本无法消失&#xff0c;同时下拉箭头还会存在 解决方法&#xff1a; 查看项目中是否有div标签 原因 div和p标签都是块级元素&#xff0c;可能是这个原因 所以把项目中的p标签改为span标签 div改为template即可解决
阅读更多...
java当中的栈和队列

java当中的栈和队列

一、Java中的栈 1.常用方法 注意上面的peek()方法和pop()方法的区别&#xff01; 2.实例 import java.util.Stack; public class StackTest { public static void main(String[] args) { Stack<String> stack new Stack<String>(); System.out.println(&qu…
阅读更多...
Clion调试QT程序qDebug()、cout控制台无输出的可能解决方法

Clion调试QT程序qDebug()、cout控制台无输出的可能解决方法

qDebug()不输出 在当前项目配置中添加一个环境变量 方法一、单独为配置 QT_ASSUME_STDERR_HAS_CONSOLE1 方法二、全局配置&#xff08;系统变量&#xff09; 一劳永逸 效果 cout不输出 Clion在debug调试C/C的时候&#xff0c;printf/cout不会实时输出情况 结果同上~ 谢阅…
阅读更多...
NoSQL--2.MongoDB配置（Windows版）

NoSQL--2.MongoDB配置（Windows版）

目录 2.MongdoDB配置 2.1 Windows环境下操作 2.1.1 注册MongDB Atlas&#xff1a; 2.1.2 MongoDB Community Server Download&#xff1a; 2.1.3 启动MondgoDB服务&#xff1a; 2.1.3.1 命令行参数的方式启动MongoDB服务&#xff1a; 2.1.3.2 使用配置文件方式启动Mongo…
阅读更多...
电脑怎么改照片大小kb？让你的照片尺寸更合适！

电脑怎么改照片大小kb？让你的照片尺寸更合适！

随着数字摄影的普及&#xff0c;我们经常需要处理各种大小的照片。有时候&#xff0c;为了上传至特定的网站或平台&#xff0c;或者为了节省存储空间&#xff0c;我们需要调整照片的大小&#xff0c;特别是其KB&#xff08;千字节&#xff09;值。那么&#xff0c;电脑怎么改照…
阅读更多...
react tab选项卡吸顶实现

react tab选项卡吸顶实现

react tab选项卡吸顶实现&#xff0c;直接上代码&#xff08;代码有注释&#xff09; tsx代码 /* eslint-disable react-hooks/exhaustive-deps */ import React, { useEffect, useState } from "react"; import DocumentTitle from react-document-title import s…
阅读更多...
【HTML】HTML基础7.2（有序列表）

【HTML】HTML基础7.2（有序列表）

目录 标签 效果 注意 标签 <ol> <li>列表内容</li> <li>列表内容</li> <li>列表内容</li> <li>列表内容</li> 。。。。。。 </ol> 效果 代码 <ol><li>银河护卫队 10000000000</li><l…
阅读更多...
关于 selinux 规则

关于 selinux 规则

1. 查看selinux状态 SELinux的状态&#xff1a; enforcing&#xff1a;强制&#xff0c;每个受限的进程都必然受限 permissive&#xff1a;允许&#xff0c;每个受限的进程违规操作不会被禁止&#xff0c;但会被记录于审计日志 disabled&#xff1a;禁用 相关命令&#xf…
阅读更多...
算法DFS 复习

算法DFS 复习

思路&#xff1a;for 代表的是每一位的纵向&#xff0c;数字变化&#xff0c;dfs 代表的是横向的&#xff0c;位置变化。vis 来做到每个枚举的数不重复&#xff0c;并且要在搜索前记录&#xff0c;搜索后还原。模拟该样例 dfs3 的时候是输出&#xff0c;dfs0&#xff0c;1&…
阅读更多...
链路负载均衡之策略路由

链路负载均衡之策略路由

一、策略路由的概念 一般来说&#xff0c;防火墙是根据目的地址查看路由&#xff0c;这种情况下只能根据报文的目的地址为用户提供服务&#xff0c;没办法更加灵活对内网用户进行区分&#xff0c;让不同用户流量走不同的链路转发&#xff0c;如根据源地址、应用协议等区分流量…
阅读更多...
Django模型层(附带test环境)

Django模型层(附带test环境)

Django模型层(附带test环境) 目录 Django模型层(附带test环境)开启测试环境数据的增加数据的删除修改数据查询数据查询所有数据去重查询排序查询统计剔除指定数据多表查询校验数据是否存在字段的筛选查询 开启测试环境 首先在app下找到tests.py文件并进入 MyDJ.settings要换成…
阅读更多...
第3部分 原理篇3可验证凭证（VC）（1）

第3部分 原理篇3可验证凭证（VC）（1）

3.3. 可验证凭证 3.3.1. 本节内容概述 本聪老师&#xff1a;今天开始去中心化身份中另一个最重要的概念可验证凭证&#xff08;verifiable credential&#xff09;的学习。凭证&#xff0c;也就是证件&#xff0c;在人类生活中不可或缺。可验证凭证实现了凭证的机器可读、加密…
阅读更多...
车牌定位识别企业版

车牌定位识别企业版

车牌定位识别企业版&#xff0c;只需要OPENCV&#xff0c;采用YOLOV8NANO检测车牌区域&#xff0c;然后使用PADDLE OCR检测车牌&#xff0c;能识别各国车牌&#xff0c;支持C,PYTHON开发 车牌定位识别企业版&#xff0c;只需要OPENCV&#xff0c;支持C,python
阅读更多...
3.5 力扣 交错字符串

3.5 力扣 交错字符串

97. 交错字符串 给定三个字符串 s1、s2、s3&#xff0c;请你帮忙验证 s3 是否是由 s1 和 s2 交错 组成的。 两个字符串 s 和 t 交错 的定义与过程如下&#xff0c;其中每个字符串都会被分割成若干 非空 子字符串&#xff1a; s s1 s2 ... snt t1 t2 ... tm|n - m| &…
阅读更多...
基于springboot+vue的经方药食两用服务平台

基于springboot+vue的经方药食两用服务平台

博主主页&#xff1a;猫头鹰源码 博主简介&#xff1a;Java领域优质创作者、CSDN博客专家、阿里云专家博主、公司架构师、全网粉丝5万、专注Java技术领域和毕业设计项目实战&#xff0c;欢迎高校老师\讲师\同行交流合作 ​主要内容&#xff1a;毕业设计(Javaweb项目|小程序|Pyt…
阅读更多...
Vmware创建共享文件夹

Vmware创建共享文件夹

具体设置步骤如下&#xff1a; 打开 “设置 -> 选项 -> 共享文件夹” 点击 “选项 -> 共享文件夹 ->选择总是开启 ->添加” 添加共享文件夹 选择主机路径和设置名称 选择启用此共享&#xff0c;并且点击完成退出。 挂载操作 在root用户下执行具体命令如下&…
阅读更多...
HTTP有什么缺陷，HTTPS是怎么解决的

HTTP有什么缺陷，HTTPS是怎么解决的

缺陷 HTTP是明文的&#xff0c;谁都能看得懂&#xff0c;HTTPS是加了TLS/SSL加密的&#xff0c;这样就不容易被拦截和攻击了。 SSL是TLS的前身&#xff0c;他俩都是加密安全协议。前者大部分浏览器都不支持了&#xff0c;后者现在用的多。 对称加密 通信双方握有加密解密算法…
阅读更多...
Linux 开发工具 yum、git、gdb

Linux 开发工具 yum、git、gdb

目录 一、yum 1、软件包 2、rzsz 3、注意事项 4、查看软件包 5、安装软件 6、卸载软件 二、git操作 1、克隆三板斧 2、第一次使用会出现以下情况&#xff1a; 未配置用户名和邮箱&#xff1a; push后弹出提示 三、gdb使用 1、背景 2、使用方法 例一&#xff1a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023