C++运算符重载，匿名对象

news2025/1/13 10:04:29

目录

 1、加号运算符重载

1.1 通过自己写成员函数，实现两个对象相加属性后返回新的对象

1.2通过成员函数实现加法运算符重载

1.3通过全局函数实现加法运算符重载，运算符重载也可以发生函数重载

 1.4总结--对于内置的数据类型的表达式运算符是不可以改变的

2.左移运算符

2.1不会利用成员函数重载成员函数

2.2只能利用全局函数重载左移运算符

3.递增运算符重载

 3.1重载前置递增运算符

3.1.1成员函数重载前置递增运算符

 3.1.2利用全局函数重载前置递增运算符

3.2重载后置递增运算符

3.2.1利用成员函数重载后置递增运算符

3.2.2利用全局函数重载后置递增

4.赋值运算符重载

5.关系运算符重载

 5.1利用成员函数重载关系运算符

5.2利用全局函数重载关系运算符

6.函数调用运算符()(小括号)重载，匿名函数对象，匿名对象

 1、加号运算符重载

1.1 通过自己写成员函数，实现两个对象相加属性后返回新的对象

#include<iostream>
using namespace std;

class Person
{
public:
	int m_A;
	int m_B;
	Person PersonAddPerson(Person& p)
	{
		Person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;    
	}
	
	/*第二种写法
	Person & PersonAddPerson(Person& p1, Person& p2)
	{
		this->m_A = p1.m_A + p2.m_A;
		this->m_B = p1.m_B + p2.m_B;
		return *this;
	}
	*/

};
void test01()
{
	Person p1;
	p1.m_A = 10;
	p1.m_B = 10;
	Person p2;
	p2.m_A = 10;
	p2.m_B = 10;
	Person p3 = p1.PersonAddPerson(p2);
	
	//Person p3;第二种写法的调用
	//p3.PersonAddPerson(p1, p2);

	cout << p3->m_A << " " << p3->m_B << endl;
}
int main()
{
	test01();
	system("pause");//按任意键继续
	return 0;
}

1.2通过成员函数实现加法运算符重载

#include<iostream>
using namespace std;

//加号运算符重载




class Person
{
public:
	int m_A;
	int m_B;
	//1、成员函数重载+号
	Person operator+(Person& p)//operator+编译器起的函数名
	{
		Person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;    
	}
	

};


void test01()
{
	Person p1;
	p1.m_A = 10;
	p1.m_B = 10;
	Person p2;
	p2.m_A = 10;
	p2.m_B = 10;

	Person p3 = p2.operator+(p1);
	//Person p3 = p1 + p2;//成员函数重载本质调用Person p3=p2.operator+(p1)
	cout << "p3.m_A = "<<p3.m_A << " " <<"p3.m_B = "<< p3.m_B << endl;
}
int main()
{
	test01();
	system("pause");//按任意键继续
	return 0;
}

1.3通过全局函数实现加法运算符重载，运算符重载也可以发生函数重载

#include<iostream>
using namespace std;

//加号运算符重载




class Person
{
public:
	int m_A;
	int m_B;
	
};

//2、全局函数重载+号
Person operator+(Person& p1, Person& p2)
{
	Person temp;
	temp.m_A = p1.m_A+p2.m_A;
	temp.m_B = p1.m_B+p2.m_B;
	return temp;
}

//运算符重载 也可以发生函数重载
Person operator+(Person& p1, int num)
{
	Person temp;
	temp.m_A = p1.m_A +num;
	temp.m_B = p1.m_B + num;
	return temp;
}
void test01()
{
	Person p1;
	p1.m_A = 10;
	p1.m_B = 10;
	Person p2;
	p2.m_A = 10;
	p2.m_B = 10;

	//Person p3 = operator+(p1, p2);
	Person p3 = p1 + p2;//全局函数重载本质调用Person p3 = operator+(p1, p2);
	cout << p3.m_A << " " << p3.m_B << endl;
	Person p4 = p1 + 100;
	cout << p4.m_A << " " << p4.m_B << endl;
	//运算符重载 也可以发生函数重载

}
int main()
{
	test01();
	system("pause");//按任意键继续
	return 0;
}

 1.4总结--对于内置的数据类型的表达式运算符是不可以改变的

