今天你学C++了吗？——C++中的类与对象（第二集）

♥♥♥~~~~~~欢迎光临知星小度博客空间~~~~~~♥♥♥

♥♥♥零星地变得优秀~也能拼凑出星河~♥♥♥

♥♥♥我们一起努力成为更好的自己~♥♥♥

♥♥♥如果这一篇博客对你有帮助~别忘了点赞分享哦~♥♥♥

♥♥♥如果有什么问题可以评论区留言或者私信我哦~♥♥♥

✨✨✨✨✨✨ 个人主页✨✨✨✨✨✨

在前面一篇博客类与对象（第一集），我们简单了解了一下C++中的类与对象~接下来，我们要更加深层次的探讨C++中的类与对象~体会C++的魅力~准备好了吗~我们发车啦~🚗🚗🚗🚗🚗🚗

目录

类的默认成员函数

构造函数

析构函数

构造函数和析构函数的好处

拷贝构造函数

类的默认成员函数

前面我们提到了类里面有成员变量和成员函数，那么什么是默认成员函数呢？

定义：

》默认成员函数就是用户（程序员）没有显式实现，编译器会自动生成的成员函数称为默认成员函数

⼀个类，我们不写的情况下编译器会默认生成以下6个默认成员函数

接下来，我们一个个来看~

构造函数

构造函数是特殊的成员函数，构造函数虽然名称叫构造，但是 构造函数的 主要任务 并不是开空间创建对象(我们常使用的局部对象是栈帧创建时，空间就已经开好)，而是对象实例化时 初始化对象 。
这样看来，构造函数的本质是要替代我们以前Stack和Date类中写的Init（初始化）函数的功能。同时， 构造函数自动调用 的 特点就完美的替代的了Init函数调用。
构造函数的特点
1. 函数名与类名相同 。
》函数名与类名相同，有利于编译器识别这个函数是用于类初始化的函数，而不是普通的成员函数
例： 
class Date
{
public:
	//构造函数函数名与类名相同
	Date()
	{
		//构造函数
	}
};
2. 无返回值 。 (C++规定构造函数 不需要返回值，同时也不需要写void)
》 构造函数的存在是为了初始化对象，而不是返回数据~我们可以理解为规定~
3. 对象实例化时 系统会 自动调用对应的构造函数 。
》 （这就不需要我们手动调用构造函数了，更加方便，同时也避免了忘记初始化的情况~） 
#include<iostream>
using namespace std;
class Date
{
public:
	//构造函数函数名与类名相同
	Date()
	{
		//构造函数
		cout << "Date()" << endl;
	}
};
int main()
{
	Date d1;//创建一个对象
	//对象实例化时系统会自动调用对应的构造函数
	return 0;
}

4. 构造函数可以重载
》 也就是说我们可以在同一个类里面写多个构造函数，来满足不同的初始化需求~
》 函数重载的要求是函数参数个数或者类型不同 
#include<iostream>
using namespace std;
class Date
{
public:
	//构造函数函数名与类名相同
	Date()
	{
		//构造函数
		cout << "Date()" << endl;
	}
	// 构造函数可以重载
	Date(int y)
	{
		cout << "Date(int y)" << endl;
	}

};
int main()
{
	Date d1;//创建一个对象
	Date d2(2);
	return 0;
}

5. 如果类中没有显式定义构造函数，则C++编译器会自动生成⼀个无参的默认构造函数 ，如果用户显 式定义编译器将不再生成~
》 这样看来，编译器还是十分强大的，当我们忘记写构造函数，编译器自动生成一个没有参数的默认构造函数~

没有写构造函数，就会使用编译器生成的默认构造函数~

