[C++]类与对象下篇

news2024/12/23 10:19:54

目录

类与对象下篇::

                            1.再谈构造函数

                            2.static成员

                            3.友元

                            4.内部类

                            5.匿名对象

                            6.拷贝对象时的编译器优化

                            7.再次理解封装

                            8.求1+2+...n(不能使用乘除法、循环、条件判断)

                            9.计算日期到天数的转换

                           10.日期差值

                           11.打印日期

                           12.累加天数


类与对象下篇::

1.再谈构造函数

构造函数体赋值:

在创建对象时,编译器通过调用构造函数,给对象中各个成员变量一个合适的初始值。

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

虽然上述构造函数调用之后,对象中已经有了一个初始值,但是不能将其称为对象中成员变量的初始化,构造函数体中的语句只能将其称为赋初始值,而不能称作初始化,因为初始化只能初始一次,而构造函数体内可以多次赋值。

初始化列表:

以一个冒号开始,接着是一个以逗号分隔的数据成员列表,每个成员变量后面跟一个放在括号中的初始值或表达式。

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

注意:

1.每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

2.类中包含一次啊成员必须放在初始化列表中进行初始化:

        a.引用成员变量

        b.const成员变量

        c.自定义类型成员(该类没有构造函数)

class A
{
public:
	A(int a)
		:_a(a)
	{}
private:
	int _a;
};
class B
{
public:
	B(int a, int ref)
		:_aobj(a)
		, _ref(ref)
		, _n(10)
	{}
private:
	A _aobj;  // 没有默认构造函数
	int& _ref;  // 引用
	const int _n; // const 
};

3.尽量使用初始化列表初始化,因为不管你是否使用初始化列表,对于自定义类型成员变量,一定会先使用初始化列表初始化。

class Time
{
public:
	Time(int hour = 0)
		:_hour(hour)
	{
		cout << "Time()" << endl;
	}
private:
	int _hour;
};
class Date
{
public:
	Date(int day)
	{}
private:
	int _day;
	Time _t;
};
int main()
{
	Date d(1);
}

4.成员变量在类中声明次序就是其在初始化列表中的初始化顺序,与其在初始化列表中的先后次序无关。

class A
{
public:
	A(int a)
		:_a1(a)
		, _a2(_a1)
	{}