对于内置的数据类型的表达式运算符是不可以改变的，比如你把两个整型数据相加的，在函数里面写两数相减，这是不允许的

2.左移运算符

2.1不会利用成员函数重载成员函数

#include<iostream>
using namespace std;

//左移运算符
class Person
{
public:

	//利用成员函数重载 左移运算符
	//p.operator<<(cout) 简化版本p<<cout
	//所以不会利用成员函数重载<<运算符，因为无法实习cout在左侧
	//即cout<<
	void operator<<(cout)
	{
       //但你不知道返回什么就先写void
	}
	int m_A;
	int m_B;

};
void test01()
{
	Person p;
	p.m_A = 10;
	p.m_B = 10;
	cout << p.m_A  << endl;
}




int main()
{
	test01();
	system("pause");//按任意键继续
	return 0;
}

2.2只能利用全局函数重载左移运算符

#include<iostream>
using namespace std;

//左移运算符
class Person
{
public:

	int m_A;
	int m_B;

};


//只能利用全局函数重载左移运算符
void operator<<(ostream& cout, Person& p)//本质 operator<<(cout,p)简化为cout<<p
{
	//cout是输出流对象
	//cout只能有一个，要用引用的方式传递
	cout << "m_A = " << p.m_A << " " << "m_B = " << p.m_B;
}

void test01()
{
	Person p;
	p.m_A = 10;
	p.m_B = 10;
	cout <<p;
	//cout << p << endl;//报错
	// 链式调用
	//是因为cout << p本质 operator<<(cout,p)，返回值为空，当然不能往后追加内容了
	//不能写endl
}


int main()
{
	test01();
	system("pause");//按任意键继续
	return 0;
}
=
#include<iostream>
using namespace std;

//左移运算符
class Person
{
	//全局函数做Person的好朋友，可以访问Person类的私有成员
	friend ostream& operator<<(ostream& cout, Person& p);
public:
	Person(int a, int b)
	{
		m_A = a;
		m_B = b;
	}

private:

	int m_A;
	int m_B;

};


//只能利用全局函数重载左移运算符
ostream& operator<<(ostream& cout, Person& p)//本质 operator<<(cout,p)简化为cout<<p
{
	//cout是输出流对象
	//cout只能有一个，要用引用的方式传递
    //因为属性私有，所以设为友元
	cout << "m_A = " << p.m_A << " " << "m_B = " << p.m_B;
	return cout;
}
/*
这样也对
ostream& operator<<(ostream& out, Person& p)//本质 operator<<(cout,p)简化为cout<<p
{
	
	out << "m_A = " << p.m_A << " " << "m_B = " << p.m_B;
	return out;
}
*/

void test01()
{
	Person p(10,10);
	//链式编程思想
	cout << p  << endl;
	//cout << p本质 operator<<(cout,p)，返回cout
	//执行cout<<endl endl（在 << 右边）不符合右边的形参（person类）的要求
	//endl不是Person类 所以使用iostream中定义的 <<
	//此时的 << 只是最普通的 << ，而不是运算符重载后的 <<
	cout << p << " hello word" << endl;
}


int main()
{
	test01();
	system("pause");//按任意键继续
	return 0;
}

3.递增运算符重载

 自己写一个整型的数据，实现递增运算

 3.1重载前置递增运算符

3.1.1成员函数重载前置递增运算符

#include<iostream>
using namespace std;

//递增元素符重载

