【C++修炼之路】类和对象(下)—— 完结篇

👑作者主页:@安 度 因
🏠学习社区:StackFrame
📖专栏链接:C++修炼之路

文章目录

  • 一、再谈构造函数
    • 1、初始化列表
    • 2、explicit 关键字
  • 二、static 成员
    • 1、概念
    • 2、特性
  • 三、友元
    • 1、友元函数
    • 2、友元类
  • 四、内部类
  • 五、匿名对象
  • 六、构造(拷贝构造)对象时的一些编译器优化
  • 七、再谈类和对象

如果无聊的话,就来逛逛 我的博客栈 吧! 🌹

一、再谈构造函数

1、初始化列表

初始化列表:对于 构造函数(构造与拷贝构造) 来说,以一个冒号开始,接着一个以逗号分隔的数据成员列表,每个"成员变量"后面跟一个放在括号中的初始值或表达式,每个成员变量只能初始化一次,对于变量来说可以初始化也可以不初始化

Date d1(2023, 2, 5); // 对象整体定义的地方
初始化列表:对象的成员定义的地方

例如:

image-20230206174557243

当然 _year 的括号内也可以为 -year ,甚至是常量,都可以。初始化时,就会根据初始化列表的表达式内容进行初始化。

类中包含以下成员,必须放在初始化列表位置进行初始化

  • const 成员变量
  • 引用成员变量
  • 没有默认构造函数的自定义类型成员变量(对象必须初始化,如果没有默认构造的成员变量无法构造就要报错)

因为对于 const 修饰的变量来说,必须在定义时初始化 ,否则后面不可改,引用也是一个道理;而对于没有默认构造函数的自定义类型,由于无法自动调用它的默认构造函数,所以也需要在定义时初始化。

对于:

class A
{
private:
	int _year;
	int _month;
	int _day;
	const int _N;
	int& _ref;
	A _aa;  
};

int main()
{
    A aa; // 对整个对象进行定义
}

对于类中的成员,它们只是成员变量的声明 ,不能在这里初始化;而定义则是在主函数中对对象整体进行定义并不是成员定义的地方 ,当在构造函数中,对 _N 进行初始化时报错了,因为此刻 _N 已经被定义,此刻是在函数体中,无法再对其进行初始化

image-20230206183711392

而使用初始化列表就可以,因为初始化列表是成员变量定义的地方 ,无论是对于引用,const 成员变量,又或者是无构造函数的自定义类型成员(自动调用非默认构造函数),都可以完成初始化:

class A
{
public:
	A(int a){ _a = a; } // 非默认构造函数
private:
	int _a;
};