	void Print() 
	{
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a2;
	int _a1;
};
int main() 
{
	A aa(1);
	aa.Print();
}
A.输出1  1
B.程序崩溃
C.编译不通过
D.输出1  随机值
答案:D

explicit关键字

构造函数不仅可以构造与初始化对象,对于单个参数或者第一个参数无默认值其余均有默认值以及全缺省的构造函数,还具有类型转换的作用。用explicit修饰构造函数,将会禁止构造函数的隐式转换。

class Date
{
public:
		// 1. 单参构造函数,没有使用explicit修饰,具有类型转换作用 —— C++98
		// explicit修饰构造函数,禁止类型转换---explicit去掉之后,代码可以通过编译
		explicit Date(int year)
		:_year(year)
	{}
		/*
 //2. 虽然有多个参数,但是创建对象时后两个参数可以不传递,没有使用explicit修饰,具
有类型转换作用
 // explicit修饰构造函数,禁止类型转换
 explicit Date(int year, int month = 1, int day = 1)
 : _year(year)
 , _month(month)
 , _day(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;
};
void Test()
{
	Date d1(2022);
	// 用一个整形变量给日期类型对象赋值
	// 实际编译器背后会用2023构造一个无名对象,最后用无名对象给d1对象进行赋值
	d1 = 2023;
	// 将1屏蔽掉,2放开时则编译失败,因为explicit修饰构造函数,禁止了单参构造函数类型转换的作用
}
class Date
{
public:
	//多参数构造函数——C++11
	Date(int year, int month, int day)
		:_year(year)
		,_month(month)
		,_day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1 = { 2023,4,12 };//优化后等价于Date d1(2023,4,12);
	const Date& d2 = { 2023,4,12 };
	return 0;
}

2.static成员

声明为static的类成员称为类的静态成员,用static修饰的成员变量,称之为静态成员变量,用static修饰的成员函数,称之为静态成员函数。静态成员函数一定要在类外进行初始化。

面试题:实现一个类,计算程序中创建出了多少个类对象。

class A
{
public:
	A() 
    { 
		++_N; 
    }
	A(const A & t) 
	{ 
		++_N; 
	}
	~A() 
	{ 
		--_N; 
	}
	static int GetACount() 
	{ 
		return _N;
	}
private:
	static int _N;
};
int A::_N = 0;
void TestA()
{
	cout << A::GetACount() << endl;
	A a1, a2;
	A a3(a1);
	cout << A::GetACount() << endl;
}

static成员变量属于类,并且类的每个对象共享,生命周期是全局的,作用域受类域限制,只能在类域中使用 在main函数中使用需要加访问限定符A::N或者a.N(但静态变量N不在a里面)(前提在类中静态成员变量设置成公有的)

静态成员函数没有this指针,在main函数中调用既可以a.GetN()又可以A::GetN(),所以静态成员函数是配合静态成员变量使用的。

静态成员的特性:

1.静态成员为所有类对象所共享,不属于某个具体的对象,存放在静态区。

2.静态成员变量必须在类外定义,定义时不添加static关键字,类中只是声明。

3.类静态成员即可用类名::静态成员 或者 对象.静态成员 来访问。

4.静态成员函数没有隐藏的this指针,不能访问任何静态成员。

5.静态成员也是类的成员,受public、protected、private访问限定符的限制。

//面试题:
//要求类对象只能在栈上 不允许static A a1以及A* ptr = new A出现
class A
{
public:
	//解决办法;使用静态 静态不用定义对象就可以调用
	static A GetObj(int a = 0)
	{
		//换句话说在这里调用对象只允许A aa这么调用 没有体现另外两种方式的创建
		A aa(a);
		return aa;
	}
private:
	A(int a = 0)
		:_a(a)
	{}
private:
	int _a;
};
int main()
{
	/*static A aa1;
	A* ptr = new A;
	A aa2;*/
	//面临问题:先有鸡还是先有蛋 创建aa3对象要先创建函数 要调用这个成员函数也要先创建对象用.操作符访问GetObj()函数
	A aa3 = A:: GetObj(10);
	return 0;
}

3.友元

友元提供了一种突破封装的方式,有时提供了便利。但是友元会增加耦合度,破坏了封装,所以友元不宜多用。

友元分为:友元函数和友元类

友元函数:

问题:现在尝试去重载operator<<,然后发现没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置,this指针默认是第一个参数也就是左操作数了。但是实际中使用中cout需要是第一个形参对象,才能正常使用。所以要将operator<<重载成全局函数。但又会导致类外没办法访问成员,此时就需要友元来解决。operator>>同理。

class Date
{
public:
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
	// d1 << cout; -> d1.operator<<(&d1, cout); 不符合常规调用
    // 因为成员函数第一个参数一定是隐藏的this,所以d1必须放在<<的左侧
	ostream& operator<<(ostream& _cout)
	{
		_cout << _year << "-" << _month << "-" << _day << endl;
		return _cout;
	}
private:
	int _year;
	int _month;
	int _day;
};

友元函数可以直接访问类的私有成员,它是定义在类外部的普通函数,不属于任何类,但需要早类的内部声明,声明时需要加friend关键字。

class Date
{
	friend ostream& operator<<(ostream& _cout, const Date& d);
	friend istream& operator>>(istream& _cin, Date& d);
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
}
ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "-" << d._month << "-" << d._day;
	return _cout;
}
istream& operator>>(istream& _cin, Date& d)
{
	_cin >> d._year;
	_cin >> d._month;
	_cin >> d._day;
	return _cin;
}
int main()
{
	Date d;
	cin >> d;
	cout << d << endl;
	return 0;
}

说明:

1.友元函数可访问类的私有和保护成员,但不是类的成员函数

2.友元函数不能用const修饰,是因为友元函数只是一个普通函数,没有this指针

3.友元函数可以在类定义的任何地方声明,不受类访问限定符的限制

4.一个函数可以是多个类的友元函数

5.友元函数的调用与普通函数的调用原理相同

友元类:

1.友元类的所有成员函数都可以是另一个类的友元函数,,都可以访问另一个类中的私有成员。

2.友元关系是单向的,不具有交换性。比如上述Time类和Date类,在Time类中声明Date类为其友元类,那么可以在Date类中直接访问Time类的私有成员变量,但想在Time类中访问Date类中私有的成员变量则不行。

