C++学习第五天

创作过程中难免有不足，若您发现本文内容有误，恳请不吝赐教。

提示：以下是本篇文章正文内容，下面案例可供参考

一、构造函数

问题1

        关于编译器生成的默认成员函数，很多童鞋会有疑惑：不实现构造函数的情况下，编译器会
生成默认的构造函数。但是看起来默认构造函数又没什么用？ d 对象调用了编译器生成的默认构造函数，但是d 对象 _year/_month/_day ，依旧是随机值。也就说在这里 编译器生成的 默认构造函数并没有什么用？？
        
        解答：C++ 把类型分成内置类型 ( 基本类型 ) 和自定义类型。内置类型就是语言提供的数据类
型，如： int/char... ，自定义类型就是我们使用 class/struct/union 等自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t 调用的它的默认构造函数。

示例1：

#include<iostream>
using namespace std;

class A
{
public:
	A(int a)
	{
		cout << "Aint(a)" << endl;
		_a = a;
	}
private:
	int _a;
};

class Date
{
public:
	//Date(int year, int month, int day)
	//{
	//	_year = year;
	//	_month = month;
	//	_day = day;
	//}
private:
	//内置类型
	int _year;
	int _month;
	int _day;

	//自定义类型
	A _aa;
};

int main()
{
	Date d1;
}

class A没有提供默认构造函数(不用参数就可以调用的构造).

示例2：

#include<iostream>
using namespace std;

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

class Date
{
public:
	//Date(int year, int month, int day)
	//{
	//	_year = year;
	//	_month = month;
	//	_day = day;
	//}
private:
	//内置类型
	int _year;
	int _month;
	int _day;

	//自定义类型
	A _aa;
};

int main()
{
	Date d1;
}

如果A不提供默认构造，需要使用初始化列表才能解决。当前的学习暂时先通过提供全缺省( A(int a = 0) )来解决这个问题.

简单来说：我们不写编译器生成的默认构造函数，对内置类型不做处理，对自定义类型会调用它的默认构造.

二、默认构造函数

  无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。 注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。

       特点：不传参就可以调用的构造就是默认构造.

三、析构函数

   可以简单理解为与构造函数相反的函数，类比Destroy函数.

日期类不需要写析构函数，因为日期类没有资源需要清理，年、月、日属于对象，不需要清理。而像栈这种才需要清理，有指向资源才需要清理。

示例1：

  内置类型的成员，不做处理，造成堆上的空间没有释放，造成内存泄漏。

#include<iostream>
using namespace std;

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)
	{
		_array[_size] = data;
		_size++;
	}

	/*~Stack()
	{
		cout << "~Stack()" << endl;
		free(_array);
		_array = nullptr;
		_size = _capacity = 0;
	}*/
private:
	// 内置类型
	DataType* _array;
	int _capacity;
	int _size;

};

void TestStack()
{
	Stack s;
	s.Push(1);
	s.Push(2);
}

int main()
{
	TestStack();

	return 0;
}

示例2：

自定义类型的成员，会去调用他的析构。

#include<iostream>
using namespace std;

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

	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

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)
	{
		_array[_size] = data;
		_size++;
	}

	/*~Stack()
	{
		cout << "~Stack()" << endl;
		free(_array);
		_array = nullptr;
		_size = _capacity = 0;
	}*/
private:
	// 内置类型
	DataType* _array;
	int _capacity;
	int _size;

	// 自定义类型
	A _aa;
};

void TestStack()
{
	Stack s;
	s.Push(1);
	s.Push(2);
}

int main()
{
	TestStack();

	return 0;
}

四、拷贝构造

日期类拷贝：

#include<iostream>
using namespace std;
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)
	{
		_array[_size] = data;
		_size++;
	}

	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_array);
		_array = nullptr;
		_size = _capacity = 0;
	}
private:
	// 内置类型
	DataType* _array;
	int _capacity;
	int _size;
};

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;
};

void func1(Date d)
{
	d.Print();
}

int main()
{
	Date d1(2025,1,8);
	func1(d1);

	return 0;
}

栈拷贝：