6. 无参构造函数、全缺省构造函数、我们不写构造时编译器默认生成的构造函数 ，都叫做 默认构造函数
》 这 三个函数有且只有一个存在 ，不能同时存在（默认构造函数只存在一个）
》 无参构造函数和全缺省构造函数虽然构成函数重载，但是调用时会存在歧义（编译器不知道调用哪一个）
》总结： 不传实参就可以调用的构造函数就叫默认构造函数 
#include<iostream>
using namespace std;
class Date
{
public:
	Date()
	{
		cout << "Date()" << endl;
	}
	Date(int y = 2)
	{
		cout << "Date(int y)" << endl;
	}

};
int main()
{
	Date d1();//创建一个对象
	return 0;
}

因为编译器不知道调用哪一个，虽然没有报错，但是没有输出结果~这是存在歧义的~

7. 编译器生成的默认构造函数，对内置类型成员变量的初始化没有要求，也就是说是是否初始化是由编译器决定的，那么初始化的值也是不确定的。
但是对于自定义类型成员变量必须调用这个成员变量的默认构造函数初始 化。
》 如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要使用初始化列表（后面的博客会讲解）才能解决
例：使用编译器自动生成的默认构造函数，初始化的值是不确定的~可以理解为随机值~

补充：

C++把类型分成 内置类型(基本类型) 和 自定义类型 。
内置类型就是语言提供的原始数据类型 ， 如： int/char/double/指针 等
自定义类型就是我们使用class/struct/union等关键字自己定义的类型

我们来看看下面的代码：

#include<iostream>
using namespace std;
class Date
{
private:
	int _year;
	int _month;
	int _day;

public:
	void Print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
};

int main()
{
	Date d1;//调用编译器生成的默认构造函数
	d1.Print();
	return 0;
}

我们可以看到年月日都是随机的，那么这肯定不是我们想要的~

所以如果这里我们使用编译器自动生成的默认构造函数，不能满足我们的需求~我们就需要自己写构造函数~比如日期类（我们肯定不希望日期是随机的的，未真正初始化的）

#include<iostream>
using namespace std;
class Date
{
private:
	int _year;
	int _month;
	int _day;
	
public:
	//构造函数
	//成员函数前面有一个隐含的this指针
	// Date* const this
	Date(int year,int month,int day)
	{
		_year = year;//相当于this->_year = year;
		_month = month;
		//this->_month = month;
		_day = day;
		//this->_day = day;
	}
	void Print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
};

int main()
{
	Date d1(2024, 11, 11);//调用自己写的构造函数，满足我们的需求
	d1.Print();
	return 0;
}

又比如我们的栈~

#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	//默认构造满足不了需求，需要自己写的构造函数
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
	// ...
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};

那如果是使用两个栈实现一个队列，这种情况如果栈写了构造函数，就不需要写构造函数了~

#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	//默认构造满足不了需求，需要自己写的构造函数
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
	// ...
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};

// 两个Stack实现队列
class MyQueue
{
public:
	//编译器默认生成MyQueue的构造函数调用Stack的构造，完成了两个成员的初始化
private:
	Stack pushst;
	Stack popst;
};
int main()
{
	MyQueue mq;
	return 0;
}

这里栈的构造函数已经实现了队列的成员初始化~

总结：目前来看，大多数情况下需要自己写构造函数，如果一个类里面的成员全部是自定义类型，并且自定义类型的构造函数已经写好了，那么就不需要我们写构造函数了，比如两个栈实现一个队列，后续我们会了解更多的不需要自己写构造函数的情况

析构函数

了解了构造函数，我们就来看看与它作用相反的析构函数，既然构造函数是用来初始化的，那么析构函数就是用来对对象中的资源在生命周期结束时进行清理（类似于以前的Destory函数），比如手动申请的空间等等~

注意：
》 析构函数 不是完成对对象本身的销毁 ，只是 完成对象中资源的清理释放工作 ~比如局部对象是存在栈帧的，函数结束栈帧销毁，他就已经释放了，不需要我们管~像我们动态开辟的内存就需要我们手动释放资源
》 C++规定 对象在销毁时会自动调用析构函数 ，这样就可以 避免我们忘记释放资源而导致内存泄漏~

析构函数的特点