3.友元关系不能传递。如果C是B的友元,B是A的友元,但不能说明C是A的友元。

4.友元关系不能继承。

class Time
{
	// 声明日期类为时间类的友元类,则在日期类中就直接访问Time类中的私有成员变量
	friend class Date;
public:
	Time(int hour = 0, int minute = 0, int second = 0)
		: _hour(hour)
		, _minute(minute)
		, _second(second)
	{}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}

	void SetTimeOfDate(int hour, int minute, int second)
	{
		// 直接访问时间类私有的成员变量
		_t._hour = hour;
		_t._minute = minute;
		_t._second = second;
	}

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

4.内部类

概念:如果一个类定义在另一个类的内部,这个类就叫做内部类。内部类是一个独立的类,它不属于外部类,更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。

注意:

1.内部类就是外部类的友元类,参见友元类的定义,内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

2.内部类虽然定义在类的里面,但完全是两个独立的类,和定义在类外面没有区别,真正的影响点是B类的访问受A的类域和访问限定符的限制,内部类受访问限定符的限制,如果一个内部类被设置成私有,那么main函数无法访问。

内部类的特性:

1.内部类可以定在外部类的public、protected、private都是可以的。

2.注意内部类可以直接访问外部类中的static成员,不需要外部类的对象/类名。

3.sizeof(外部类) = 外部类,和内部类没有任何关系。

class A
{
private:
	static int k;
	int h;
public:
	class B // B天生就是A的友元
	{
	public:
		void foo(const A& a)
		{
			cout << k << endl;//OK
			cout << a.h << endl;//OK
		}
	};
};
int A::k = 1;
int main()
{
	A::B b;
	b.foo(A());
	return 0;
}

5.匿名对象

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
class Solution {
public:
	int Sum_Solution(int n) {
		//...
		return n;
	}
};
int main()
{
	A aa1;
	// 不能这么定义对象,因为编译器无法识别下面是一个函数声明,还是对象定义
	//A aa1();
	// 但是我们可以这么定义匿名对象,匿名对象的特点不用取名字,
	// 但是他的生命周期只有这一行,我们可以看到下一行他就会自动调用析构函数
	A();
	A aa2(2);
	// 匿名对象在这样场景下就很好用,当然还有一些其他使用场景,这个我们以后遇到了再说
	Solution().Sum_Solution(10);
	return 0;
}

6.拷贝对象时的编译器优化

在传参和传返回值的过程中,一般编译器会做一些优化,减少对象的拷贝。

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	A(const A& aa)
		:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}
	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{
			_a = aa._a;
		}
		return *this;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
void f1(A aa)
{}
A f2()
{
	A aa;
	return aa;
}
int main()
{
	// 传值传参
	A aa1;
	f1(aa1);
	cout << endl;
	// 传值返回
	f2();
	cout << endl;
	// 隐式类型,连续构造+拷贝构造->优化为直接构造
	f1(1);
	// 一个表达式中,连续构造+拷贝构造->优化为一个构造
	f1(A(2));
	cout << endl;
	// 一个表达式中,连续拷贝构造+拷贝构造->优化一个拷贝构造
	A aa2 = f2();
	cout << endl;
	// 一个表达式中,连续拷贝构造+赋值重载->无法优化
	aa1 = f2();
	cout << endl;
	return 0;
}

7.再次理解封装

现实生活中的实体,计算机并不认识,计算机只认识二进制格式的数据,如果想要让计算机认识现实生活中的实体,用户必须通过某种面向对象的语言,对实体进行描述,然后通过编写程序,创建对象后计算机才可以认识。比如想要让计算机认识洗衣机,就需要:

1.用户先要对现实中洗衣机实体进行抽象—即在人为思想层面对洗衣机进行认识,洗衣机有什么属性,有哪些功能,即对洗衣机进行抽象认知的一个过程。

2.经过1之后,在人的头脑中已经对洗衣机有了一个清醒的认识,只不过此时计算机还不清楚,想要让计算机识别人想象中的洗衣机,就需要人通过某种面向对象的语言(比如:C++、Java、Python等)将洗衣机用类来进行描述,并输入到计算机中。

3.经过2之后,在计算机中就有了一个洗衣机类,但是洗衣机类只是站在计算机的角度对洗衣机对象进行描述的,通过洗衣机类可以实例化出一个个具体的洗衣机对象,此时计算机才能识别洗衣机是什么东西。