#include<iostream>
using namespace std;
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)
	{
		_array[_size] = data;
		_size++;
	}

	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_array);
		_array = nullptr;
		_size = _capacity = 0;
	}
private:
	// 内置类型
	DataType* _array;
	int _capacity;
	int _size;
};

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;
};

void func1(Date d)
{
	d.Print();
}

void func2(Stack s)
{
	
}

int main()
{
	Date d1(2025,1,8);
	func1(d1);

	Stack s1;
	func2(s1);

	return 0;
}

解决方法：

void func2(Stack& s)
{
	//使用引用
}

拷贝构造函数

        定义：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存

在的类类型对象创建新对象时由编译器自动调用 。
        自定义类型传值传参要调用拷贝构造。

特征1：

      拷贝构造函数是构造函数的一个重载形式。

特征2：

        拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错， 因为会引发无穷递归调用。

#include<iostream>
using namespace std;

class Date
{
public:
	Date(int year, int month, int day)
	{
		cout << "Date(Date& d)" << endl;
		_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(2025,1,8);
	Date d2(d1);

	return 0;
}

	Date(Date d)
	{
        //没有引用会引发无穷递归调用
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

#include<iostream>
using namespace std;

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;
	}

	Stack(Stack& s)
	{
		cout << "Stack(Stack& s)" << endl;
		// 深拷贝
		_array = (DataType*)malloc(sizeof(DataType) * s._capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		
		memcpy(_array, s._array, sizeof(DataType) * s._size);
		_size = s._size;
		_capacity = s._capacity;
	}

	void Push(DataType data)
	{
		_array[_size] = data;
		_size++;
	}

	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_array);
		_array = nullptr;
		_size = _capacity = 0;
	}
private:
	// 内置类型
	DataType* _array;
	int _capacity;
	int _size;
};

void func2(Stack s)
{
	s.Push(1);
}

int main()
{
	Stack s1;
	func2(s1);

	Stack s2(s1);

	return 0;
}

问题：

        如果不写拷贝构造函数，系统会自动生成吗？

#include<iostream>
using namespace std;

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


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

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

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		cout << "Stack()" << endl;

		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}

		_capacity = capacity;
		_size = 0;
	}

	void Push(DataType data)
	{
		_array[_size] = data;
		_size++;
	}

	~Stack()
	{
		cout << "~Stack()" << endl;

		free(_array);
		_array = nullptr;
		_size = _capacity = 0;
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};

int main()
{
	Date d1(2025, 1, 1);
	Date d2 = d1;
    
	Stack st1;
	Stack st2(st1);

	return 0;
}

特征3：

        若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按 字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。 
我们不写，编译默认生成的拷贝构造，跟之前的构造函数特性不一样

1、内置类型， 值拷贝

 2、自定义的类型，调用他的拷贝

 总结：Date不需要我们实现拷贝构造，默认生成就可以用

 Stack需要我们自己实现深拷贝的拷贝构造，默认生成会出问题

MyQueue对于默认生成的几个函数非常受用，人生赢家

#include<iostream>
using namespace std;

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		cout << "Stack()" << endl;

		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}

		_capacity = capacity;
		_size = 0;
	}

	Stack(const Stack& s)
	{
		cout << "Stack(Stack& s)" << endl;
		// 深拷贝
		_array = (DataType*)malloc(sizeof(DataType) * s._capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}

		memcpy(_array, s._array, sizeof(DataType) * s._size);
		_size = s._size;
		_capacity = s._capacity;
	}

	void Push(DataType data)
	{
		_array[_size] = data;
		_size++;
	}

	~Stack()
	{
		cout << "~Stack()" << endl;

		free(_array);
		_array = nullptr;
		_size = _capacity = 0;
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};

class MyQueue
{
private:
	Stack _pushst;
	Stack _popst;
};

int main()
{
    MyQueue mq1;
	MyQueue mq2 = mq1;

	return 0;
}

注意：

	Date(const Date& d)
	{
      //一般情况都加上const
	  cout << "Date(Date& d)" << endl;
	  _year = d._year;
	  _month = d._month;
	  _day = d._day;
	}

 
	Date(const Date& d)
	{
	  cout << "Date(Date& d)" << endl;

      //若不小心写反了，很容易忽视这里的错误
	  d._year = _year ;
	  d._month = _month;
	  d._day = _day;
	}