//自定义整型
class MyInteger
{
	friend ostream& operator<<(ostream& cout, MyInteger myint);
public:
	MyInteger()
	{
		m_Num = 0;
	}
	//重载前置++运算符
	//当不知道返回什么 就先写void
	MyInteger& operator++()
	{
		//先进性++运算
		m_Num++;
		//再将自身返回
		return *this;//返回自身
		/*
		返回引用是为了一直对一个数据进行递增操作
		因为
		int a=0;
		cout<<++(++a)<<endl;//输出2
		cout<<a<<endl;//输出2
		一直在对a这一个数进行操作

		如果返回值，会创建一个拷贝出来一个副本
		*/

	}
	//重载后置++运算符


private:
	int m_Num;
};

//重载<<(左移)运算符
ostream& operator<<(ostream& cout, MyInteger myint)
{
	cout << myint.m_Num;//因为私有，所以做友元
	return cout;
}
void test01()
{
	MyInteger myint;
	cout << myint << endl;
	cout << ++(++myint) << endl;
	cout <<myint << endl;
}


int main()
{
	test01();
	system("pause");//按任意键继续
	return 0;
}

 3.1.2利用全局函数重载前置递增运算符

#include<iostream>
using namespace std;

//递增元素符重载

//自定义整型
class MyInteger
{
	friend ostream& operator<<(ostream& cout, MyInteger &myint);
	friend MyInteger& operator++(MyInteger& myint);
public:
	MyInteger()
	{
		m_Num = 0;
	}
private:
	int m_Num;
};

//重载前置++运算符
MyInteger& operator++(MyInteger& myint )
{
	myint.m_Num++;
	return myint;
}


//重载<<(左移)运算符
ostream& operator<<(ostream& cout, MyInteger &myint)
{
	cout << myint.m_Num;//因为私有，所以做友元
	return cout;
}
void test01()
{
	MyInteger myint;
	cout << ++(++myint) << endl;
	cout << myint << endl;
}
int main()
{
	test01();
	system("pause");//按任意键继续
	return 0;
}

3.2重载后置递增运算符

3.2.1利用成员函数重载后置递增运算符

#include<iostream>
using namespace std;

//递增元素符重载

//自定义整型
class MyInteger
{
	friend ostream& operator<<(ostream& cout, MyInteger myint);
public:
	MyInteger()
	{
		m_Num = 0;
	}
	//重载前置++运算符
	MyInteger& operator++()
	{
		m_Num++;
		return *this;
	}
	//重载后置++运算符
	//同一个作用域下，函数名相同，发生了重载，
	// 函数返回值不可以作为重载条件
	//写个int作为占位参数，必须写int 写double float不好使
	//用于区分前置和后置
	//加了int之后，编译器就会认为这是后置的++运算符重载
	//但是前面讲过占位参数调用时必须填补呀，感觉是程序的规定
	//就是你写了int编译器自己就可以区分了
	MyInteger operator++(int)
	{
		/*
		//先返回结果
		return *this;
		//后 递增
		m_Num++;
		如果写return 那么后面的代码就不执行了
		*/
		//先记录结果
		MyInteger temp = *this;
		//后递增
		m_Num++;
		//最后将记录结果返回
		return temp;
		//如果是后置递增，要返回值
		//返回局部对象引用后面就是非法操作，因为，temp是局部变量
		//局部变量在当前函数执行完后就被释放掉了
	}
	
private:
	int m_Num;
};

//重载<<(左移)运算符
ostream& operator<<(ostream& cout, MyInteger myint)
{
	cout << myint.m_Num;//因为私有，所以做友元
	return cout;
}

void test02()
{
	MyInteger myint;
	cout << myint++ << endl;
	cout << myint << endl;

	/*
	int a = 0;
	cout << (a++)++ << endl;//报错
	cout << a << endl;
	因为在重载后置运算符时我们返回的是值
	所以（myint++）++是不会对同一个数据操作
	实际上我们看，系统自带的也不支持这种操作
	*/
}


int main()
{
	test02();
	system("pause");//按任意键继续
	return 0;
}