class Date
{
public:
	Date(int year, int month, int day, int i)
		:_N(10)
		,_ref(i)
		,_aa(-1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

private:
	int _year;
	int _month;
	int _day;
	const int _N;
	int& _ref;
	A _aa;
};

int main()
{
	Date d1(2023, 2, 6, 10);

	return 0;
}

image-20230206184436030

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

类 A:

class A
{
public:
	A(int a = 1) 
	{
		cout << "进行构造" << endl;
		_a = a; 
	}
	A(const A& a)
	{
		cout << "进行拷贝构造" << endl;
		_a = a._a;
	}
	A& operator=(const A& a)
	{
		cout << "赋值重载" << endl;
		_a = a._a;
		return *this;
	}
private:
	int _a;
};

看如下动图:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VxvEfgLL-1689668796586)(https://anduin.oss-cn-nanjing.aliyuncs.com/%E5%88%9D%E5%A7%8B%E5%8C%96%E5%88%97%E8%A1%A83.gif)]

虽然我们没有写初始化列表,但是初始化列表是成员变量定义的地方,所以 _aa 会在初始化列表定义的时候默认调用其构造函数。

所以适当时刻使用初始化列表可以效率提升,因为此刻,只发生一次拷贝构造(存在成员初始化不存在成员)

image-20230206191940375

所以,建议自定义类型的成员,在初始化列表进行初始化,更加高效

C++11 中的补丁,提供了给成员变量缺省值的方式,若没有显示写缺省值的处理,含缺省值的变量都会在初始化列表进行初始化 ;若显示写初识化列表了,就使用初始化列表的。本质上还是使用初始化列表进行初始化,因为初始化列表是成员定义的时候。

总结:

  1. 哪个对象调用构造函数,初始化列表是它所有成员变量定义的位置
  2. 不管是否显示在初始化列表写,那么编译器每个变量都会初始化列表定义初始化

反正记住一句话:优先使用初始化列表初始化。

考察

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 随机值

image-20230206192847543

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

_a2 先声明,所以初始化列表先初始化,此刻 _a1 为随机值,将随机值给 _a2 ,再初始化 _a1,将 a 的值初始化为 1

所以,建议将声明次序和初始化列表次序对应,防止混淆。

2、explicit 关键字

隐式类型转换:

image-20230206193632643

Date d2 = 2022 时发生了隐式类型转换(意义相似类型转换)。由于支持单参数的构造函数,所以这里用 2022 构造一个临时对象 Date tmp(2022),再用这个对象拷贝构造给 d2 ,但是 C++ 编译器在连续构造的过程中,多个构造会被优化,合二为一,变为一个构造:

image-20230206201119916

d1 一次构造,d2 一次构造,一次拷贝构造合并为一次构造。 如果不想要实现隐式类型转换,就可以加上 explicit 关键字修饰

image-20230206201826169

这时,就不会进行转换了。

对于单参数的构造函数,可以支持应试类型转换。对于多参数的构造函数,需要这么写:

class A
{
public:
	A(int a)
		:_a1(a)
	{
		cout << "A(int)" << endl;
	}

	// explicit A(int a1, int a2) 如果不想要隐式转换,则加 explicit 修饰
	A(int a1, int a2)
    	:_a1(a1)
		, _a2(a2)
	{}

	A(const A& aa)
		:_a1(aa._a1)
	{
		cout << "A(const A& aa)" << endl;
	}

private:
	int _a2;
	int _a1;
};

int main()
{
	A a3 = { 2, 2 }; // 多参数隐式类型转换 

	return 0;
}

对于 explicit 修饰的构造函数称为显示构造函数,对于没有用 explicit 修饰的构造函数称为隐式构造函数。

二、static 成员

1、概念

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

考题1:

如何使用程序计算一个对象被构造了几次?

image-20230206203749365

但是对于全局变量,可以随之改变:

cnt++;

所以并不好,如何让 cnt 和 A 绑定起来,并且始终只有一个?static 成员,它属于整个类,所有对象,生命周期在整个程序运行期间 。static 成员在类的所有对象中都可以使用,它并不在对象中,而是在类中,所有类对象只有一个staic 成员。

访问

若 static 成员为 public :

image-20230206204838875

静态成员变量可以用对象和类访问。

private:

(statoc 修饰的成员函数没有 this 指针,所以在里面不能访问 _a )

但是指定类域(.)和使用类作用限定符(::)就可以访问。

image-20230206205154515

static 成员在类外面定义(特例,仅限于静态,因为不能在某个构造函数定义,它属于类,不单独属于对象)。

写一个 GetCnt 函数,来获取 _sCnt 。静态成员函数可以用对象和类访问,即 a1.GetCnt() ,A::Getcnt() 。

考题2:

image-20230207153800623

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 a[n]; // 构造 n 次
        // return Sum().GetRet() - (n + 1); // 匿名对象多构造一次
        // return a[0].GetRet();
        return Sum::GetRet();
    }
};

使用静态成员变量,_i 初始化为 1, _ret 初始化为 0 ,两者在全局初始化。对 Sum 类的构造函数每次将 ret 累加,并且让 _i 自增,这样构造 n 次,就可以计算出从 1 + … n . 再写一个静态成员函数,返回 _ret ,这些为计算过程。

可以 Sum().GetRet() 使用匿名对象返回,所以需要 Sum().GetRet() - (n + 1);最好的返回方式还是用类来访问静态成员函数 Sum::GetRet() ,还有很多种返回方式,看注释。

在 C++11 中,提供了成员变量的缺省值:

image-20230207091041783

但是虽然将 _a 给为 0 ,但是说 int _a = 0 是初始化并不对,因为在 A 类中,只是完成了对成员变量的声明。缺省值只是在未明确初始化时,在该成员变量在初始化时,才会默认使用这个缺省值。

如果在初始化列表阶段,没有对成员变量初始化,就会使用缺省值初始化

image-20230207091345213