1. 析构函数名是 在类名前加上字符 ~，同时 函数名与类名相同~
2. 无参数无返回值 。 (同样不需要加void)
3. 对象生命周期结束时，系统会自动调用析构函数 。
例： 
#include<iostream>
using namespace std;
class Date
{
public:
	//构造函数函数名与类名相同
	Date()
	{
		//构造函数
		cout << "Date()" << endl;
	}
	//析构函数
	~Date()
	{
		cout << "~Date()" << endl;
	}
};
int main()
{
	Date d1;//对象实例化
	return 0;
}

我们可以看到编译器自动调用了构造函数和析构函数~

4. ⼀个类只能有⼀个析构函数 。若 未显式定义，系统会自动生成默认的析构函数 。
（与前面构造函数类似~）
5. 跟构造函数类似，当我们不写 编译器自动生成的析构函数对内置类型成员不做处理 ， 自定义类型的成员会调用他的析构函数释放资源 。
6. 我们显示写析构函数，对于自定义类型成员也会调用他的析构，也就是说 自定义类型成员无论什么情况都会自动调用析构函数，避免出现内存泄漏的情况~
7. 如果类中 没有申请资源时，析构函数可以不写 ，直接使用编译器生成的默认析构函数，如Date类；如果 默认生成的析构就足够使用，也不需要显示写析构 ，如MyQueue；但是 有资源申请时，一定要自己写析构，否则会造成资源泄漏 ，如Stack（需要我们释放动态申请的空间~）
例： 
#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
	//栈的析构函数必须自己写，释放资源
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};
// 两个Stack实现队列
class MyQueue
{
public:
	//编译器默认生成MyQueue的析构函数调用了Stack的析构，释放的Stack内部的资源
	// 显示写析构，也会自动调用Stack的析构，这才是真正的释放资源
	~MyQueue()
	{
		cout << "~MyQueue" << endl;
	}
private:
	Stack pushst;
	Stack popst;
};
int main()
{
	Stack st;
	MyQueue mq;
	return 0;
}
8. ⼀个局部域的多个对象，C++规定 后定义的先析构，（后面会讲到这个内容）

构造函数和析构函数的好处

》编译器有时候自动生成的默认构造函数和默认构造函数满足我们需求的情况下，可以减少我们的代码量（如两个栈实现队列不需要自己写析构函数，也不需要写构造函数）

》编译器会自动调用构造函数和析构函数，就可以避免内存泄漏或者忘记初始化的情况~同时不用显示调用，也减少了我们的代码量~

拷贝构造函数

接下来就是这篇博客的重点了~拷贝构造函数~首先我们就需要知道拷贝构造函数是干什么的~

拷贝构造函数是用来通过一个已经初始化的对象去初始化另外一个新创建的对象~

拷贝构造函数 显示的第一个参数是自身类类型的引用 ，且任何额外的参数都有默认值~

1. 拷贝构造函数是构造函数的⼀个重载（函数名相同，都是类名）~

可以理解为拷贝构造函数是特殊的构造函数~