五、运算符重载

    问题1：

          日期对象如何比较大小？能否用 < .

简单的代码实现：

#include<iostream>
using namespace std;

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

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

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

bool DateLess (const Date& x1,const Date& x2)
{
	if (x1._year < x2._year)
	{
		return true;
	}
	else if (x1._year == x2._year && x1._month < x2._month)
	{
		return true;
	}
	else if (x1._year == x2._year && x1._month == x2._month && x1._day < x2._day)
	{
		return true;
	}
	else
	{
		return false;
	}
}

int main()
{
	Date d1(2025, 1, 1);
	Date d2(2025, 1, 11);

	cout<<DateLess(d1, d2)<<endl;

	return 0;
}

#include<iostream>
using namespace std;

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

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

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

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

int main()
{
	Date d1(2025, 1, 1);
	Date d2(2025, 1, 11);

    cout << (d1 < d2) << endl;
	cout << (operator<(d1, d2)) << endl;

	return 0;
}

写为成员函数：

// d1 < d2  
// d1.operator<(d2)
//操作数顺序不能随便换
bool operator<(const Date& d)
	{
		if (_year < d._year)
		{
			return true;
		}
		else if (_year == d._year && _month < d._month)
		{
			return true;
		}
		else if (_year == d._year && _month == d._month && _day < d._day)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

运算符复用

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

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

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

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

	// d1 <= d2
	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);
	}
}

实现日期+运算

#include<iostream>
using namespace std;

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

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

	int GetMonthDay(int year, int month)
	{
		int monthArray[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

		if (month == 2
			&& ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
		{
			return 29;
		}

		return monthArray[month];
	}

    //如果写成Date& operator+(int day)会发现Date ret = d1 + 50;中d1也会改变，所以该写成+=
	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);
		tmp += day;
		return tmp;

		//tmp._day += day;
		//while (tmp._day > GetMonthDay(tmp._year, tmp._month))
		//{
		//	// 月进位
		//	tmp._day -= GetMonthDay(tmp._year, tmp._month);
		//	++_month;

		//	// 月满了
		//	if (tmp._month == 13)
		//	{
		//		++tmp._year;
		//		tmp._month = 1;
		//	}
		//}
		//return tmp;
	}

private:
	// 内置类型
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2023, 7, 21);
	Date d2(2022, 8, 21);

	Date ret = d1 + 50;
	ret.Print();
	d1.Print();

	return 0;
}

总结

        以上就是今天要讲的内容，本文仅仅简单介绍了c++的基础知识。

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

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

相关文章

2024嵌入式系统的未来发展与技术洞察分享

2024嵌入式系统的未来发展与技术洞察分享

时间如白驹过隙&#xff0c;不知不觉又是一年&#xff0c;这一年收获满满。接下来&#xff0c;将本年度对技术的感悟和洞察分析如下&#xff0c;希望对大家有所帮助。 在过去几十年里&#xff0c;嵌入式系统技术迅速发展&#xff0c;成为现代电子设备和智能硬件的核心组成部分。…
阅读更多...
01设计模式（D3_设计模式类型 - D3_行为型模式）

01设计模式（D3_设计模式类型 - D3_行为型模式）

目录 一、模版方法模式 1. 基本介绍 2. 应用案例一&#xff1a;豆浆制作问题 需求 代码实现 模板方法模式的钩子方法 3. View的draw&#xff08;Android&#xff09; Android中View的draw方法就是使用了模板方法模式 模板方法模式在 Spring 框架应用的源码分析 知识小…
阅读更多...
Linux 中如何使用 inotify-tools 监控目录变化 ？

Linux 中如何使用 inotify-tools 监控目录变化 ？

当 Linux 系统目录中有新文件创建时执行命令&#xff0c;可以通过组合使用工具和脚本实现监控。一种常见的方法是使用 inotify-tools&#xff0c;这是一个允许您监视文件系统事件的实用程序&#xff0c;与 shell 脚本一起使用。 Step 1: 安装 inotify-tools 首先&#xff0c;…
阅读更多...
vid2vid-zero：使用Stable Diffusion进行零样本视频编辑