上面的代码我们注意到

 左移运算符，对象是以值传递的方式传入的。那我能不能写成引用呢?答案是可以的

#include<iostream>
using namespace std;

//递增元素符重载

//自定义整型
class MyInteger
{
	friend ostream& operator<<(ostream& cout, MyInteger &myint);
public:
	MyInteger()
	{
		m_Num = 0;
	}
	//重载前置++运算符
	MyInteger& operator++()
	{
		m_Num++;
		return *this;
	}
	//重载后置++运算符
	MyInteger operator++(int)
	{
		/*
		//先返回结果
		return *this;
		//后 递增
		m_Num++;
		如果写return 那么后面的代码就不执行了
		*/
		//先记录结果
		MyInteger temp = *this;
		//后递增
		m_Num++;
		//最后将记录结果返回
		return temp;
	}
private:
	int m_Num;
};

//重载<<(左移)运算符
ostream& operator<<(ostream& cout, MyInteger &myint)
{
	cout << myint.m_Num;//因为私有，所以做友元
	return cout;
}

void test02()
{
	MyInteger myint;
	MyInteger temp = myint++;
	cout << temp << endl;
	cout << myint << endl;
	//这个时候需要写个变量去接受myint++返回的对象
	//如果直接写cout << myint++ << endl;会报错
	//以值的方式返回对象，会调用拷贝构造函数，
	//复制出一个临时副本，感觉应该是这个副本没具体被接收
}


int main()
{
	test02();
	system("pause");//按任意键继续
	return 0;
}

 重载后置++运算符时，返回引用，此时需要用到new

#include<iostream>
using namespace std;

//递增元素符重载

//自定义整型
class MyInteger
{
	friend ostream& operator<<(ostream& cout, MyInteger &myint);
public:
	MyInteger()
	{
		m_Num = 0;
	}
	//重载前置++运算符
	MyInteger& operator++()
	{
		m_Num++;
		return *this;
	}
	//重载后置++运算符
	MyInteger& operator++(int)
	{
		//也可以直接 new 一个类，然后就可以返回引用了，占用内存还小
		
		//先记录结果
		MyInteger* temp = new MyInteger;
		*temp = *this;
		//后递增
		m_Num++;
		//最后将记录结果返回
		return *temp;
	}
	
private:
	int m_Num;
};

//重载<<(左移)运算符
ostream& operator<<(ostream& cout, MyInteger &myint)
{
	cout << myint.m_Num;//因为私有，所以做友元
	return cout;
}

void test02()
{
	MyInteger myint;
	cout << myint++ << endl;
	cout << myint << endl;
}


int main()
{
	test02();
	system("pause");//按任意键继续
	return 0;
}

3.2.2利用全局函数重载后置递增

#include<iostream>
using namespace std;

//递增元素符重载

//自定义整型
class MyInteger
{
	friend ostream& operator<<(ostream& cout, MyInteger myint);
	friend MyInteger& operator++(MyInteger& myint);
	friend MyInteger operator++(MyInteger& myint, int);
public:
	MyInteger()
	{
		m_Num = 0;
	}
private:
	int m_Num;
};

//重载前置++运算符
MyInteger& operator++(MyInteger& myint )
{
	myint.m_Num++;
	return myint;
}

//重载后置++运算符
MyInteger operator++(MyInteger& myint,int)
{
	cout << "后置" << endl;
	//先记录结果
	MyInteger temp = myint;
	//后递增
	myint.m_Num++;
	//最后将记录结果返回
	return temp;
}

//重载<<(左移)运算符
ostream& operator<<(ostream& cout, MyInteger myint)
{
	cout << myint.m_Num;//因为私有，所以做友元
	return cout;
}
void test02()
{
	MyInteger myint;
	cout << myint++ << endl;
	cout << myint << endl;
}
int main()
{
	test02();
	system("pause");//按任意键继续
	return 0;
}

4.赋值运算符重载

下面代码 会报错，原因如下面图片所述 