4.用户就可以借助计算机中洗衣机对象,来模拟现实中的洗衣机实体了,在类和对象阶段,大家一定要体会到,类是对某一类实体(对象)来进行描述的,描述该对象具有哪些属性,哪些方法,描述完成后就形成了一种新的自定义类型,用该自定义类型就可以实例化具体的对象。

 

8.求1+2+...n(不能使用乘除法、循环、条件判断)

//方法一:创建n个对象调用n次构造函数
class Sum
{
public:
	Sum()
	{
		_ret += _i;
		++_i;
	}
	static int GetRet()
	{
		return _ret;
	}
private:
	static int _i;
	static int _ret;
};
int Sum::_i = 1;
int Sum::_ret = 0;
class Solution
{
public:
	int Sum_Solution(int n)
	{
		// 变长数组 返回值类型为类Sum
		//Sum arr[n];//调用n次构造函数
		return Sum::GetRet();
	}
};
//方法二:内部类
//利用内部类的两个性质:
//1.内部类可以直接访问外部类的静态成员
//2.内部类是外部类的友元
class Solution
{
public:
	class Sum
	{
	public:
		Sum()
		{
			//内部类可以直接访问外部类的静态成员
			_ret += _i;
			++_i;
		}
		static int GetRet()
		{
			return _ret;
		}
	};
	int Sum_Solution(int n)
	{
		// 变长数组 返回值类型为类Sum
		//Sum arr[n];//调用n次构造函数
		return _ret;
	}
//把原有内部类的成员变量放到外部类来
private:
	static int _i;
	static int _ret;
};
int Solution::_i = 1;
int Solution::_ret = 0;

9.计算日期到天数的转换

10.日期差值

#include <iostream>
using namespace std;
/*
 思路:
 1.分别求出每一个日期与0000年0月1日距离的天数
 2.两个距离天数相减即可得到两个日期相差的天数
*/
//平年从1月到n月的天数
int mon[12] = { 0,31,59,90,120,151,181,212,243,273,304,334 };
//给出年月日,计算距离0000年0月1日的天数和
int CountDay(int y, int m, int d)
{
	// 计算0-y年的天数
	int yearDay = y * 365 + y / 4 - y / 100 + y / 400;
	// 计算到0-m月的天数
	int monthDay = mon[m - 1];
	if (m > 2 && ((y % 4 == 0 && y % 100 != 0) || y % 400 == 0))
	{
		monthDay += 1;
	}
	return yearDay + monthDay + d;
}
int main()
{
	int year1, month1, day1;
	scanf("%4d%2d%2d", &year1, &month1, &day1);
	int n1 = CountDay(year1, month1, day1);
	int year2, month2, day2;
	scanf("%4d%2d%2d", &year2, &month2, &day2);
	int n2 = CountDay(year2, month2, day2);
	cout << abs(n1 - n2) + 1 << endl;
	return 0;
}

11.打印日期

#include <iostream>
using namespace std;
int main()
{
	int year;
	int day;
	int mon[13] = { 31, 28, 31, 30, 31, 30, 31, 31, 30 ,31, 30, 31 };
	while (cin >> year >> day)
	{
		if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0))
		{
			mon[1] = 29;
		}
		else
		{
			mon[1] = 28;
		}
		for (int i = 0; i < 12; i++)
		{
			if (day <= mon[i])
			{
				printf("%04d-%02d-%02d\n", year, i + 1, day);
				break;
			}
			else
			{
				day = day - mon[i];
			}
		}
	}
	return 0;
}

12.累加天数

#include<iostream>
using namespace std;
int main()
{
	int n;
	while (cin >> n)
	{
		for (int i = 0; i < n; i++)
		{
			int y, m, d, num;
			int days[12] = { 31,28,31,30,31,30,31,31,30,31,30,31 };
			cin >> y >> m >> d >> num;
			d += num;
			while (d > days[m - 1])
			{
				if (y % 400 == 0 || (y % 4 == 0 && y % 100 != 0))
				{
					days[1] = 29;
				}
				else
				{
					days[1] = 28;
				}
				d -= days[m - 1];
				if (d == 0)
				{
					d = 1;
				}
				m++;
				if (m == 13)
				{
					y++;
					m = 1;
				}
			}
			printf("%4d-%02d-%02d\n", y, m, d);
		}
	}
	return 0;
}

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

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