2. 拷贝构造函数的 参数只有⼀个 ，并且 必须是类类型对象的引用
》 使用传值方式编译器直接报错，因为语 法逻辑上会引发无穷递归调用~在传参的时候相当于也需要调用拷贝构造函数就回不来了~
例： 
#include<iostream>
using namespace std;
class Date
{
public:
	//构造函数
	Date(int year,int month,int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//拷贝构造函数-——特殊的构造函数
	Date(Date& d)
		//拷贝构造函数的参数只有⼀个，并且必须是类类型对象的引用
	{
		//用已经存在的对象去初始化新的对象
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2024, 11, 11);//d1调用构造函数
	Date d2(d1);//调用拷贝构造函数~用已经存在的对象去初始化新的对象
	Date d3 = d1;//同样是调用拷贝构造函数~用已经存在的对象去初始化新的对象
	d1.Print();
	d2.Print();
	d3.Print();
	return 0;
}
我们可以发现成功使用拷贝构造函数使用已经存在的对象去初始化新创建的对象~
3. C++规定 自定义类型对象进行拷贝行为必须调用拷贝构造 ，所以这里 自定义类型 传值传参 和 传值返回 （它们都会产生临时对象）都会调用拷贝构造完成~
注意：
》 传值返回会产生⼀个临时对象调用拷贝构造
》 传值使用引用返回，返回的是返回对象的别名，没有产生拷贝
》 如果 返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使用引用返回就有问题，这时的引用相当于⼀个野引用，类似⼀个野指针⼀样
》 传引用返回可以减少拷贝，但是 ⼀定要确保返回对象，在当前函数结束后还在，才能使用引用返回~
例： 
#include<iostream>
using namespace std;
class Date
{
public:
	//构造函数（这里是全缺省参数，是默认构造函数的一种
	Date(int year = 1, 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(Date* d)
	{
		_year = d->_year;
		_month = d->_month;
		_day = d->_day;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};


//void Func1(Date d)//调用拷贝构造完成拷贝（产生了一个临时对象）
void Func1(Date& d)//使用引用传参优化，不需要拷贝构造，传自身，减少拷贝构造次数~
{
	cout << "&d" << endl;
	cout << &d << endl;
	cout << "d.Print()" << endl;
	d.Print();
}

Date Func2()//返回对象也会调用拷贝构造函数（相当于产生了一个临时对象）
//Date& Func2()//使用引用返回，不需要拷贝构造，返回自身，存在问题//err
//问题：Func2函数结束，tmp对象就销毁了，相当于了⼀个野引用
{
	Date tmp(2024, 2, 2);
	cout << "tmp.Print()" << endl;
	tmp.Print();
	return tmp;
}
int main()
{
	Date d1(2024, 11, 11);
	cout << "d1.Print()" << endl;
	d1.Print();
	//d1传值传参给d要调用拷贝构造完成拷贝，使用传引用传参可以减少拷贝
	cout << "&d1" << endl;
	cout << &d1 << endl;
	Func1(d1);

	
	Date ret = Func2();
	cout << "ret.Print()" << endl;
	ret.Print();
	return 0;
}

4. 若未显式定义拷贝构造，编译器会自动生成一个拷贝构造函数 ~
》 自动生成的拷贝构造 对内置类型成员变量会完成值拷贝/浅拷贝(⼀个字节⼀个字节的拷贝) ， 对自定义类型成员变量会调用他的拷贝构造 。
例： 
#include<iostream>
using namespace std;
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 d1(2024, 11, 11);//d1调用构造函数
	Date d2(d1);//调用编译器自动生成的拷贝构造函数
	Date d3 = d1;//调用编译器自动生成的拷贝构造函数
	//自动生成的拷贝构造对内置类型成员变量会完成值拷贝/浅拷贝(⼀个字节⼀个字节的拷贝)
	d1.Print();
	d2.Print();
	d3.Print();
	return 0;
}

我们可以发现当我们没有显示写拷贝构造函数的时候，也完成了拷贝~这是因为使用了编译器自动生成的拷贝构造函数~实现了浅拷贝~

》 浅拷贝也就是把对象中的值拷贝过来~相当于共享同一份资源（比如内存空间、文件） ，那么如果对象中存在资源管理，比如动态开辟内存， 当多个对象共享同一份资源（内存空间）时，资源/空间释放的时候就会释放多次 （一个对象销毁时就已经释放了，其他对象不知道依然认为有效的~）这就会出问题~
》 还可能出现的问题是 一个对象修改时，会影响其他与它共享这个资源的对象 ~
》 深拷贝就可以很好的解决这个问题， 每一个对象都独立拥有一份资源（空间） ，这样就不会导致访问出错~
5.
》 像 Date这样的类 成员变量全是内置类型且没有指向什么资源 ，编译器自动生成的拷贝构造就可以完成，那么 不需要我们显示实现拷贝构造 。
》 但是像 Stack这样的类 ，虽然也都是内置类型，但是 _a指向了资源（申请了空间） ，编译器自动生成的拷贝构造完成的值拷贝/浅拷贝不符合我们的需求，所以 需要我们自己实现深拷贝(对指向的资源也进行拷贝) 。
》 像 MyQueue这样的类 ，内部主要是自定义类型 Stack成员， 编译器自动生成的的拷贝构造会调用Stack的拷贝构造 ，也 不需要我们显示实现MyQueue的拷贝构造 。
》小技巧： 区分是否需要显示写拷贝构造，可以 看⼀个类是否显示实现了析构并释放资源 ，如果是就 需要显示写拷贝构造，否则就不需要~
》 总结：类有申请占用资源，就需要我们自己写拷贝构造函数，避免多个对象共享一个资源
例： 
#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
	//涉及资源，需要显示写拷贝构造函数
	Stack(const Stack& st)
	{
		// 需要对_a指向资源创建同样大的资源再拷贝
		_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		
		memcpy(_a, st._a, sizeof(STDataType) * st._top);
		_top = st._top;
		_capacity = st._capacity;
	}