#include<iostream>
using namespace std;

//赋值运算符重载

class Person
{
public:
	Person(int age)
	{
		m_Age=new int(age);//将age数据开辟在堆区
	}
	~Person()
	{
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
	}
	int* m_Age;//开辟 到堆区
};
void test01()
{
	Person p1(18);

	Person p2(20);

	p2 = p1;//赋值操作
	cout << "p1的年龄为 " << *p1.m_Age<<endl;
	cout << "p2的年龄为 " << *p2.m_Age << endl;
}
int main()
{
	test01();
	system("pause");//按任意键继续
	return 0;
}

 解决方法

 第一种，自己写个拷贝构造函数将p1赋值给p2

#include<iostream>
using namespace std;

//赋值运算符重载

class Person
{
public:
	Person(int age)
	{
		m_Age=new int(age);//将age数据开辟在堆区
	}
	Person(const Person &p)
	{
		m_Age = new int(*p.m_Age);
	}
	~Person()
	{
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
	}
	int* m_Age;//开辟 到堆区
};
void test01()
{
	Person p1(18);

	Person p2(p1);

	//赋值操作
	cout << "p1的年龄为 " << *p1.m_Age<<endl;
	cout << "p2的年龄为 " << *p2.m_Age << endl;
}
int main()
{
	test01();
	system("pause");//按任意键继续
	return 0;
}

第二种，重载赋值运算符,必须用成员函数重载赋值运算符

#include<iostream>
using namespace std;

//赋值运算符重载

class Person
{
public:
	Person(int age)
	{
		m_Age=new int(age);//将age数据开辟在堆区
	}
	~Person()
	{
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
	}

	//重载 赋值运算符
	Person& operator=(Person &p)
	{
		//编译器提共的是浅拷贝
		//m_Age = p.m_Age;

		//应该判断是否有属性在堆区， 如果有先释放干净， 然后在深拷贝
		//将p1的数据给到p2，但是p2已经有一块内存了
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
		//深拷贝
		m_Age = new int(*p.m_Age);
		//返回对象本身
		return *this;
		//返回引用才是真正的自身
	}
	int* m_Age;//开辟 到堆区
};
void test01()
{
	Person p1(18);

	Person p2(20);

	Person p3(30);
    //p2 = p1;//本质上是p2.operator(p1)

	p3=p2 = p1;//赋值操作
	cout << "p1的年龄为 " << *p1.m_Age<<endl;
	cout << "p2的年龄为 " << *p2.m_Age << endl;
	cout << "p3的年龄为 " << *p3.m_Age << endl;
}
int main()
{
	test01();

	/*
	int a = 10,b=20,c=30;
	c = b = a;
	//将a的值赋值给b,此时b为10
	//再将b的值赋值给c,此时c也为10
	cout << "a = " << a << endl;//输出 10
	cout << "b = " << b << endl;//输出 10
	cout << "c = " << c << endl;//输出 10
	*/
	
	system("pause");//按任意键继续
	return 0;
}

5.关系运算符重载

 

 5.1利用成员函数重载关系运算符

#include<iostream>
using namespace std;

//重载关系运算符
class Person
{
public:
	Person(string name, int age)
	{
		m_Name = name;
		m_Age = age;
	}

	//重载==
	bool operator==(Person &p)
	{
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
		{
			return true;
		}
		return false;
	}

	//重载!=
	bool operator!=(Person& p)
	{
		if (this->m_Name != p.m_Name || this->m_Age != p.m_Age)
		{
			return true;
		}
		return false;
	}
	string m_Name;
	int m_Age;
};
void test01()
{
	Person p1("Tom", 18);
	Person p2("Tom", 18);
	if (p1 == p2)//本质p1.operator==(p2)
	{
		cout << "p1和p2是相等的" << endl;
	}
	else
	{
		cout << "p1和p2是不相等的" << endl;
	}
	if (p1 != p2)//本质p1.operator==(p2)
	{
		cout << "p1和p2是不相等的" << endl;
	}
	else
	{
		cout << "p1和p2是相等的" << endl;
	}
}
int main()
{
	
	test01();
	system("pause");//按任意键继续
	return 0;
}