相关文章

数据结构与算法七 堆

一 堆 1.1 堆定义 堆是计算机科学中一类特殊的数据结构的统称&#xff0c;堆通常可以被看做是一棵完全二叉树的数组对象。 堆的特性&#xff1a; 它是完全二叉树&#xff0c;除了树的最后一层结点不需要是满的&#xff0c;其它的每一层从左到右都是满的&#xff0c;如果最后…

4月最新编程排行出炉,第一名ChatGPT都在用~

作为一名合格的&#xff08;准&#xff09;程序员&#xff0c;必做的一件事是关注编程语言的热度&#xff0c;编程榜代表了编程语言的市场占比变化&#xff0c;它的变化更预示着未来的科技风向和机会&#xff01; 快跟着一起看看本月排行有何看点&#xff1a; 4月Tiobe排行榜前…

【CSS】使用 固定定位 实现顶部导航栏 ( 核心要点 | 固定定位元素居中设置 | 代码示例 )

文章目录一、核心要点分析1、顶部导航栏要点2、固定定位垂直居中设置二、代码示例一、核心要点分析 实现下图所示功能 : 上方有一个固定导航栏 , 水平居中设置 ;左右两侧各一个广告栏 , 垂直居中设置 ; 1、顶部导航栏要点 顶部导航栏要点 : 使用固定定位 , 上边偏移设置为 0 …

Linux Ubuntu虚拟机下载安装以及初始配置--VMware、Ubuntu、Xshell、Xftp

一、下载准备 Ubuntu系统下载链接&#xff08;系统本身&#xff09;&#xff1a;官网链接 VMware虚拟机下载链接&#xff08;搭载Ubuntu系统&#xff09;&#xff1a;网盘链接密码XMKD Xshell下载链接&#xff08;虚拟机远程连接&#xff09;&#xff1a;官网链接 Xftp下载…

MySQL索引数据结构入门

之前松哥写过一个 MySQL 系列&#xff0c;但是当时是基于 MySQL5.7 的&#xff0c;最近有空在看 MySQL8 的文档&#xff0c;发现和 MySQL5.7 相比还是有不少变化&#xff0c;同时 MySQL 又是小伙伴们在面试时一个非常重要的知识点&#xff0c;因此松哥打算最近再抽空和小伙伴们…

PyQt5学习笔记一、安装PyQt5和在PyCharm中配置工具

一、安装PyQt5 1. 可以在cmd窗口安装PyQt5和工具 可以在cmd窗口使用命令 pip install PyQt5 安装PyQt5&#xff0c;若指定版本使用命令 pip install PyQt5version&#xff0c;此时同时安装了PyQt5和sip。参考链接 在cmd命令窗口安装Python模块_Mr. 李大白的博客-CSDN博客htt…

potPlay——记忆播放位置、各种快捷键

potPlay——记忆播放位置、各种快捷键potPlay——各种快捷键简洁版完整版快捷键列表potPlay——记忆播放位置potPlay——各种快捷键 简洁版 Q 复位 亮度&#xff0c;对比度&#xff0c;色度复位键 W/E 调暗/调亮 R/T 对比度 Y/U 饱和度 I/O 色彩度 D 上一帧 F 下一帧 M 静音 …

Docker开启并配置远程安全访问

前言 在工作学习中&#xff0c;为了提高项目部署效率&#xff0c;一般会在Idea中直接使用Docker插件连接服务器Docker容器&#xff0c;然后将项目打包与DockerFile一起build成Docker镜像部署运行。但是不可能服务器总是跟着主机的&#xff0c;因此呢时常会面临的一个问题就是从…

【微信小程序】-- uni-app 项目--- 购物车 -- 配置 tabBar 效果(五十一)

&#x1f48c; 所属专栏&#xff1a;【微信小程序开发教程】 &#x1f600; 作  者&#xff1a;我是夜阑的狗&#x1f436; &#x1f680; 个人简介&#xff1a;一个正在努力学技术的CV工程师&#xff0c;专注基础和实战分享 &#xff0c;欢迎咨询&#xff01; &…

事务的ACID特性