甚至,在成员变量中,给为 int* p = (int*)malloc(4 * 10) 都是可以的,但是记住这里是缺省值。

但是对于静态成员变量是不可以这样给缺省值的,必须在类外面全局位置定义初始化

image-20230207091836100

使一个对象只能在栈上创建/堆上创建

#include <iostream>

using namespace std;

class A
{
public:
	static A GetStackObj()
	{
		A aa;
		return aa;
	}

	static A* GetHeapObj()
	{
		return new A;
	}

	// 封装成私有,只能在类内部调用
	// 这样子就不能直接创建对象
private:
	A()
	{}

private:
	int _a1 = 1;
	int _a2 = 2;
};


int main()
{
	// 但是调用两个成员函数就会被对象和成员函数的优先级所困扰
	// 因为调用需要有一个对象,但是对象的指定创建范围不同
	// 这时就可以使用静态成员函数
	// static A GetStackObj();

	return 0;
}

2、特性

  1. 静态成员为所有类对象所共享,不属于某个具体的对象,存放在静态区
  2. 静态成员变量必须在类外定义,定义时不添加static关键字,类中只是声明
  3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
  4. 静态成员函数没有隐藏的this指针,不能访问任何非静态成员
  5. 静态成员也是类的成员,受public、protected、private 访问限定符的限制
  6. 静态变量成员不可以给缺省值,得在全局定义
  7. 非静态能调用静态,静态不能调用非静态(因为调用非静态要传递 this 指针,但是 static 成员没有 this 指针)

三、友元

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

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

友元就像黄牛一样,破坏管理规则,能不用就不用。

1、友元函数

我们有没有思考过一个问题:既然运算符可以重载,那么流插入与流提取操作符 << 和 >> 是否可以重载呢?

能否将对象像内置类型一样输入和打印?就像这样?

image-20230205133258004

可以!C++ 允许重载这两个操作符,就拿 << 来说:

对于流插入操作符来说,有两个参数 coutd1cout 的类型为 ostream:

image-20230205134658455

ostream 本身是一个类对象,并且 << 能自动匹配类型的原因是因为运算符重载过了,而对于自定义类型并没有重载。可以理解为 << 已经进行过了函数重载 + 运算符重载。

我们试着在类中写一下:

void Date::operator<<(ostream& out)
{
	out << _year << '-' << _month << '-' << _day << endl;
}

形参 out 为 cout 的别名,通过这种方式,在主函数中调用:

image-20230205142110717

发现是无法调用的,但是如果我们主动调用 :

image-20230205142257245

这是因为在运算符重载中,对于双操作数的操作符重载,第一个参数是操作数,第二个参数是右操作数。

而我们上方的写法让 cout 变为了第二个操作数,就相当于变成了 d1 << cout ,错乱了:

image-20230205142810745

但是这很明显不符合我们的习惯。而 this 指针已经占用了第一个参数,左操作数一定是对象,所以如果写重载的话一定实现不,就不能写作成员函数。

所以就写在类外面,写作全局的不就好了,这样就不受类的特性的约束了

image-20230205143553531

但是这里又迎来一个问题:访问不到类中的成员变量 ,对于这个问题,我们也遇到过,要么是将类成员变量私有权限放开;要么是给一个调取数据的函数,但是这样虽然可以解决调取数据的问题,可是对于 >> 流提取函数的实现又成了一个问题:无法获取到输入数据,而使用这种方案解决了也很麻烦,所以这两种方案都被排除了。

那么有没有什么简便的方法?一个全局函数想用对象访问类中私有或保护的成员,可以使用友元。意思就是让类的“朋友”访问到它的私有对象。

友元函数的声明需要写在类里面:

image-20230205150512715

image-20230205150430542

此刻就可以访问了:

image-20230205150556013

但是这里不能连续输出 ,和之前讲过的连续赋值的原因是相同的,因为 cout << d1 << d2; 由于函数没有返回值,并不能起到连续输出的效果。所以可以稍加改进,让每次输出后,都可以获取 cout :

image-20230205150903889

这时,就可以连续输出了:

image-20230205150944693

同理,对于 >> 的函数,我们也可以写出来:

istream& operator>>(istream& in, Date& d) // d 要被修改,不能加 const
{
	in >> d._year >> d._month >> d._day;
	return in;
}