5.2利用全局函数重载关系运算符

#include<iostream>
using namespace std;

//重载关系运算符
class Person
{
public:
	Person(string name, int age)
	{
		m_Name = name;
		m_Age = age;
	}

	
	string m_Name;
	int m_Age;
};
//重载==
bool operator==(Person& p1,Person &p2)
{
	if (p1.m_Name == p2.m_Name && p1.m_Age == p2.m_Age)
	{
		return true;
	}
	return false;
}

//重载!=
bool operator!=(Person& p1, Person& p2)
{
	if (p1.m_Name !=p2.m_Name || p1.m_Age != p2.m_Age)
	{
		return true;
	}
	return false;
}
void test01()
{
	Person p1("Tom", 18);
	Person p2("Jerry", 18);
	if (p1 == p2)//本质operator==(p1,p2)
	{
		cout << "p1和p2是相等的" << endl;
	}
	else
	{
		cout << "p1和p2是不相等的" << endl;
	}
	if (p1 != p2)//本质p1.operator==(p2)
	{
		cout << "p1和p2是不相等的" << endl;
	}
	else
	{
		cout << "p1和p2是相等的" << endl;
	}
}
int main()
{
	
	test01();
	system("pause");//按任意键继续
	return 0;
}

6.函数调用运算符()(小括号)重载，匿名函数对象，匿名对象

#include<iostream>
using namespace std;

//函数调用运算符重载

//打印输出类
class MyPrint
{
public:

	//重载函数调用运算符
	void operator()(string test)
	{
		cout << test << endl;
	}
};
void MyPrint02(string test)
{
	cout << test << endl;
}
void test01()
{
	MyPrint myPrint;
	myPrint("hello word");//很像下面的函数调用
	//由于使用起来非常类似于函数调用，因此称为仿函数
	MyPrint02("xyq");//函数调用
}

//仿函数非常灵活，没有固定的写法

//加法类
class MyAdd
{
public:
	int operator()(int num1, int num2)
	{
		return num1 + num2;
	}
};
void test02()
{
	MyAdd myAdd;
	int ret=myAdd(10,10);
	cout << ret<< myAdd(10, 10) << endl;

	//匿名函数对象
	//因为重载了小括号称为匿名函数对象
	cout << MyAdd()(100, 100) << endl;
	// MyAdd()会创建出来一个匿名对象，通过类名加小括号会创建出来一个匿名对象
	//匿名函数对象有一个特点当前行执行完了立即被释放
	//匿名对象在构造函数分类及调用时讲过
}
int main()
{
	test01();
	test02();
	system("pause");//按任意键继续
	return 0;
}

 

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

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

相关文章

Python+Requests实现接口自动化测试

Python+Requests实现接口自动化测试

一般对于自动化的理解&#xff0c;有两种方式的自动化。 第一&#xff0c;不需要写代码&#xff0c;完全由工具实现&#xff0c;这种方式的工具一般是公司自己研发的&#xff0c;方便黑盒测试人员使用。这种工具的特点是学习成本低&#xff0c;方便使用&#xff0c;但是通用性…
阅读更多...
面向5G C-RAN组网的机房配置标准与模型

面向5G C-RAN组网的机房配置标准与模型

【摘 要】当前5G网络建设成本高，投资压力大，基站建设进度受铁塔公司制约；基站机房电费、租赁、服务费用逐年上升，运营维护压力大。面向未来5G建设，通过C-RAN组网，实现BBU集中化部署，可促进降本增效，实现低成本建网。首先分析了C-RAN区所处的网络位置，其次从BBU框多基…
阅读更多...
java基于springboot的心理健康管理网站-计算机毕业设计