1. 絮絮叨叨 重温Apache ORC时&#xff0c;发现ORC支持ACID想起自己之前一度不知道ACID是哪些单词的缩写&#xff0c;更别提面试中常提到的事物隔离级别等知识了因此&#xff0c;特地学习一下数据库中事务的ACID 2. ACID 2.1 What’s transaction&#xff1f; 考虑一个真实…

42.原型对象 prototype

目录 1 面向对象与面向过程 2 原型对象 prototype 3 在内置对象中添加方法 4 constructor 属性 5 实例对象原型 __proto__ 6 原型继承 7 原型链与instanceof 7.1 原型链 7.2 instanceof 8 案例-模态框 1 面向对象与面向过程 编程思想有 面向过程 与 面向…

几何-九种二次曲面类型

&#xff08;一&#xff09;椭圆锥面 &#xff08;1&#xff09;把z平方看成一个一直变大的常数&#xff0c;那么可以看出延z方向&#xff0c;是一个一直变大的椭圆。 &#xff08;2&#xff09;把一个x或y赋予0&#xff0c;显然是一个两条关于原点对称的直线。 由上即可判断…

不小心删除了文件能恢复吗 误删除文件怎么找回

电脑是我们平时工作或者生活、学习中使用频率非常高的电子设备&#xff0c;已经成为了我们日常生活中不可或缺的一部分。删除文件是电脑使用过程中常见的一种操作&#xff0c;因为电脑的储存空间是有限的&#xff0c;我们需要对电脑数据进行清理&#xff0c;避免电脑储存空间占…

视觉检测相比于人工目视检测有哪些优势

技术的发展可以给我们带来好的结果。 是其中之一。 这在现代工业生产中非常常见。 视觉检测设备可以更好地检测生产中的错误和产品质量问题&#xff0c;提高工业生产的效率和自动化水平&#xff0c;提高工业生产的准确性&#xff0c;加快工作进度&#xff0c;节约时间&#xff…

docker too many open files解决方式

1&#xff1a;问题描述 今天在环境上执行docker ps命令失败&#xff0c;如下提示 [rootcontrol02 ~]# docker ps -a lgrep nginx Cannot connect to the Docker daemon at unix:///var/run/docker.sock, Is the docker daemon running?2&#xff1a;查看节点docker状态 看信…

【Arduino 和 HC-12 远程无线通信模块】

【Arduino 和 HC-12 远程无线通信模块】 1. 概述2. HC-12 无线通信模块3. Arduino 和 HC-123.1 原理图3.2 示例 01 – Arduino 代码3.3 AT 命令:3.4 例子 023.5 代码说明:4. HC-12 无线通信:使用加速度计的步进电机控制4.1 原理图4.2 代码说明:1. 概述 在本Arduino教程中,…

Web 开发的一些常用基础——HTTP请求、响应、Cookies、Session

HTTP 请求 进入浏览器的开发者模式下的 Network 监听组件&#xff0c;访问百度 https://www.baidu.com/&#xff0c;输入该 URL 后回车&#xff0c;观察这个过程中发生了怎样的网络请求&#xff1a; 请求&#xff0c;由客户端向服务端发出&#xff0c;可以分为 4 部分内容&…

基于DSP+FPGA的多轴运动控制平台(一)硬件设计

2实验平台总体方案与硬件设计 2.1.1 实验平台的功能需求分析 针对便于多轴运动控制技术的研究&#xff0c;培养此方面技术的人才&#xff0c;实验平台应能 对多轴运动实现高速高精度的控制效果&#xff0c;同时保证系统开放性和兼容多种算法及 参数的运行。 实验过程契合实际工…

4.16--计算机网络之HTTP篇之常见面试题篇--(复习+深入)---好好沉淀,加油呀

1.HTTP 基本概念 1.HTTP 是什么&#xff1f; HTTP 是超文本传输协议 HTTP 是一个在计算机世界里专门在「两点」之间「传输」文字、图片、音频、视频等「超文本」数据的「约定和规范」。 「HTTP 是用于从互联网服务器传输超文本到本地浏览器的协议」&#xff0c;这种说法正确吗…

Android -- OkHttp的简单使用和封装

OkHttp的封装 由于是封装我们可以吧OKHttp和Gson给结合起来&#xff0c;那么我们在gradle文件添加以下的依赖 1 2 3 compile "com.squareup.okhttp:okhttp:2.4.0" compile com.squareup.okio:okio:1.5.0 compile "com.google.code.gson:gson:2.8.0" ①Ca…