	void Push(STDataType x)
	{
		if (_top == _capacity)
		{
			int newcapacity = _capacity * 2;
			STDataType* tmp = (STDataType*)realloc(_a, newcapacity *
				sizeof(STDataType));
			if (tmp == NULL)
			{
				perror("realloc fail");
				return;
			}
			_a = tmp;
			_capacity = newcapacity;
		}
		_a[_top++] = x;
	}
	//析构函数
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}

private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};

// 两个Stack实现队列
class MyQueue
{
public:
private:
	Stack pushst;
	Stack popst;
};
int main()
{
	Stack st1;
	st1.Push(1);
	st1.Push(2);
	// 如果Stack不显示实现拷贝构造，那么会使用编译器自动生成的拷贝构造完成浅拷贝
	// 会导致st1和st2⾥⾯的_a指针指向同⼀块资源，析构时会析构两次，程序崩溃

	Stack st2 = st1;
	MyQueue mq1;
	// MyQueue自动生成的拷贝构造，会自动调用Stack拷贝构造完成pushst/popst
	// 的拷贝，只要Stack拷贝构造实现了深拷贝，就没问题~
	MyQueue mq2 = mq1;
	return 0;
}

我们可以看到注释掉我们自己写的拷贝构造函数时，st1和st2的_a就是指向的同一块内存空间，资源共享了，就会出问题~

如果使用自己写的拷贝构造函数，就是不同的内存空间，就没有问题了~

♥♥♥本篇博客内容结束，期待与各位优秀程序员交流，有什么问题请私信♥♥♥

♥♥♥如果这一篇博客对你有帮助~别忘了点赞分享哦~♥♥♥

✨✨✨✨✨✨个人主页✨✨✨✨✨✨

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【C++习题】14.滑动窗口_找到字符串中所有字母异位词

【C++习题】14.滑动窗口_找到字符串中所有字母异位词

文章目录 题目链接&#xff1a;题目描述&#xff1a;解法C 算法代码&#xff1a;图解 题目链接&#xff1a; 438. 找到字符串中所有字母异位词 题目描述&#xff1a; 解法 暴力解法&#xff1a; 字母排序后运用滑动窗口解题。 滑动窗口哈希表&#xff1a; 我们可以优化一下&am…
阅读更多...
Spring Boot集成MyBatis-Plus：自定义拦截器实现动态表名切换

Spring Boot集成MyBatis-Plus：自定义拦截器实现动态表名切换

Spring Boot集成MyBatis-Plus&#xff1a;自定义拦截器实现动态表名切换 一、引言 介绍动态表名的场景需求&#xff0c;比如多租户系统、分表分库&#xff0c;或者不同业务模块共用一套代码但操作不同表。说明 MyBatis-Plus 默认绑定固定表名的问题。 二、项目配置 1. 集成 M…
阅读更多...
深入探索API爬虫工作的技术难点与高效解决思路

深入探索API爬虫工作的技术难点与高效解决思路