总结

  • 友元函数可访问类的私有和保护成员,但不是类的成员函数
  • 友元函数 不能用const修饰
  • 友元函数可以在 类定义的任何地方声明,不受类访问限定符限制
  • 一个函数可以是多个类的友元函数
  • 友元函数的调用与普通函数的调用原理相同

2、友元类

友元类的所有成员函数都变为是另一个类的友元函数,都可以访问另一个类中的非公有成员

  • 友元关系是单向的,不具有交换性
class Time
{
	// 日期类想要经常访问 Time ,让 Date 变为 Time 的友元类
	friend class Date; // 声明日期类为时间类的友元类,则在日期类中就直接访问Time类中的私有成员变量
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;
};

比如上述Time类和Date类,在Time类中声明Date类为其友元类,Date 类为 Time 类的友元。那么可以在Date类中直接访问Time类的私有成员变量 ,但想在Time类中访问Date类中私有的成员变量则不行。

但是 Time 类不能访问 Date 类 。举个中二的例子,就好比说,Date 类是主,Time 类是仆,Date 类和 Time 类缔结了神魂契约,对于 Date 类来说,可以随时查看 Time 的情况,但是对于 Time 并不能随时查看 Date 的情况;除非它俩关系对等,签订平等的契约才可以(在 Date 类中,声明 Time 类为其友元类)

class Time
{
	// 日期类想要经常访问 Time ,让 Date 变为 Time 的友元类
	friend class Date; // 声明日期类为时间类的友元类,则在日期类中就直接访问Time类中的私有成员变量
public:
	Time(int hour = 0, int minute = 0, int second = 0)
		: _hour(hour)
		, _minute(minute)
		, _second(second)
	{}
	void Func(Date d);
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
	friend class Time;
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;
};

void Time::Func(Date d) // Date 和 Time 两者互为友元,所以 Time 中现在可以访问 Date 
{
	cout << d._year << endl;
}


int main()
{
	return 0;
}

友元类和友元函数一样,不受访问限定符的约束:

image-20230207094801740

如图在 A 类中,将友元类 C 的声明放为私有(其实平时放在 class 中也就是私有,这里只是为了说明),此刻 C 能访问 A ,在主函数创建对象时,A 也通过构造完成初始化,调用 c1 的成员函数也访问到了 A 的成员。

  • 友元关系不能传递
    如果C是B的友元, B是A的友元,则不能说明C时A的友元。

  • 友元关系不能继承,在继承位置再详细介绍。

四、内部类

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

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

对外部类大小的计算,和内部类中的成员变量没有关系,因为里面并没有包含对象,只是图纸而已:

image-20230207154902428

再看一个例子:

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
		}
	private:
		int _b;
	};

	void f(B b)
	{
		// cout << b._b << endl; // err ,外部类不能访问内部类的私有
	}
};
int A::k = 1;
int main()
{
	A::B b; // 内部类的定义
	
	return 0;
}

内部类 B 和在全局定义时基本一样的,但是外部类 A 类域限制定义在 A 的类域中,就比如定义内部类对象时,需要指定外部类的类域:A::B b

内部类 B 天生就是外部类 A 的友元,也就是 B 中可以访问 A 的私有,A 不能访问 B 的私有 :就比如 B 类中可以访问 A 中私有成员变量,但是 A 不能访问 B 的私有,除非将权限开放为公有。

内部类改写 JZ76

class Solution {
private:
    class Sum
    {
    public:
        Sum()
        {
            _ret += _i;
            ++_i;
        }
    };
private:
    static int _i;
    static int _ret;
public:
    int Sum_Solution(int n) {
        Sum a[n];
        return _ret;
    }
};

int Solution::_i = 1;
int Solution::_ret = 0;

将 Sum 包为内部类,并将 _i 和 _ret 变为 Solution 的成员变量,Sum 默认为 Solution 的友元,那么 Sum 可以访问这两个成员。而返回时,也不需要借助成员函数,直接返回成员变量即可。

优点:根据内部类的特性,将成员变量放到 Solution 后,根据两者的特性,就可以访问到 _ret ,这时不再需要使用成员函数获取 _ret

五、匿名对象

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

六、构造(拷贝构造)对象时的一些编译器优化

在同一句语句中,不存在的对象或者有多个构造或拷贝构造,这些构造过程可能会合二(三)为一。

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