java基于springboot的心理健康管理网站-计算机毕业设计

运行环境&#xff1a; 开发工具:IDEA /Eclipse 数据库:MYSQL5.7 应用服务:Tomcat7/Tomcat8 使用框架springbootvue 项目介绍 心灵治愈交流平台的主要使用者分为管理员和用户、心理咨询师&#xff0c;实现功能包括管理员&#xff1a;首页、个人中心、系统公告管理、用户管理、心…
阅读更多...
网上订餐项目（附源代码及数据库）

网上订餐项目（附源代码及数据库）

目录 一、项目概要 二、项目展示 三、数据库 四、项目源码 五、毕设专栏 首页 登录界面 注册页面 一、项目概要 系统主要功能模块有&#xff1a; &#xff08;1&#xff09;首页菜品&#xff1a;主要包括购买菜品、菜品加入购物车的功能 &#xff08;2&#xff09;我的…
阅读更多...
django-rest-framework

django-rest-framework

文章目录 &#xff08;1&#xff09;Web应用模式及API接口 &#xff08;2&#xff09;Restful规范 &#xff08;3&#xff09;drf安装和简单使用 &#xff08;4&#xff09;源码分析 &#xff08;5&#xff09;序列化器-Serializer &#xff08;6&#xff09;局部和全局响应配…
阅读更多...
STL篇之vector

STL篇之vector

一、介绍 1. vector是表示可变大小数组的序列容器。 2. 就像数组一样&#xff0c;vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问&#xff0c;和数组一样高效。但是又不像数组&#xff0c;它的大小是可以动态改变的&#xff0c;而且它…
阅读更多...
NR HARQ (四)dynamic codebook

NR HARQ (四)dynamic codebook

微信同步更新欢迎关注同名modem协议笔记 上篇提到type-1 HARQ-ACK codebook&#xff0c;即semi-static codebook&#xff0c;UE要为每个PDSCH候选位置生成反馈&#xff0c;也会包含实际没有下行传输的PDSCH&#xff0c;再加上配置CBG的场景&#xff0c;HARQ-ACK 码本中包含的无…
阅读更多...
SpringBoot系列之数据库初始化-datasource配置方式

SpringBoot系列之数据库初始化-datasource配置方式

在我们的日常业务开发过程中&#xff0c;如果有db的相关操作&#xff0c;通常我们是直接建立好对应的库表结构&#xff0c;并初始化对应的数据&#xff0c;即更常见的情况下是我们在已有表结构基础之下&#xff0c;进行开发&#xff1b; 但是当我们是以项目形式工作时&#xff…
阅读更多...
HUAWEI WeAutomate RPA初级教程之Excel、数据表和JSON自动化2

HUAWEI WeAutomate RPA初级教程之Excel、数据表和JSON自动化2

阅读更多...
java微信支付v3系列——3.订单创建准备操作

java微信支付v3系列——3.订单创建准备操作

微信支付的下单操作分为了5种&#xff0c;分别是JSAPI、APP、H5以及Native支付及小程序支付&#xff0c;之所以将支付放在单独一个章节&#xff0c;而不是按照支付类型划分一个章节&#xff0c;是因为支付所传递的数据都是相似的&#xff0c;方便我们更好的封装。 本章节是支付…
阅读更多...
20221222英语学习

20221222英语学习

托福词汇 sociology n.社会学 given adj.规定的&#xff0c;特定的&#xff1b;假定的 narrative n.叙述&#xff1b;记叙体&#xff0c;叙述技巧 deplore vt.悲叹&#xff0c;哀叹&#xff0c;公开谴责 despoil vt.夺取&#xff0c;掠夺&#xff1b;毁坏&#xff0c;破坏…
阅读更多...
HUAWEI WeAutomate RPA初级教程之Excel、数据表和JSON自动化

HUAWEI WeAutomate RPA初级教程之Excel、数据表和JSON自动化

阅读更多...
Kubernetes：环境搭建