vid2vid-zero：使用Stable Diffusion进行零样本视频编辑

Paper: Wang W, Jiang Y, Xie K, et al. Zero-shot video editing using off-the-shelf image diffusion models[J]. arXiv preprint arXiv:2303.17599, 2023. Introduction: Unreleased Code: https://github.com/baaivision/vid2vid-zero 目录 一. 预备知识1. diffusion 引导…
阅读更多...
AI 大爆发时代，音视频未来路在何方？

AI 大爆发时代，音视频未来路在何方？

AI 大模型突然大火了 回顾2024年&#xff0c;计算机领域最大的变革应该就是大模型进一步火爆了。回顾下大模型的发展历程&#xff1a; 萌芽期&#xff1a;&#xff08;1950-2005&#xff09; 1956年&#xff1a;计算机专家约翰麦卡锡首次提出“人工智能”概念&#xff0c;标志…
阅读更多...
蓝桥杯训练—完美的代价

蓝桥杯训练—完美的代价

文章目录 一、题目二、示例三、解析四、代码 一、题目 回文串&#xff0c;是一种特殊的字符串&#xff0c;它从左往右读和从右往左读是一样的。现在给你一个串&#xff0c;它不一定是回文的&#xff0c;请你计算最少的交换次数使得该串变成一个完美的回文串。 交换的定义是&am…
阅读更多...
雷电9最新版安装Magisk+LSPosd（新手速通）

雷电9最新版安装Magisk+LSPosd（新手速通）

大家好啊&#xff01;我是NiJiMingCheng 我的博客&#xff1a;NiJiMingCheng 在安卓系统的定制与拓展过程中&#xff0c;获取 ROOT 权限以及安装各类框架是进阶玩家常用的操作&#xff0c;这可以帮助我们实现更多系统层面的个性化功能。今天&#xff0c;我将为大家详细介绍如何…
阅读更多...
【25】Word：林涵-科普文章❗

【25】Word：林涵-科普文章❗

目录 题目​ NO1.2.3 NO4.5.6 NO7.8 NO9.10 NO11.12 不连续选择&#xff1a;按住ctrl按键&#xff0c;不连续选择连续选择&#xff1a;按住shift按键&#xff0c;选择第一个&#xff0c;选择最后一个。中间部分全部被选择 题目 NO1.2.3 布局→纸张方向&#xff1a;横向…
阅读更多...
ESP8266-01S、手机、STM32连接

ESP8266-01S、手机、STM32连接

1、ESP8266-01S的工作原理 1.1、AP和STA ESP8266-01S为WIFI的透传模块&#xff0c;主要模式如下图&#xff1a; 上节说到&#xff0c;我们需要用到AT固件进行局域网应用&#xff08;ESP8266连接的STM32和手机进行连接&#xff09;。 ESP8266为一个WiFi透传模块&#xff0c;和…
阅读更多...
Vscode：问题解决办法 及 Tips 总结

Vscode：问题解决办法 及 Tips 总结

Visual Studio Code&#xff08;简称VSCode&#xff09;是一个功能强大的开源代码编辑器&#xff0c;广泛用于各种编程语言和开发场景&#xff0c;本博客主要记录在使用 VSCode 进行verilog开发时遇到的问题及解决办法&#xff0c;使用过程中的技巧 文章目录 扩展安装失败调试配…
阅读更多...
Comment(爆破+git泄漏+二次注入)

Comment(爆破+git泄漏+二次注入)

通过爆破密码的后三位&#xff0c;获得账号为&#xff1a;zhangwei666 F12查看控制台 使用bugscanteam的githack工具&#xff0c;下载泄漏的源码&#xff0c;根据控制台的提示&#xff0c;完整源码还在历史的commit中 git log –reflog 查看历史记录 查看最新的提交记录&#…
阅读更多...
物联网网关Web服务器--Boa服务器移植与测试

物联网网关Web服务器--Boa服务器移植与测试