在大数据与信息化高速发展的今天&#xff0c;API&#xff08;应用程序编程接口&#xff09;爬虫成为了数据收集与分析的重要工具。然而&#xff0c;API爬虫工作并非一帆风顺&#xff0c;它面临着诸多技术挑战。本文将深入探讨几个API爬虫工作的技术难点&#xff0c;并提出相应的…
阅读更多...
css效果

css效果

css炫彩流光圆环效果 <!DOCTYPE html> <html><head><meta charset"utf-8" /><title></title><style>*{margin: 0;padding: 0;}body{width: 100%;height: 100vh;}.container{position: relative;width: 100%;height: 100vh…
阅读更多...
arm Rk1126 编译Qt工程报错： Could not find qmake spec

arm Rk1126 编译Qt工程报错： Could not find qmake spec

首先修改qmake.conf文件&#xff0c;配置好正确的交叉编译工具&#xff1a; 然后执行编译&#xff1a; /opt/Rv1126/Rv1126-盒子代码/rv1126-qt5-sdk/bin/qmake untitled.pro 报错。 原因&#xff1a;中文路径。修改路径为英文路径即可
阅读更多...
zabbix监控进程

zabbix监控进程

使用zabbix监控指定的进程&#xff0c;现在主要使用监控一些用java python写的一些微服务模块&#xff0c;我这边用于演示就直接使用nginx服务来演示了 创建监控项 name - 进程名称&#xff08;默认为 ALL PROCESSES);user - 用户名&#xff08;默认为 all users);state - 可能…
阅读更多...
php 导出excel 一个单元格 多张图片

php 导出excel 一个单元格 多张图片

public function dumpData(){error_reporting(0); // 禁止错误信息输出ini_set(display_errors, 0); // 不显示错误$limit $this->request->post(limit, 20, intval);$offset $this->request->post(offset, 0, intval);$page floor($offset / $limit) 1 ;$wh…
阅读更多...
【C++11】锋芒毕露

【C++11】锋芒毕露

(续) 一、可变参数模板 C11支持可变参数模板&#xff0c;也就是说支持可变数量参数的函数模板和类模板&#xff0c;可变数目的参数被称 为参数包&#xff0c;存在两种参数包&#xff1a;模板参数包&#xff0c;表示零或多个模板参数&#xff1b;函数参数包&#xff1a;表示零…
阅读更多...
用户管理（MySQL）

用户管理（MySQL）

目录 1用户管理&#xff08;MySQL&#xff09; 1.1 用户 1.1.1 用户信息 1.1.2 创建用户(后%是可以任意远端登录) 1.1.3 刷新一下 1.1.4 删除用户 1.1.5 修改用户密码 1.2 数据库的权限 1.2.1 登录创建用户 1.2.2给权限 1.2.2.1 把jj数据库中uu表的权限给woaini这个…
阅读更多...
Hive离线数仓结构分析

Hive离线数仓结构分析

Hive离线数仓结构 首先&#xff0c;在数据源部分&#xff0c;包括源业务库、用户日志、爬虫数据和系统日志&#xff0c;这些都是数据的源头。这些数据通过Sqoop、DataX或 Flume 工具进行提取和导入操作。这些工具负责将不同来源的数据传输到基于 Hive 的离线数据仓库中。 在离线…
阅读更多...
Linux——Uboot命令使用

Linux——Uboot命令使用

什么是Uboot&#xff1f; 1&#xff09;Uboot是一个裸机程序&#xff0c;比较复杂。类似我们PC机的BIOS程序。 2&#xff09;Uboot就是一个bootloader&#xff0c;作用就是用于启动Linux或者其他系统&#xff0c;Uboot最主要的工作是初始化DDR&#xff0c;因为Linux的运行是运行…
阅读更多...
Cannal实现MySQL主从同步环境搭建

Cannal实现MySQL主从同步环境搭建

大家好&#xff0c;我是袁庭新。 在多数情况下&#xff0c;客户端往往会优先获取缓存中的数据。然而&#xff0c;当缓存数据与数据库中的实际数据存在显著不一致时&#xff0c;可能会导致严重的后果。因此&#xff0c;确保数据库与缓存数据之间的一致性变得至关重要&#xff0c…
阅读更多...
C++《二叉搜索树》

C++《二叉搜索树》

在初阶数据结构中我学习了树基础的概念以及了解了顺序结构的二叉树——堆和链式结构二叉树该如何实现&#xff0c;那么接下来我们将进一步的学习二叉树&#xff0c;在此会先后学习到二叉搜索树、AVL树、红黑树&#xff1b;通过这些的学习将让我们更易于理解后面set、map、哈希等…
阅读更多...
C++ —— 以真我之名 如飞花般绚丽 - 智能指针

C++ —— 以真我之名 如飞花般绚丽 - 智能指针

目录 1. RAII和智能指针的设计思路 2. C标准库智能指针的使用 2.1 auto_ptr 2.2 unique_ptr 2.3 简单模拟实现auto_ptr和unique_ptr的核心功能 2.4 shared_ptr 2.4.1 make_shared 2.5 weak_ptr 2.6 shared_ptr的缺陷&#xff1a;循环引用问题 3. shared_ptr 和 unique_…
阅读更多...
springboot项目使用maven打包，第三方jar问题

springboot项目使用maven打包，第三方jar问题

springboot项目使用maven package打包为可执行jar后&#xff0c;第三方jar会被打包进去吗&#xff1f; 答案是肯定的。做了实验如下&#xff1a; 第三方jar的项目结构及jar包结构如下&#xff1a;&#xff08;该第三方jar采用的是maven工程&#xff0c;打包为普通jar&#xf…
阅读更多...
第六届智能控制、测量与信号处理国际学术会议 (ICMSP 2024)

第六届智能控制、测量与信号处理国际学术会议 (ICMSP 2024)

重要信息 2024年11月29日-12月1日 中国陕西西安石油大学雁塔校区 大会官网&#xff1a;www.icmsp.net 大会简介 第六届智能控制、测量与信号处理国际学术会议&#xff08;ICMSP 2024&#xff09;由西安石油大学、中海油田服务股份有限公司、浙江水利水电学院与中国石油装备…
阅读更多...
设计LRU缓存

设计LRU缓存

LRU缓存 LRU缓存的实现思路LRU缓存的操作C11 STL实现LRU缓存自行设计双向链表 哈希表 LRU&#xff08;Least Recently Used&#xff0c;最近最少使用&#xff09;缓存是一种常见的缓存淘汰算法&#xff0c;其基本思想是&#xff1a;当缓存空间已满时&#xff0c;移除最近最少使…
阅读更多...
跨平台应用开发框架（1）----Qt(组件篇)

跨平台应用开发框架（1）----Qt(组件篇)

目录 1.Qt 1.Qt 的主要特点 2.Qt的使用场景 3.Qt的版本 2.QtSDK 1.Qt SDK 的组成部分 2.安装 Qt SDK 3.Qt SDK 的优势 3.Qt初识 1.快速上手 widget.cpp mian.cpp widget.h Helloworld.pro 2.对象树 3.坐标系 4.信号和槽 1. 信号和槽的基本概念 2. 信号和槽的…
阅读更多...
Vue3+SpringBoot3+Sa-Token+Redis+mysql8通用权限系统

Vue3+SpringBoot3+Sa-Token+Redis+mysql8通用权限系统

sa-token支持分布式token 前后端代码&#xff0c;地球号: bright12389
阅读更多...
专题二十三_动态规划_回文串系列问题_算法专题详细总结

专题二十三_动态规划_回文串系列问题_算法专题详细总结

目录 动态规划 回文串系列问题 1. 回⽂⼦串&#xff08;medium&#xff09; 解析&#xff1a; 解决回文串问题&#xff0c;这里提供三个思路&#xff1a; 1.中心扩展法&#xff1a;n^2 / 1 2.马拉车算法&#xff1a;n / n 3.动态规划算法&#xff1a;n^2 / n^2 1.状态表…
阅读更多...
最新文章

Copyright @ 2022~2023