【C++庖丁解牛】默认成员函数

📙 作者简介 ：RO-BERRY
📗 学习方向：致力于C、C++、数据结构、TCP/IP、数据库等等一系列知识
📒 日后方向 : 偏向于CPP开发以及大数据方向，欢迎各位关注，谢谢各位的支持

请添加图片描述

目录

  • 前言
  • 1. 构造函数
    • 1.1 概念
    • 1.2 特性
  • 2.析构函数
    • 2.1 概念
    • 2.2 特性
  • 3. 拷贝构造函数
    • 3.1 概念
    • 3.2 特征
  • 4.赋值运算符重载
    • 4.1 运算符重载
    • 4.2 赋值运算符重载
    • 4.3 前置++和后置++重载
  • 5.const成员
  • 6.取地址及const取地址操作符重载

前言

如果一个类中什么成员都没有，简称为空类。
空类中真的什么都没有吗？
并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。

这六个函数包括：构造函数、析构函数、拷贝构造函数、赋值运算符重载、普通对象取地址重载、const修饰对象的取地址重载。

所有的默认成员函数都是可以由编译器自己生成的，编译器会自己生成一个默认的函数。同时我们也可以自己定义这些函数，那么编译器就会直接使用我们定义好的函数而不会自己再生成了。

1. 构造函数

1.1 概念

对于以下Date类：

#include<iostream>
using namespace std;
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;
}

对于Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？

这个时候就要引入我们的构造函数

构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。

1.2 特性

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造,但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。
其特征如下：

  1. 函数名与类名相同。
  2. 无返回值。
  3. 对象实例化时编译器自动调用对应的构造函数。
  4. 构造函数可以重载。
class Date
{
public:// 1.无参构造函数//Date()//{//      _year = 1;//      _month = 1;//      _day = 1;//} 2.带参构造函数//Date(int year, int month, int day)//{//      _year = year;//      _month = month;//      _day = day;//}
//这两个函数构成重载，但是无参调用存在歧义，不能同时存在//Date(int year, int month, int day)//{//      _year = year;//      _month = month;//      _day = day;//}//Date(int year=1, int month=1, int day=1) 全缺省//{//      _year = year;//      _month = month;//      _day = day;//}Date(int year=1, int month=1, int day=1) //全缺省{_year = year;_month = month;_day = day;}
//使用全缺省这里可以传一个两个三个或者不传，就比较方便
private:int _year;int _month;int _day;
};
void TestDate()
{Date d1; // 调用无参构造函数//这里可不可以写Date d1（）//不可以 这里如果这样写就和函数声明分不开了//比如Date f()    -->函数名为f。返回值为DateDate d2(2015, 1, 1); // 调用带参的构造函数// 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明// 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象// warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)Date d3();
}
  1. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦
    用户显式定义编译器将不再生成。