Kubernetes：环境搭建

文章目录1、k8s 概念1.1、基本概念1.2、基本术语2、k8s 架构2.1、k8s 节点2.2、k8s 组件2.2.1、master 组件2.2.2、node 组件3、k8s 集群安装配置3.1、docker3.2、主机环境调整3.3、安装 kube 工具3.4、Master 节点初始化3.5、node 节点初始化3.6、重置节点4、k8s 集群升级4.1、…
阅读更多...
基于node.js网上蛋糕店系统的设计与实现(论文+项目源码)

基于node.js网上蛋糕店系统的设计与实现(论文+项目源码)

随着互联网应用技术的突飞猛进。信息化广泛使用&#xff0c;已渗透到各行各业。作为代表的以网上购物商城为例。它极大地改变了人们的出行方式以及线上购物发生的转变。网上购物的需求也随着人们的个性化定制而变得相对复杂。用户量以及需求量在网上商城也带来了很多商家的考验…
阅读更多...
c++primer第2章 变量和基本类型

c++primer第2章 变量和基本类型

文章目录第2章 变量和基本类型2.1 基本内置类型2.1.1 算术类型2.1.2 类型转换2.1.3 字面值常量2.2 变量2.2.1 变量定义2.2.2 变量声明与定义的关系2.2.3 标识符2.2.4 名字的作用域第Ⅰ部分 c基础 语法特征 类型 变量 语句 控制结构 函数补充&#xff1a;自定义数据类型(语言扩展…
阅读更多...
Elasticsearch：如何减少 Elasticsearch 集群中的分片数量

Elasticsearch：如何减少 Elasticsearch 集群中的分片数量

在我之前的文章 “Elasticsearch&#xff1a;我的 Elasticsearch 集群中应该有多少个分片&#xff1f;” &#xff0c; 它描述了在我们实际操作中的分片数量的准则。在文章 “Elasticsearch&#xff1a;如何部署 Elasticsearch 来满足自己的要求” 讲述了如何部署 Elasticsearc…
阅读更多...
Prometheus系列之Grafana 版本9.0.0 设置Email邮件报警实战

Prometheus系列之Grafana 版本9.0.0 设置Email邮件报警实战

目录1. 配置文件conf/defaults.ini修改2. Grafana Web页面配置报警邮箱接收者3. 创建Dashboard4. 创建Alert的文件夹5. 设置Notification policies6. 添加Alert7. Alert Rule测试1. 配置文件conf/defaults.ini修改 将conf/defaults.ini的如下内容 ##########################…
阅读更多...
变量提升，函数提升，暂时性死区，详细解析

变量提升，函数提升，暂时性死区，详细解析

变量的提升 JavaScript 在执行之前 会进行预解析 函数声明 函数体会被提升到当前作用域顶部 var的声明会提升 并赋值undefined 因为var会有一个变量提升&#xff0c;他的声明初始化会被提升&#xff0c;但是值不会被提升&#xff0c;所以控制台返回undefined 函数提升 这是…
阅读更多...
CSS -- CSS3基础动画讲解

CSS -- CSS3基础动画讲解

文章目录CSS 3动画1 动画的基本使用2 动画序列3 动画常用属性4 动画简写属性5 速度曲线细节CSS 3动画 动画(animation) 是CSS3中具有颠覆性的特征之一&#xff0c;可通过设置多个节点来精确控制一个或一组动画常用来实现复杂的动画效果。 相比较过渡&#xff0c;动画可以实现…
阅读更多...
白银票据的原理和使用

白银票据的原理和使用

白银票据的原理和使用白银票据(Silver Ticket)原理白银票据的使用服务账号是计算机名字$用来管理服务的账号 白银票据(Silver Ticket)原理 白银票据是伪造本该由TGS返回的ST(服务票据)&#xff0c;从而访问对应的服务 有server用户的hash就可以伪造出ST&#xff0c;且不经过K…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023