七、再谈类和对象

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

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

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

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

  4. 用户就可以借助计算机中洗衣机对象,来模拟现实中的洗衣机实体了。

在类和对象阶段,大家一定要体会到,类是对某一类实体(对象)来进行描述的,描述该对象具有那些属性,那些方法,描述完成后就形成了一种新的自定义类型,才用该自定义类型就可以实例化具体的对象

image-20230207162749540

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

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

相关文章

【hadoop】部署hadoop的伪分布模式

hadoop的伪分布模式 伪分布模式的特点部署伪分布模式hadoop-env.shhdfs-site.xmlcore-site.xmlmapred-site.xmlyarn-site.xml对NameNode进行格式化启动Hadoop 对部署是否完成进行测试免密码模式免密码模式的原理&#xff08;重要&#xff09;免密码模式的配置 伪分布模式的特点…

【基于 GitLab 的 CI/CD 实践】03、GitLab Pipeline 实践(上)

目录 一、GitLab Pipeline 流水线语法有哪些&#xff1f;流水线参数列表 如何检查语法错误&#xff1f;流水线语法检测 二、Pipeline 基础语法 job script before_script after_script stages 未定义 stages ​定义 stages 控制 stage 运行顺序 .pre & .post …

哇~真的是你呀!今天是LINUX中的RSYNC服务

目录 前言 一、概述 二、特性 三、rsync传输模式 四、rsync应用 五、格式 六、配置文件 七、守护进程传输 八、rsyncinotfy实时同步 一、概述 rsync是linux 下一个远程数据同步工具;他可通过LAN/WAN快速同步多台主机间的文件和目录&#xff0c;并适当利用rsync 算法减少数据的…

04.MySQL——用户管理

用户管理 用户管理的价值 用户 用户信息 MySQL中的用户&#xff0c;都存储在系统数据库mysql的user表中 use mysql;select host,user,authentication_string from user;host&#xff1a; 表示这个用户可以从哪个主机登陆&#xff0c;如果是localhost&#xff0c;表示只能从…

对Element DatePicker时间组件的封装,时间组件开始时间和结束时间绑定

背景 我们时常有时间范围选择&#xff0c;需要选择一个开始时间和一个结束时间给后端&#xff0c;但我们给后端的是两个字段&#xff0c; 分别是开始时间和结束时间&#xff0c;现在使用element绑定的值是一个数组&#xff0c;我们还要来回处理&#xff0c;很麻烦列表也的查询…

leaflet 沿河流流向显示河流名字

1.效果图&#xff1a; 2.代码块 首先需要借助一个插件3mapslab-Leaflet.streetlabels&#xff08;这个插件也可用于显示街道名字用的&#xff09; 插件可在leaflet官网上下载及案例&#xff01; --- layout: default ---<div idmap style"width:100%;min-height:30…

【数据结构】二叉树详解(1)

⭐️ 前言 ✨ 二叉树的概念性质 ⭐️ 二叉树链式结构的实现 结构定义&#xff1a; #include <stdio.h> #include <stdlib.h> #include <assert.h>typedef int BinaryTreeDataType;typedef struct BinaryTreeNode {BinaryTreeDataType value;struct Binary…

关于AES 和 BASE64 的理解

BASE64 首先 base64 是一种编码方式&#xff0c;它的字符集由64个不同字符组成&#xff08;A-Z、a-z、0-9和两个额外字符/&#xff09;&#xff0c;因此每个Base64字符都占用6个比特&#xff08;2^6 64&#xff09; Base64编码后的数据长度 4 * ceil(原始数据长度 / 3) 其中…

vue做移动端上拉加载 删除当前列表某个数据 保持当前状态 继续获取下一页不影响正常的数据

本文中使用vant组件的list列表制作的 当然主要是看这个难题的思路 不必计较用的什么组件库 换做其他的组件库 思路还是一样的 //主要思路是把点击删除的数据让后端置为false // 比如我请求了3页&#xff0c;一页10条数据 // 一共30条&#xff0c;我一条一条删除&#xff0c;点…

Redis : zmalloc.h:50:31: 致命错误:jemalloc/jemalloc.h:没有那个文件或目录

