【C++】中类的6个默认成员函数 取地址及const成员函数 && 学习运算符重载 && 【实现一个日期类】

仍然探索未知中2024-02-19 18:14

文章目录

    • 一、【C++】赋值运算符重载
      • [1.1 运算符重载【引入】](#1.1 运算符重载【引入】)
      • [1.2 运算符重载](#1.2 运算符重载)
      • [1.3 赋值运算符重载](#1.3 赋值运算符重载)
      • [1.4 赋值](#1.4 赋值)
    • 二、日期类的实现
      • [2.1 判断小于](#2.1 判断小于)
      • [2.2 判断等于](#2.2 判断等于)
      • [2.3 判断小于等于](#2.3 判断小于等于)
      • [2.4 判断大于](#2.4 判断大于)
      • [2.5 判断大于等于](#2.5 判断大于等于)
      • [2.6 判断不等于](#2.6 判断不等于)
      • [2.7 日期加等天数](#2.7 日期加等天数)
      • [2.8 获取月份天数](#2.8 获取月份天数)
      • [2.9 日期加天数](#2.9 日期加天数)
      • [2.9.1 日期减等天数](#2.9.1 日期减等天数)
      • [2.9.2 日期减天数](#2.9.2 日期减天数)
    • [三、前置++ && 后置++](#三、前置++ && 后置++)
      • [3.1 日期减日期【返回天数】](#3.1 日期减日期【返回天数】)
      • [3.2 流插入](#3.2 流插入)
      • [3.3 流提取](#3.3 流提取)
      • [3.4 检查输入日期是否合法](#3.4 检查输入日期是否合法)
    • 四、日期类的实现【源码】
    • 五、const修饰
      • [5.1 const成员函数](#5.1 const成员函数)
      • [5.2 小结一下：](#5.2 小结一下：)
      • [5.3 默认成员函数【取地址及const取地址操作符重载】](#5.3 默认成员函数【取地址及const取地址操作符重载】)

一、【C++】赋值运算符重载

1.1 运算符重载【引入】

  • C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
  • 函数名字为：关键字operator后面接需要重载的运算符符号。
  • 函数原型：返回值类型 operator操作符(参数列表)

注意：

  • 不能通过连接其他符号来创建新的操作符：比如operator@

  • 重载操作符必须有一个类类型参数【不能去重载运算符改变内置类型的行为】

  • 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义

  • 作为类成员函数重载时，其形参看起来比操作数数目少1个，因为成员函数的第一个参数为隐藏的this

  • .* :: sizeof ?: . 注意以上5个运算符不能重载。这里的是.*，不是*，这写经常在笔试选择题中出现。

  • 我们写了一个日期类，有没有可能要比较比较呢？
cpp 复制代码 
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;
};
  • 我们写了一个比较相等的函数，如果是传值的话没有必要，我们形参直接写成&，而且也不需要修改，所以再加上const
cpp 复制代码 
bool DateEquel(const Date& x, Date& y)
{
	return x._year == y._year
		&& x._month == y._month
		&& x._day == y._day;
}
  • 下面再实现一个函数【比较小于】
cpp 复制代码 
bool DateLess(const Date& x, Date& y)
{
	if (x._year < y._year)
	{
		return true;
	}
	else if(x._year == y._year)
	{
		if (x._month < y._month)
		{
			return true;
		}
		else if(x._month == y._month)
		{
			if (x._day < y._day)
			{
				return true;
			}
		}
	}
	return false;
}
  • 上面有一些不好的地方，取名字的问题，取得很乱就不知道这个函数是干什么的

下面我就要用一个新的符号

1.2 运算符重载

  • 这里的运算符重载 和函数重载的重载不是一个意思
  • 对运算符的行为重新定义

operator+运算符做函数名

  • 刚刚上面写的代码就可以写成下面这样
cpp 复制代码 
bool operator==(const Date& x, Date& y)
{
	return x._year == y._year
		&& x._month == y._month
		&& x._day == y._day;
} 
bool operator<(const Date& x, Date& y)
{
	if (x._year < y._year)
	{
		return true;
	}
	else if(x._year == y._year)
	{
		if (x._month < y._month)
		{
			return true;
		}
		else if(x._month == y._month)
		{
			if (x._day < y._day)
			{
				return true;
			}
		}
	}
	return false;
}
  • 就可以这样使用了
  • 还可以这样做
  • 这里必须要加括号，因为流插入的优先级很高
  • 注意：参数不能反，左边的操作数对应的是左边
  • 我们再次回到上面，我们一开始是将内置类型放开的
  • 如果将他设置成私有，类外面就不能访问了
  • 我们这里有三种解决方法
  • 第一种就是在类里面搞一个Get函数，这样获取【Java就是这样做的】
cpp 复制代码 
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	int GetYear()
	{
		return _year;
	}

private:	
	int _year;
	int _month;
	int _day;
};
  • 第二种方法就是将函数放到类里面
cpp 复制代码 
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	bool operator==(const Date& x, Date& y)
	{
		return x._year == y._year
			&& x._month == y._month
			&& x._day == y._day;
	}

	bool operator<(const Date& x, Date& y)
	{
		if (x._year < y._year)
		{
			return true;
		}
		else if (x._year == y._year)
		{
			if (x._month < y._month)
			{
				return true;
			}
			else if (x._month == y._month)
			{
				if (x._day < y._day)
				{
					return true;
				}
			}
		}
		return false;
	}

private:	
	int _year;
	int _month;
	int _day;
};
  • 然后我们又发现，函数的参数太多了，因为成员函数有一个隐含的this指针
  • 下面进行修改
cpp 复制代码 
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	bool operator==(Date& y)
	{
		return _year == y._year
			&& _month == y._month
			&& _day == y._day;
	}

	bool operator<(Date& y)
	{
		if (_year < y._year)
		{
			return true;
		}
		else if (_year == y._year)
		{
			if (_month < y._month)
			{
				return true;
			}
			else if (_month == y._month)
			{
				if (_day < y._day)
				{
					return true;
				}
			}
		}
		return false;
	}

private:	
	int _year;
	int _month;
	int _day;
};
  • 我们使用就可以这样使用了

  • 我们通过查看反汇编再来了解一下

  • 首先看一下内置类型的比较，是通过指令集的支持

  • 再来看自定义类型
  • 可以看到两种写法的汇编代码是一样的，编译器会先转化，会一步到位的

1.3 赋值运算符重载

  • 我们接着写日期类，下面写一个赋值运算符
cpp 复制代码 
void operator=(const Date& d)
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
}
  • 但是我们写的这个又遇到新的问题了，就是连续赋值是无法完成的
  • 其实连续赋值就是右操作的返回值，做操作的值再进行赋值
  • 返回类型用传引用返回，类型用引用，效率会提高Date&，返回的就是*this，不是this，这是个指针
cpp 复制代码 
Date& operator=(const Date& d)
{
	_year = d._year;
	_month = d._month;
	_day = d._day;

	return *this;
}
  • 但是有可能有人这样写代码：d1 = d1
cpp 复制代码 
d1 = d1
  • 这里我们就可以加上一个判断，两个相等的话直接返回即可

1.4 赋值

cpp 复制代码 
Date& operator=(const Date& d)
{
	if (this != &d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	return *this;
}

  • 那么我们不写这个赋值，编译器不会不会自动生成一个呢？--->会的！

  • 因为这个是那6个默认成员函数之一

  • 内置类型会值拷贝，自定义类型会调用它的拷贝

总结：

  1. 赋值运算符重载格式
  • 参数类型：const T&，传递引用可以提高传参效率
  • 返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
  • 检测是否自己给自己赋值
  • 返回*this ：要复合连续赋值的含义
  1. 赋值运算符只能重载成类的成员函数不能重载成全局函数
  • 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
cpp 复制代码 
Date& operator=(Date& left, const Date& right)
{
	if (&left != &right)
	{
		left._year = right._year;
		left._month = right._month;
		left._day = right._day;
	}
	return left;
}

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

二、日期类的实现

  • 前面实现了一些逻辑，接下来我们就实现剩下的
  • 所有代码在最后~~

2.1 判断小于

  • 在上面已经说明了，这里就直接写出来了
cpp 复制代码 
bool operator<(const Date& d)
{
	if (_year < d._year)
	{
		return true;
	}
	else if (_year == d._year)
	{
		if (_month < d._month)
		{
			return true;
		}
		else if (_month == d._month)
		{
			if (_day < d._day)
			{
				return true;
			}
		}
	}
	return false;
}

2.2 判断等于

  • 直接判断相不相等
cpp 复制代码 
bool operator==(const Date& d)
{
	return _year == d._year
		&& _month == d._month
		&& _day == d._day;
}

2.3 判断小于等于

  • 上面实现了小于 ，下面我们来实现一下小于等于
  • 既然上面都写了小于和等于了，我们这里就可以直接复用
cpp 复制代码 
bool operator<=(const Date& d)
{
	return *this <= d || *this == d;
}

2.4 判断大于

  • 这里的大于不就是小于等于的取反
cpp 复制代码 
bool operator>(const Date& d)
{
	return !(*this <= d);
}

2.5 判断大于等于

  • 大于等于就是小于取反
cpp 复制代码 
bool operator>=(const Date& d)
{
	return !(*this < d);
}

2.6 判断不等于

  • 不等于就是等于的取反
cpp 复制代码 
bool operator!=(const Date& d)
{
	return !(*this == d);
}

2.7 日期加等天数

2.8 获取月份天数

  • 在实现日期加天数的时候我们需要再先实现一个获取月份天数
  • 因为这里的获取月份天数需要被频繁调用，我们这里使用inline，可以不写【在类内声明同时定义的成员函数自动转化为内联函数】
  • 我们还将数组使用static修饰，避免了频繁开辟
  • 然后再判断闰年的时候我们把判断月份放到了前面，首先判断月份是否为2，为真继续判断下面的，否则每次都要执行那么一长串的判断闰年
cpp 复制代码 
inline int GetMonthDay(int year,int month)
{
	assert(month < 13 && month > 0);
	// 放到静态区
	static int MonthDays[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
	// 先判断月份
	if (month == 2 && (((year % 100 == 0) && (year % 4 == 0)) || (year % 400 != 0)))
		return 29;
	return MonthDays[month];
}
  • 然后继续来实现
  • 首先加上天数，然后判断当前月的天数和加上的天数
  • 然后进行减掉天数，月份+1，如果月份等于了13，年就+1，月份赋值为1
cpp 复制代码 
Date& operator+=(int day)
{
	// 这里就直接修改了
	_day += day;
	while (_day > GetMonthDay(_year, _month))
	{
		_day -= GetMonthDay(_year, _month);
		++_month;
		if (_month == 13)
		{
			++_year;
			_month = 1;
		}
	}
	return *this;
}

2.9 日期加天数

  • 上面是实现了+=，+也就很好实现了，这里只需要另外开一块空间，修改别的空间就不会影响我这里的值
  • 这里不可以用引用返回，tmp是一个临时对象，必须用传值返回
cpp 复制代码 
Date operator+(int day)
{
	Date tmp(*this);
	tmp._day += day;
	while (tmp._day > GetMonthDay(tmp._year, tmp._month))
	{
		tmp._day -= GetMonthDay(tmp._year, tmp._month);
		++tmp._month;
		if (tmp._month == 13)
		{
			++tmp._year;
			tmp._month = 1;
		}
	}
	return tmp;
}
  • 上面那个+和+=的代码相似，我们也可以复用一下
cpp 复制代码 
Date operator+(int day)
{
	Date tmp(*this);
	tmp += day;
	return tmp;
}
  • 上面的代码是+复用+=，那么我们也可以用+=复用+
cpp 复制代码 
Date& operator+=(int day)
{
	*this = *this + day;
	return *this;
}
  • 那么这两种写法哪一种比较好呢？
  • 这里左边的更好，右边的会复用+，而+里面会创建临时对象

2.9.1 日期减等天数

  • 经过上面的思考，我们先实现减等
cpp 复制代码 
Date& operator-=(int day)
{
	_day -= day;
	while (_day <= 0)
	{
		--_month;
		if (_month == 0)
		{
			--_year;
			_month = 12;
		}
		_day += GetMonthDay(_year, _month);
	}
	return *this;
}

2.9.2 日期减天数

cpp 复制代码 
Date operator-(int day)
{
	Date tmp = *this;
	tmp -= day;

	return tmp;
}

三、前置++ && 后置++

  • 前置++很简单
cpp 复制代码 
Date& operator++()
{
	*this += 1;
	return *this;
}
  • 后置++要返回++后的值【这里要注意，后置++的操作符是有一个**(int)区分的**】
  • 后置++相比前置++的效率是低一些的
cpp 复制代码 
Date operator++(int)
{
	Date tmp = *this;
	*this += 1;
	return tmp;
}

3.1 日期减日期【返回天数】

cpp 复制代码 
int operator-(const Date& d)
{
	int flag = 1;
	Date max = *this;
	Date min = d;
	if (*this < d)
	{
		int flag = -1;
		max = d;
		min = *this;
	}
	// 相差天数
	int n = 0;
	while (min != max)
	{
		++min;
		++n;
	}
	return n * flag;
}

3.2 流插入

  • 对于内置类型可以流插入，那么内置类型也可以流插入

  • 对于流插入【cout】，对于库里面全局的ostream类型的对象 -->点我

  • 这里我们在使用的时候就反了，第一个被this占用了
cpp 复制代码 
void operator<<(ostream& out)
{
	out << _year << "年" << _month << "月" << _day << "日" << endl;
}
  • 作为成员函数重载，this指针占据第一个参数，Date必须是在操作数

  • 所以我们就必须让ostream占据第一个位置

  • 想要占据第一个参数，就不能写成成员函数，就要写成全局函数

  • 当我们写成全局函数的时候，·不能访问类的私有了，这里也要后面的友元

cpp 复制代码 
void operator<<(ostream& out, const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
}
  • 这里想要改成多个插入，我们返回值就要改一下
cpp 复制代码 
ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
	return out;
}

3.3 流提取

  • 流提取是cin
  • 这里就不能使用const了
cpp 复制代码 
istream& operator>>(istream& in, Date& d)
{
	cout << "请依次输入年月日:>";
	in >> d._year >> d._month >> d._day;
	return in;
}

3.4 检查输入日期是否合法

cpp 复制代码 
bool CheckInvalid()
{
	if (_year <= 0
		|| _month < 1
		|| _month > 12
		|| _day < 1
		|| _day > GetMonthDay(_year,_month))
	{
		return false;
	}
	else
	{
		return true;
	}
}
  • 这个时候把可以改检查的地方就检查一下

四、日期类的实现【源码】

cpp 复制代码 
#include <iostream>
#include <assert.h>
using namespace std;

class Date
{
public:
	// 构造函数
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;

		if (!CheckInvalid())
		{
			cout << "构造日期非法" << endl;
		}
	}
	// 判断等于
	bool operator==(const Date& d)
	{
		return _year == d._year
			&& _month == d._month
			&& _day == d._day;
	}
	// 判断小于
	bool operator<(const Date& d)
	{
		if (_year < d._year)
		{
			return true;
		}
		else if (_year == d._year)
		{
			if (_month < d._month)
			{
				return true;
			}
			else if (_month == d._month)
			{
				if (_day < d._day)
				{
					return true;
				}
			}
		}
		return false;
	}
	// 判断小于等于
	bool operator<=(const Date& d)
	{
		return *this <= d || *this == d;
	}
	// 判断大于
	bool operator>(const Date& d)
	{
		return !(*this <= d);
	}
	// 判断大于等于
	bool operator>=(const Date& d)
	{
		return !(*this < d);
	}
	// 判断不等于
	bool operator!=(const Date& d)
	{
		return !(*this == d);
	}
	// 日期加等天数

	Date& operator+=(int day)
	{
		_day += day;
		while (_day > GetMonthDay(_year, _month))
		{
			_day -= GetMonthDay(_year, _month);
			++_month;
			if (_month == 13)
			{
				++_year;
				_month = 1;
			}
		}
		return *this;
	}

	Date operator+(int day)
	{
		Date tmp(*this);
		//Date tmp = *this;
		tmp += day;
		return tmp;
	}

	// 日期加天数
	Date operator+(const Date& d)
	{
		Date tmp(*this);
		tmp._day += d._day;
		while (d._day > GetMonthDay(tmp._year, tmp._month))
		{
			tmp._day -= GetMonthDay(tmp._year, tmp._month);
			++tmp._month;
			if (tmp._month == 13)
			{
				++tmp._year;
				tmp._month = 1;
			}
		}
		return tmp;
	}

	// 日期-=天数
	Date& operator-=(int day)
	{
		_day -= day;
		while (_day <= 0)
		{
			--_month;
			if (_month == 0)
			{
				--_year;
				_month = 12;
			}
			_day += GetMonthDay(_year, _month);
		}
		return *this;
	}

	// 日期减天数
	Date operator-(int day)
	{
		Date tmp = *this;
		tmp -= day;

		return tmp;
	}

	// 前置++
	Date& operator++()
	{
		*this += 1;
		return *this;
	}

	// 后置++
	Date operator++(int)
	{
		Date tmp = *this;
		*this += 1;

		return tmp;
	}

	// 日期-日期
	int operator-(const Date& d)
	{
		int flag = 1;
		Date max = *this;
		Date min = d;

		if (*this < d)
		{
			int flag = -1;
			max = d;
			min = *this;
		}

		int n = 0;
		while (min != max)
		{
			++min;
			++n;
		}
		return n * flag;
	}


	// 获取月份天数[可以不写inline，类里默认就是]
	inline int GetMonthDay(int year, int month)
	{
		assert(month < 13 && month > 0);
		// 放到静态区
		static int MonthDays[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
		// 先判断月份
		if (month == 2 && (((year % 100 == 0) && (year % 4 == 0)) || (year % 400 != 0)))
			return 29;
		return MonthDays[month];
	}

	// 拷贝构造
	Date& operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
	friend ostream& operator<<(ostream& out, const Date& d);
	friend istream& operator>>(istream& in, Date& d);

	bool CheckInvalid()
	{
		if (_year <= 0
			|| _month < 1
			|| _month > 12
			|| _day < 1
			|| _day > GetMonthDay(_year,_month))
		{
			return false;
		}
		else
		{
			return true;
		}
	}

	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
	return out;
}

istream& operator>>(istream& in, Date& d)
{
	while (1)
	{
		cout << "请依次输入年月日:>";
		in >> d._year >> d._month >> d._day;

		if (!d.CheckInvalid())
		{
			cout << "输入非法日期，请重新输入" << endl;
		}
		else
		{
			break;
		}
	}
	return in;
}

五、const修饰

5.1 const成员函数

  • 将const修饰的"成员函数"称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。
  • 我们看下面这段代码
cpp 复制代码 
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()
	{
		cout << "Print()const" << endl;
		cout << "year:" << _year << endl;
		cout << "month:" << _month << endl;
		cout << "day:" << _day << endl << endl;
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};
  • 这里会出现一个权限放大的问题

  • 那么在参数就需要改成const Date*

  • 为了解决这个问题，我们就要在函数后面的位置加上一个const

  • 修饰的是this指针指向的内容

  • 那么不是下面方法调用也是可以的，因为这个是权限的缩小
  • const对象可以调用，非const对象也可以调用
  • 那么全部函数都可以加上const吗？--->不可以！
  • 如果函数内部要被修改，那肯定是不能加的
  • 上面写的日期类的部分函数也可以加上~~

5.2 小结一下：

  • 成员函数 如果是一个对成员变量只进行读 访问的函数，建议加上const，这样const对象和非const对象都可以访问

  • 成员函数 如果是一个对成员变量进行读写 访问的函数，不可以加上const，否则不能修改成员变量

  1. const对象可以调用非const成员函数吗？ --> 不可以！【权限放大】
  2. 非const对象可以调用const成员函数吗？--> 可以！【权限缩小】
  3. const成员函数内可以调用其它的非const成员函数吗？--> 不可以！【权限放大】
  4. 非const成员函数内可以调用其它的const成员函数吗？--> 可以！【权限缩小】

5.3 默认成员函数【取地址及const取地址操作符重载】

  • 前面章节学习了4个默认成员函数了，剩下两个再看一下
  • 这两个默认成员函数一般不用重新定义 ，编译器默认会生成。
cpp 复制代码 
class Date
{
public:
	Date* operator&()
	{
		return this;
	}
	const Date* operator&()const
	{
		return this;
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};
  • 比如说不想让别人拿到我的地址，普通对象返回空，const对象返回假地址
  • 就可以这样写：
cpp 复制代码 
Date* operator&()
{
	return nullptr;
}
const Date* operator&()const
{
	int i = 0;
	return (const A*)&i;
}
  • 这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容！

最后本文主要学习了运算符重载这个知识点，并且在学习的时候实现了一个日期类，望烙铁们学有所成~~

相关推荐
‘’林花谢了春红‘’44 分钟前
C++ list （链表）容器
c++·链表·list
机器视觉知识推荐、就业指导2 小时前
C++设计模式：建造者模式（Builder） 房屋建造案例
c++
Yang.994 小时前
基于Windows系统用C++做一个点名工具
c++·windows·sql·visual studio code·sqlite3
熬夜学编程的小王4 小时前
【初阶数据结构篇】双向链表的实现（赋源码）
数据结构·c++·链表·双向链表
zz40_4 小时前
C++自己写类 和 运算符重载函数
c++
六月的翅膀5 小时前
C++：实例访问静态成员函数和类访问静态成员函数有什么区别
开发语言·c++
liujjjiyun5 小时前
小R的随机播放顺序
数据结构·c++·算法
￥ 多多￥5 小时前
c++中mystring运算符重载
开发语言·c++·算法
天若有情6736 小时前
c++框架设计展示---提高开发效率！
java·c++·算法
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10怎样让音频速度变慢？请跟随以下方法进行操作