1、Boa服务器介绍 BOA 服务器是一个小巧高效的web服务器&#xff0c;是一个运行于unix或linux下的&#xff0c;支持CGI的、适合于嵌入式系统的单任务的http服务器&#xff0c;源代码开放、性能高。 Boa 嵌入式 web 服务器的官方网站是http://www.boa.org/。 特点 轻量级&#x…
阅读更多...
vim文本编辑器

vim文本编辑器

vim命令的使用&#xff1a; [rootxxx ~]# touch aa.txt #首先创建一个文件 [rootxxx ~]# vim aa.txt #vim进入文件aa.txt进行编辑 vim是vi的升级版&#xff0c;具有以下三种基本模式&#xff1a; 输入模式(编辑模式) 点击i进入编辑模式 &#xff08;说明…
阅读更多...
MYSQL主从同步----1、基于binlog 2、基于gtid

MYSQL主从同步----1、基于binlog 2、基于gtid

目录 前提&#xff08;无论是基于binlog还是基于gitd&#xff09; 一、对MySQL主从同步的了解 1、MySQL支持的复制类型 2、为什么要做主从复制 3、主从复制原理---面试会考 二、基于binlog的主从同步 1、主库上的操作 1&#xff09;配置文件 2&#xff09;备份数据库&am…
阅读更多...
opencv笔记2

opencv笔记2

图像灰度 彩色图像转化为灰度图像的过程是图像的灰度化处理。彩色图像中的每个像素的颜色由R&#xff0c;G&#xff0c;B三个分量决定&#xff0c;而每个分量中可取值0-255&#xff0c;这样一个像素点可以有256*256*256变化。而灰度图像是R&#xff0c;G&#xff0c;B三个分量…
阅读更多...
Hadoop•用Web UI查看Hadoop状态词频统计

Hadoop•用Web UI查看Hadoop状态词频统计

听说这里是目录哦 通过Web UI查看Hadoop运行状态&#x1f407;一、关闭防火墙二、在物理计算机添加集群的IP映射三、启动集群四、进入HDFS的Web UI 词频统计&#x1f9a9;1、准备文本数据2、在HDFS创建目录3、上传文件4、查看文件是否上传成功5、运行MapReduce程序6、查看MapRe…
阅读更多...
C语言二级查漏补缺

C语言二级查漏补缺

直接拿错过的选择开始补知识点 二叉树 推荐视频 基础名词讲解 根节点&#xff08;Root&#xff09;&#xff1a;二叉树的顶端节点&#xff0c;没有父节点。子节点&#xff08;Children&#xff09;&#xff1a;每个节点下面的节点。对于二叉树来说&#xff0c;每个节点最多…
阅读更多...
Low-Level 大一统：如何使用Diffusion Models完成视频超分、去雨、去雾、降噪等所有Low-Level 任务？

Low-Level 大一统：如何使用Diffusion Models完成视频超分、去雨、去雾、降噪等所有Low-Level 任务？

Diffusion Models专栏文章汇总：入门与实战 前言：视频在传输过程中常常因为各种因素（如恶劣天气、噪声、压缩和传感器分辨率限制）而出现质量下降，这会严重影响计算机视觉任务（如目标检测和视频监控）的性能。现有的视频修复方法虽然取得了一些进展，但通常只能针对特定的退…
阅读更多...
【22】Word：小李-高新技术企业政策❗

【22】Word：小李-高新技术企业政策❗

目录 题目​ NO1.2 NO3 NO4 NO5.6 NO7.8 NO9.10 若文章中存在删除空白行等要求&#xff0c;可以到最后来完成。注意最后一定要检查此部分&#xff01;注意&#xff1a;大多是和事例一样即可&#xff0c;不用一摸一样&#xff0c;但也不要差太多。 题目 NO1.2 F12Fn&a…
阅读更多...
【前端】CSS学习笔记（1）

【前端】CSS学习笔记（1）

目录 CSS的简介CSS的概念语法 CSS的引入方式内联样式&#xff08;行内样式&#xff09;内部样式外部样式&#xff08;推荐&#xff09; 选择器全局选择器元素选择器类选择器ID选择器合并选择器后代选择器子选择器相邻兄弟选择器通用兄弟选择器伪类选择器:link:visited:hover:ac…
阅读更多...
最新文章

Copyright @ 2022~2023