class Date
{
public:/*// 如果用户显式定义了构造函数，编译器将不再生成Date(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类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数// 将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生成// 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用Date d1;return 0;
}
  1. 关于编译器生成的默认成员函数，很多童鞋会有疑惑：不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？对象调用了编译器生成的默认构造函数，但是对象_year/_month/_day依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用？？

解答**：C++把类型分成内置类型(基本类型)和自定义类型。**内置类型就是语言提供的数据类
型，如：int/char…，自定义类型就是我们使用class/struct/union等自己定义的类型，看看
下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员
函数

class Time
{
public:Time(){cout << "Time()" << endl;   //运行构造函数会输出Time()_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;
}

在这里插入图片描述

注意：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在
类中声明时可以给默认值。

class Time
{
public:Time(){cout << "Time()" << endl;_hour = 0;_minute = 0;_second = 0;}
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;
}
  1. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
    注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为
    是默认构造函数。
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;
};
// 以下测试函数能通过编译吗？
void Test()
{Date d1;
}

报错：Date类里有多个默认构造函数
在这里插入图片描述

2.析构函数

2.1 概念

通过前面构造函数的学习，我们知道一个对象是怎么来的，那一个对象又是怎么没呢的？

析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由
编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

2.2 特性

析构函数是特殊的成员函数，其特征如下：

  1. 析构函数名是在类名前加上字符 ~。
  2. 无参数无返回值类型。
  3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构
    函数不能重载
  4. 对象生命周期结束时，C++编译系统系统自动调用析构函数
typedef int DataType;
class Stack
{
public:Stack(size_t capacity = 3){_array = (DataType*)malloc(sizeof(DataType) * capacity);if (NULL == _array){perror("malloc申请空间失败!!!");return;}_capacity = capacity;_size = 0;}void Push(DataType data){// CheckCapacity();_array[_size] = data;_size++;}// 其他方法...~Stack(){if (_array){free(_array);_array = NULL;_capacity = 0;_size = 0;}}
private:DataType* _array;int _capacity;int _size;
};
int main()
{Stack s;s.Push(1);s.Push(2);return 0;
}
  • 初始化Stack
    在这里插入图片描述
  • 插入数据
    在这里插入图片描述
  • 程序结束
    在这里插入图片描述
  1. 关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器
    生成的默认析构函数，对自定类型成员调用它的析构函数。
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;
}

程序运行结束后输出：~time()

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

  • 因为：main方法中创建了date对象d，而d中包含4个成员变量，其中_year, _month, _day三个是 内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；
  • 而_t是time类对象，所以在d销毁时，要将其内部包含的time类的_t对象销毁，所以要调用time类的析构函数。
  • 但是：main函数 中不能直接调用time类的析构函数，实际要释放的是date类对象，所以编译器会调用date类的析构函数，而date没有显式提供，则编译器会给date类生成一个默认的析构函数，目的是在其内部调用time 类的析构函数，即当date对象销毁时，要保证其内部每个自定义对象都可以正确销毁
  • main函数中并没有直接调用time类析构函数，而是显式调用编译器为date类生成的默认析构函数

注意：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数

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

3. 拷贝构造函数

3.1 概念

在现实生活中，可能存在一个与你一样的自己，我们称其为双胞胎。
在这里插入图片描述

那在创建对象时，可否创建一个与已存在对象一某一样的新对象呢？

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。

3.2 特征

拷贝构造函数也是特殊的成员函数，其特征如下：

  1. 拷贝构造函数是构造函数的一个重载形式。
  2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，
    因为会引发无穷递归调用。
class Date
{
public:Date(int year = 1900, int month = 1, int day = 1){_year = year;_month = month;_day = day;}// Date(const Date& d)   // 正确写法Date(const Date& d)   // 错误写法：编译报错，会引发无穷递归{_year = d._year;_month = d._month;_day = d._day;}
private:int _year;int _month;int _day;
};
int main()
{Date d1;Date d2(d1);return 0;
}

在这里插入图片描述

  1. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按
    字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
class Time
{
public:Time(){_hour = 1;_minute = 1;_second = 1;}Time(const Time& t){_hour = t._hour;_minute = t._minute;_second = t._second;cout << "Time::Time(const 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 d1;// 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数// 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数Date d2(d1);return 0;
}

注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定
义类型是调用其拷贝构造函数完成拷贝的。

  1. 编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？
    当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？

这里会发现下面的程序会崩溃掉，这里就需要我们以后讲的深拷贝去解决。


typedef int DataType;
class Stack
{
public:Stack(size_t capacity = 10){_array = (DataType*)malloc(capacity * sizeof(DataType));if (nullptr == _array){perror("malloc申请空间失败");return;}_size = 0;_capacity = capacity;}void Push(const DataType& data){// CheckCapacity();_array[_size] = data;_size++;}~Stack(){if (_array){free(_array);_array = nullptr;_capacity = 0;_size = 0;}}
private:DataType* _array;size_t _size;size_t _capacity;
};
int main()
{Stack s1;s1.Push(1);s1.Push(2);s1.Push(3);s1.Push(4);Stack s2(s1);return 0;
}

在这里插入图片描述

注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请
时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

  1. 拷贝构造函数典型调用场景：
  • 使用已存在对象创建新对象
  • 函数参数类型为类类型对象
  • 函数返回值类型为类类型对象

class Date
{
public:Date(int year, int minute, int day){cout << "Date(int,int,int):" << this << endl;}Date(const Date& d){cout << "Date(const Date& d):" << this << endl;}~Date(){cout << "~Date():" << this << endl;}
private:int _year;int _month;int _day;
};
Date Test(Date d)
{Date temp(d);return temp;
}
int main()
{Date d1(2022, 1, 13);Test(d1);return 0;
}

在这里插入图片描述

为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用
尽量使用引用。

在这里插入图片描述

4.赋值运算符重载

4.1 运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)

注意：

  • 不能通过连接其他符号来创建新的操作符：比如operator@
  • 重载操作符必须有一个类类型参数
  • 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义
  • 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
  • .* :: sizeof ?: . 注意这5个运算符不能重载。这个经常在笔试选择题中出现。
class Date
{
public:Date(int year = 1900, int month = 1, int day = 1){_year = year;_month = month;_day = day;}//private:int _year;int _month;int _day;
};
// 这里会发现运算符重载成全局的就需要成员变量是公有的，那么问题来了，封装性如何保证？
// 这里其实可以用我们后面学习的友元解决，或者干脆重载成成员函数。
bool operator==(const Date& d1, const Date& d2)
{return d1._year == d2._year&& d1._month == d2._month&& d1._day == d2._day;
}
void Test()
{Date d1(2018, 9, 26);Date d2(2018, 9, 27);cout << (d1 == d2) << endl;
}class Date
{
public:Date(int year = 1900, int month = 1, int day = 1){_year = year;_month = month;_day = day;}// bool operator==(Date* this, const Date& d2)// 这里需要注意的是，左操作数是this，指向调用函数的对象bool operator==(const Date & d2){return _year == d2._year;&& _month == d2._month&& _day == d2._day;}
private:int _year;int _month;int _day;
};

4.2 赋值运算符重载

  1. 赋值运算符重载格式
  • 参数类型：const T&，传递引用可以提高传参效率
  • 返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
  • 检测是否自己给自己赋值
  • 返回*this ：要复合连续赋值的含义
class Date
{
public:Date(int year = 1900, int month = 1, int day = 1){_year = year;_month = month;_day = day;}Date(const Date& d){_year = d._year;_month = d._month;_day = d._day;}Date& operator=(const Date& d){if (this != &d){_year = d._year;_month = d._month;_day = d._day;}return *this;}
private:int _year;int _month;int _day;
};
  1. 赋值运算符只能重载成类的成员函数不能重载成全局函数
class Date
{
public:Date(int year = 1900, int month = 1, int day = 1){_year = year;_month = month;_day = day;}int _year;int _month;int _day;
};
// 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
Date& operator=(Date& left, const Date& right)
{if (&left != &right){left._year = right._year;left._month = right._month;left._day = right._day;}return left;
}
// 编译失败：
// error C2801: “operator =”必须是非静态成员

原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。

  1. 用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。
class Time
{
public:Time(){_hour = 1;_minute = 1;_second = 1;}Time& operator=(const Time& t){if (this != &t){_hour = t._hour;_minute = t._minute;_second = t._second;}return *this;}
private:int _hour;int _minute;int _second;
};
class Date
{
private:// 基本类型(内置类型)int _year = 1970;int _month = 1;int _day = 1;// 自定义类型Time _t;
};
int main()
{Date d1;Date d2;d1 = d2;return 0;
}

既然编译器生成的默认赋值运算符重载函数已经可以完成字节序的值拷贝了，还需要自己实现吗？当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？

// 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
typedef int DataType;
class Stack
{
public:Stack(size_t capacity = 10){_array = (DataType*)malloc(capacity * sizeof(DataType));if (nullptr == _array){perror("malloc申请空间失败");return;}_size = 0;_capacity = capacity;}void Push(const DataType& data){// CheckCapacity();_array[_size] = data;_size++;}~Stack(){if (_array){free(_array);_array = nullptr;_capacity = 0;_size = 0;}}
private:DataType* _array;size_t _size;size_t _capacity;
};
int main()
{Stack s1;s1.Push(1);s1.Push(2);s1.Push(3);s1.Push(4);Stack s2;s2 = s1;return 0;
}

注意：如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必
须要实现。

在这里插入图片描述

4.3 前置++和后置++重载

class Date
{
public:Date(int year = 1900, int month = 1, int day = 1){_year = year;_month = month;_day = day;}// 前置++：返回+1之后的结果// 注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率Date& operator++(){_day += 1;return *this;}// 后置++：// 前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载// C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递// 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后给this + 1//       而temp是临时对象，因此只能以值的方式返回，不能返回引用Date operator++(int){Date temp(*this);_day += 1;return temp;}
private:int _year;int _month;int _day;
};
int main()
{Date d;Date d1(2022, 1, 13);d = d1++;    // d: 2022,1,13   d1:2022,1,14d = ++d1;    // d: 2022,1,15   d1:2022,1,15return 0;
}

5.const成员

将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。
在这里插入图片描述
我们来看看下面的代码

class Date
{
public:Date(int year, int month, int day){_year = year;_month = month;_day = day;}void Print(){cout << "Print()" << endl;cout << "year:" << _year << endl;cout << "month:" << _month << endl;cout << "day:" << _day << endl << endl;}void Print() const{cout << "Print()const" << endl;cout << "year:" << _year << endl;cout << "month:" << _month << endl;cout << "day:" << _day << endl << endl;}
private:int _year; // 年int _month; // 月int _day; // 日
};
void Test()
{Date d1(2022, 1, 13);d1.Print();const Date d2(2022, 1, 13);d2.Print();
}

我们定义一个const对象Date d1
我们再实现成员函数print却无法实现这是为什么?

在这里插入图片描述
在这里就是权限放大是不可以访问到加了const的类对象

所以我们开发者就有了一个解决方案，那就是在函数后面加上const

在这里插入图片描述
这样操作const对象就能调用了，那么我们的非const对象又能不能调用呢？
我们调试了发现是可以的，所以我们在函数后面加const之后，既可以访问一般类对象也可以访问加了
const类对象

在这里就是权限的缩小
也就意味着权限可以调用同权限的函数也可以实现权限缩小，就是不可以进行权限放大

那么是不是所有的成员函数都需要加const呢？

并不是这样的
我们一般进行运算法重载的成员函数后面需要加const
在这里我们说一下成员函数定义的原则：
1.能定义成const的成员函数都应该定义成const，这样const对象和非const对象都可以调用
2.要修改成员变量的函数，不能定义成const

有人会问那么那些不加const的函数那么加const的类对象不是无法访问？

对，确实是无法访问，但是const对象本来就不支持修改成员变量，那么不能访问也当然是很合理的啊

6.取地址及const取地址操作符重载

这两个默认成员函数一般不用重新定义 ，编译器默认会生成。

class Date
{
public:Date* operator&(){return this;}const Date* operator&()const{return this;}
private:int _year; // 年int _month; // 月int _day; // 日
};

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需
要重载，比如想让别人获取到指定的内容！

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

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

相关文章

职场高薪 |「中高级测试」面试题

职场高薪 |「中高级测试」面试题

【软件测试面试突击班】2024吃透软件测试面试最全八股文攻略教程&#xff0c;一周学完让你面试通过率提高90%&#xff01;&#xff08;自动化测试&#xff09; 一.基础题 1.测试用例你一般是怎么设计的&#xff0c;怎么可以提高覆盖率&#xff1f; 有没有形成自己的 一套方法论…
阅读更多...
Jmeter接口测试---随机数、加密、cookie鉴权、断言、CSV参数化

Jmeter接口测试---随机数、加密、cookie鉴权、断言、CSV参数化

随机数 第一步&#xff1a;选择工具-函数助手对话框 第二步&#xff1a;选择random&#xff0c;设置最大值最小值&#xff0c;复制函数字符串到指定位置 加密接口 类型&#xff1a;AES、DES、Base64、RSA&#xff08;可以解密&#xff09; | MD5、SHA、HmacSHA&#xff08;不…
阅读更多...
llama.c代码2

llama.c代码2

1、forward 1.1、复习 encode(tokenizer, prompt, 1, 0, prompt_tokens, &num_prompt_tokens); 在encode函数结尾处(gdb) p *n_tokens $3 2(gdb) p *tokens3 $6 {1, 22172, 417} 在encode调用后 (gdb) print num_prompt_tokens $11 2 (gdb) print *prompt_tokens3 $13 …
阅读更多...
JavaScript 中的类型转换机制（详细讲解）

JavaScript 中的类型转换机制（详细讲解）

文章目录 一、概述二、显示转换Number()parseInt()String()Boolean() 三、隐式转换自动转换为布尔值自动转换成字符串自动转换成数值 一、概述 前面我们讲到&#xff0c;JS中有六种简单数据类型&#xff1a;undefined、null、boolean、string、number、symbol&#xff0c;以及…
阅读更多...
（sub）三次握手四次挥手

（sub）三次握手四次挥手

TCP的三次握手与四次挥手理解及面试题 序列号seq&#xff1a;占4个字节&#xff0c;用来标记数据段的顺序&#xff0c;TCP把连接中发送的所有数据字节都编上一个序号&#xff0c;第一个字节的编号由本地随机产生&#xff1b;给字节编上序号后&#xff0c;就给每一个报文段指派一…
阅读更多...
（学习日记）2024.03.03：UCOSIII第五节：常用汇编指令+OS初始化+启动任务+任务切换

（学习日记）2024.03.03：UCOSIII第五节：常用汇编指令+OS初始化+启动任务+任务切换

写在前面&#xff1a; 由于时间的不足与学习的碎片化&#xff0c;写博客变得有些奢侈。 但是对于记录学习&#xff08;忘了以后能快速复习&#xff09;的渴望一天天变得强烈。 既然如此 不如以天为单位&#xff0c;以时间为顺序&#xff0c;仅仅将博客当做一个知识学习的目录&a…
阅读更多...
双重检验锁

双重检验锁

双重检验锁&#xff1a;设计模式中的单例模式&#xff0c;细分为单例模式中的懒加载模式。 单例模式 单例模式&#xff1a;指的是一个类只有一个对象。最简单的实现方式是设一个枚举类&#xff0c;只有一个对象。缺点是当对象还没有被使用时&#xff0c;对象就已经创建存在了…
阅读更多...
【扩散模型】生成模型中的Residual Self-Attention UNet 以及 DDPM的pytorch代码

【扩散模型】生成模型中的Residual Self-Attention UNet 以及 DDPM的pytorch代码

参考&#xff1a; [1] https://github.com/xiaohu2015/nngen/blob/main/models/diffusion_models/ddpm_cifar10.ipynb [2] https://www.bilibili.com/video/BV1we4y1H7gG/?spm_id_from333.337.search-card.all.click&vd_source9e9b4b6471a6e98c3e756ce7f41eb134 TOC 1 UNe…
阅读更多...
视黄酸诱导基因-1敲除诱导树突状细胞的不成熟特性并延长异体移植小鼠的存活时间研究【AbMole】

视黄酸诱导基因-1敲除诱导树突状细胞的不成熟特性并延长异体移植小鼠的存活时间研究【AbMole】

器官移植是一种用于替换因疾病、损伤或其他原因受损的人体器官的医疗程序。尽管器官移植可以挽救生命并显著提高生活质量&#xff0c;但存在供体器官短缺、排斥反应、器官功能障碍、感染和药物副作用等问题。为了提高移植成功率和受体健康&#xff0c;需要有效的免疫策略。树突…
阅读更多...
如何使用支付宝沙箱环境本地配置模拟支付并实现公网远程访问【内网穿透】

如何使用支付宝沙箱环境本地配置模拟支付并实现公网远程访问【内网穿透】

文章目录 前言1. 下载当面付demo2. 修改配置文件3. 打包成web服务4. 局域网测试5. 内网穿透6. 测试公网访问7. 配置二级子域名8. 测试使用固定二级子域名访问 前言 在沙箱环境调试支付SDK的时候&#xff0c;往往沙箱环境部署在本地&#xff0c;局限性大&#xff0c;在沙箱环境…
阅读更多...
数据可视化原理-腾讯-3D网格热力图

数据可视化原理-腾讯-3D网格热力图

在做数据分析类的产品功能设计时&#xff0c;经常用到可视化方式&#xff0c;挖掘数据价值&#xff0c;表达数据的内在规律与特征展示给客户。 可是作为一个产品经理&#xff0c;&#xff08;1&#xff09;如果不能够掌握各类可视化图形的含义&#xff0c;就不知道哪类数据该用…
阅读更多...
壁炉火焰温和而宁静，警惕火焰凶猛的潜在危害

壁炉火焰温和而宁静，警惕火焰凶猛的潜在危害

在寒冷的冬夜&#xff0c;壁炉散发的温暖和闪烁的火焰成为家庭的心灵港湾。然而&#xff0c;我们在享受壁炉带来的温馨时&#xff0c;有时候也要关注火焰的凶猛度&#xff0c;因为它可能引发一系列潜在危害。 首先&#xff0c;壁炉的火焰过于凶猛可能导致空气质量下降。当火焰过…
阅读更多...
从零开始手写RPC框架（4）

从零开始手写RPC框架（4）

这一节主要讲述网络传输模块的代码&#xff0c;并且几乎每一行代码都加上了我个人理解的注释&#xff0c;同时也讲述了其中一些以前没见过的函数&#xff0c;和大致的底层运行逻辑。 目录 网络传输实体类网络传输实现基于Socket实现网络传输基于Netty实现网络传输客户端服务端 …
阅读更多...
【JavaEE进阶】 Linux常用命令

【JavaEE进阶】 Linux常用命令

文章目录 &#x1f343;前言&#x1f334;ls 与 pwd&#x1f6a9;ls&#x1f6a9;pwd &#x1f38d;cd&#x1f6a9;认识Linux目录结构 &#x1f340;touch与cat&#x1f6a9;touch&#x1f6a9;cat &#x1f332;mkdir与rm&#x1f6a9;mkdir&#x1f6a9;rm &#x1f384;cp与…
阅读更多...
Java基础 - 7 - 常用API（二）

Java基础 - 7 - 常用API（二）

API&#xff08;全称 Application Programming Interface&#xff1a;应用程序编程接口&#xff09; API就是Java帮我们已经写好的一些程序&#xff0c;如类、方法等&#xff0c;可以直接拿过来用 JDK8 API文档&#xff1a;Java Platform SE 8 一. Object Object类的作用 Ob…
阅读更多...
『Linux从入门到精通』第 ㉓ 期 - 管道

『Linux从入门到精通』第 ㉓ 期 - 管道

文章目录 &#x1f490;专栏导读&#x1f490;文章导读&#x1f427;进程间通信的目的&#x1f427;如何进行进程间通信&#x1f427;进程间通信的分类&#x1f427;管道&#x1f426;什么是管道&#x1f426;管道原理 &#x1f427;实例代码&#x1f427;管道的特点&#x1f4…
阅读更多...
Window系统部署Splunk Enterprise并结合内网穿透实现远程访问本地服务

Window系统部署Splunk Enterprise并结合内网穿透实现远程访问本地服务

文章目录 前言1. 搭建Splunk Enterprise2. windows 安装 cpolar3. 创建Splunk Enterprise公网访问地址4. 远程访问Splunk Enterprise服务5. 固定远程地址 前言 本文主要介绍如何简单几步&#xff0c;结合cpolar内网穿透工具实现随时随地在任意浏览器&#xff0c;远程访问在本地…
阅读更多...
【24最新版PythonPycharm安装教程】小白保姆级别安装教程

【24最新版PythonPycharm安装教程】小白保姆级别安装教程

今天&#xff0c;我就来教大家一下&#xff0c;如何去安装Python&#xff01; 需要博主打包好的一键激活版Pycharm&&Python也可扫下方直接获取 ​ 1 了解Python Python是一种面向对象的解释型计算机程序设计语言&#xff0c;由荷兰人Guido van Rossum于1989年发明&…
阅读更多...
[C++]使用纯opencv去部署yolov9的onnx模型

[C++]使用纯opencv去部署yolov9的onnx模型

【介绍】 部署 YOLOv9 ONNX 模型在 OpenCV 的 C 环境中涉及一系列步骤。以下是一个简化的部署方案概述&#xff0c;以及相关的文案。 部署方案概述&#xff1a; 模型准备&#xff1a;首先&#xff0c;你需要确保你有 YOLOv9 的 ONNX 模型文件。这个文件包含了模型的结构和权…
阅读更多...
Flutter Gradle下载失败的解决方案

Flutter Gradle下载失败的解决方案

Flutter Gradle可能会由于网络原因下载失败,这个时候我们可以首先下载Gradle&#xff0c;然后再进行配置。具体步骤如下&#xff1a; 第一步&#xff1a;下载对应版本的gradle 可以通过下面地址下载&#xff0c;也可以百度里面搜对应的版本 【极速下载】gradle各版本快速下载地…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023