In file included from adlist.c:34:0: zmalloc.h:50:31: 致命错误&#xff1a;jemalloc/jemalloc.h&#xff1a;没有那个文件或目录 #include <jemalloc/jemalloc.h> 解决 : 如上图使用命令 make MALLOClibc

【EXCEL】数据录入的快捷键和正确格式

目录 0.环境 1.内容概述 2.具体内容 2.1数据录入换行换列的快捷键&#xff08;标准的数据输入方式&#xff09; 2.2日期的正确格式和使用&#xff08;标准日期格式与长日期&#xff09; 2.2.1 标准日期 2.2.2 长日期 2.2.3 显示当前日期和时间的快捷键 2.3百分比的正确…

FPGA adrv9002 4收4发板卡,支持NVME SATA EMMC 光口 FMC

板卡采用ADI 射频直采芯片ADRV9002 &#xff0c;支持4收4发支持外部本振 跳频 同时支持4X 10G光口对外传输&#xff0c;FMC扩展 。同时支持4X NVME接口&#xff0c;可以实时流盘&#xff0c;备份一路SAT A接口&#xff0c;板卡同时预留了EMMC&#xff0c;可以PS PL选通访问&…

C++ stack和queue 模拟实现

stack和queue 模拟实现 模拟栈实现模拟队实现 模拟栈实现 1 栈是一种容器适配器&#xff0c;专门设计用于后进先出的后进先出环境&#xff0c;在这种环境中&#xff0c;元素只从容器的一端插入和提取。 2 栈是作为容器适配器实现的&#xff0c;这些适配器是使用特定容器类的封装…

linux安装git

linux安装git 命令行安装方法下载安装配置git用户信息 命令行安装方法 Debian/Ubuntu&#xff1a;使用apt命令进行安装 sudo apt install git但是我安装遇到问题&#xff1a; 这是应为之前安装了搜狗拼音的原因&#xff0c;卸载即可 apt-get autoremove sogoupinyinapt-get …

23.JavaWeb-集群+Nginx+JMeter

1.集群概念 平时用的服务是的并发量是有限的&#xff0c;像tomcat只有不到500的并发量&#xff0c;不能满足高并发的需求&#xff0c;因此就采用了集群的方法&#xff0c;用多个服务器 当用户请求集群系统时&#xff0c;集群给用户的感觉就是一个单一独立的服务器&#xff0c;而…

基于SpringBoot+vue的民宿管理平台系统设计与实现

博主介绍&#xff1a; 大家好&#xff0c;我是一名在Java圈混迹十余年的程序员&#xff0c;精通Java编程语言&#xff0c;同时也熟练掌握微信小程序、Python和Android等技术&#xff0c;能够为大家提供全方位的技术支持和交流。 我擅长在JavaWeb、SSH、SSM、SpringBoot等框架…

JS-26 认识防抖和节流函数;自定义防抖、节流函数;自定义深拷贝、事件总线函数

目录 1_防抖和节流1.1_认识防抖和节流函数1.2_认识防抖debounce函数1.3_防抖函数的案例1.4_认识节流throttle函数 2_Underscore实现防抖和节流2.1_Underscore实现防抖和节流2.2_自定义防抖函数2.3_自定义节流函数 3_自定义深拷贝函数4_自定义事件总线 1_防抖和节流 1.1_认识防…

Failed to initialize NVML: Driver/library version mismatch (解决)

问题描述 运行nvidia-smi报错&#xff1a; Failed to initialize NVML: Driver/library version mismatch解决方法 只需一步&#xff1a;下载一个安装包&#xff0c;运行一个命令来重新安装cuda driver和cuda toolkit&#xff08;在一个包里&#xff09;。 到这里&#xff1…

听GPT 讲K8s源代码--pkg(六)

pkg/kubelet/cm 目录是 Kubernetes 源代码中的一个目录&#xff0c;包含了 kubelet 组件中的 ConfigMap 相关代码。 在 Kubernetes 中&#xff0c;ConfigMap 是一种用于存储非机密数据的 API 对象类型&#xff0c;它可以用来存储配置信息、环境变量、命令行参数等等。 kubelet …

学堂在线数据结构(上)(2023春)邓俊辉 课后题

The reverse number of a sequence is defined as the total number of reversed pairs in the sequence, and the total number of element comparisons performed by the insertion sort in the list of size n is: 一个序列的逆序数定义为该序列中的逆序对总数&#xff0c;…