【c++】——类和对象(下) 万字解答疑惑

作者:chlorine

专栏:c++专栏

目录

🚩再谈构造函数

🎓构造函数体赋值

🎓初始化列表

🚩explicit关键字

🚩static成员

🎓概念

面试题:计算创建多少个类对象

🎓特性

【问题】(非)静态调用(非)静态

【题目】累加

🚩友元

🎓友元函数

🎓友元类

🚩内部类

特性:

特性一🍭内部类定义在public中:

特性一🍭内部类定义在private中

特性三🍭类大小

🚩匿名对象

特性一🍭生命周期

特性二🍭匿名对象具有常性

🚩拷贝对象时一些编译器优化


🚩再谈构造函数

我们之前学了构造函数,对成员函数体内成员变量赋初值——构造函数体赋值

这一章我们要学习  对成员变量初始化——初始化列表

🎓构造函数体赋值

构造函数体赋值:在创建对象时,编译器通过调用构造函数,给对象中各个成员变量一个合适的初始值。 虽然上述构造函数调用之后,对象中已经有了一个初始值,但是不能将其称为对对象中成员变量的初始化, 构造函数体中的语句只能将其称为赋初值,而不能称作初始化。因为初始化只能初始化一次,而构造函数体内可以多次赋值


🎓初始化列表

初始化列表:以一个 冒号:开始 ,接着是一个以 逗号,分隔的数据成员列表 ,每个 " 成员变量 " 后面跟一个 放在括 号中的初始值或表达式。
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. 类中包含以下成员,必须放在初始化列表位置进行初始化:(必须在定义的时候初始化)
  • 引用成员变量

  • const成员变量

成员变量实际上是在声明,在main函数中创建对象B bb(10,1)其实就是定义的过程,但是这个定义对所有的成员变量都定义了,没有给单个成员变量定义

那在哪对成员进行定义呢??

那么我们就衍生了初始化列表:对象的成员定义的位置。(记住:有且仅一次初始化)

class B
{
public:
	//初始化列表:对象成员定义的地方
	B(int a, int ref)	
		:_n(1)
		,_ref(ref)
	{
	}
private:
	//声明
	const int _n; // const 
	int& _ref; // 引用
};
int main()
{
	//对象整体定义
	B bb(10, 1);
	return 0;
}
  • 自定义类型成员(且该类没有默认构造函数时)

我们之前就学过了,自定义类型成员会自动调用默认构造函数,内置类型不会进行处理,会给个随机值

我们也可以给内置成员变量打个补丁,int x=1;这里的1是缺省值,缺省值是给初始化列表的

如果我们给x初始化,那么编译器就不会用缺省值,缺省值在大部分学c++的人叫成备胎,初始化了那么就不需要缺省值,没有初始化就需要缺省值。

如果自定义类型的成员没有默认构造函数,那么自定义类型的成员就会报错,没有合适的构造函数可用,这就需要给自定义类型的成员初始化了。

在没有默认构造函数给初始值,我们就需要在初始化列表进行定义

如果有默认构造,我们能不能再初始化列表中定义呢?——当然可以

只不过初始化列表优先处理。其实本质上默认构造里的参数也是缺省参数,如果我们给了缺省参数 ,但是初始化列表初始化了,就不需要缺省值来初始化了。所以默认构造函数(隐式)或者初始化列表(显式)都是一种初始化,但是在后来的初始化都是利用初始化列表进行初始化。

3. 尽量使用初始化列表初始化,因为不管你是否使用初始化列表,对于自定义类型成员变量,一定会先使用初始化列表初始化。
自定义类型是一定要调用构造函数的,有默认构造函数没有初始化列表,就会调用默认构造函数,没有默认构造函数,就必须要使用初始化列表初始化。
所以这里的自定义类型成员变量前提是没有默认构造函数,则一定要用初始化列表初始化。
注意:初始化列表是构造函数的一部分,初始化列表严格说替代了构造函数体内赋值,以后我们就可以开始用初始化列表来初始化了。
但是我们要知道,初始化列表并不能完成初始化所有的内容,比如我们要开辟一个空间,malloc,可以这样写 :a((int*)malloc(capacity*sizeof(int)) 但是我们是不是得检查一下是否开辟空间成功?
Stack(int capacity=10)
:_a((int*)malloc(capacity*sizeof(int)))
,_top(0)
,_capacity(capacity)
{
  if(_a==nullpter)
 {
   perror("malloc fail\n");
   return -1;
 }
}
所以我们需要在函数内进行检查,初始化列表能帮我们完成95%的内容,但是还剩5%是初始化列表无法完成,上面的例子就是。
还有给数组初始化一下,我们就需要memset,calloc也需要检查.....等等
还有更多复杂的过程,就无法让初始化列表来完成的。
函数体分工就是初始化列表不方便做的。
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 随机值
4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序,与其在初始化列表中的先后次序无关
为什么选D呢?按照上面的特点,声明的次序就是初始化列表中的初始化顺序,成员变量就是声明的过程,所以先声明_a2,那么就先初始化_a2为_a1,那么_a1就是1,_a2就是随机值了。
就比如在上面对_a开辟空间之后,里面的_capacity就是一个随机值,随后的声明的是_capacity就会变得很大,导致了程序的崩溃,所以我们必须以后声明顺序和初始化顺序相同。

🚩explicit关键字

class A
{
public:
	A(int a)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	A(const A& aa)
		:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}
private:
	int _a;
};
int main()
{
	A aa1(1);//拷贝构造
	A aa2 = 2;
	return 0;
}

我们看看上面一段代码,A aa2=2,运行成功,并且还调了构造函数。

看下面一段代码,隐式类型转换,我们根据前面所学的知识,我们知道有隐式类型转换的过程中会自动生成一个临时变量,b是int类型,b的值给与d类型相同的临时变量,然后进行赋值。所以这里的编译成功。

int b=10;
double d=b;

那么这里的int型隐式类型转换成自定义类型,是不是也是会在其中默认生成一个临时变量。——是的。其过程就是2创造一个A的临时对象,临时对象再拷贝构造aa2,再近代我们的编译对其进行优化,2直接构造了。所以我们的运行成功,调用了拷贝构造函数。

所以下面的表达式经历了——创建临时变量——拷贝构造——优化  ——三大过程。

A aa2=2;

那我们接下来看看下面的代码

这里A&aa3=2,就无法进行构造了。因为2在赋值的时候不是直接赋值,而是我们在中间创建的临时变量是具有常性的,是const类型,是不可以改变的,而中间创建的临时变量的对象是A类,而且是const的A类,然后我们要进行拷贝构造的时候,也需要拷贝给相同类型的对象,所以也要在之前加个const。


构造函数不仅可以构造与初始化对象, 对于单个参数或者除第一个参数无默认值其余均有默认值的构造函 数,还具有类型转换的作用 。如果我们禁止类型转换,我们该如何操作呢?
——
explicit关键字

以后我们学到智能指针的时候我们就会用大explicit这个关键字,阻止隐式类型转换。

🚩static成员

🎓概念

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

面试题:计算创建多少个类对象

实现一个类,计算程序中创建出了多少个类对象。
class A
{
public:
 A() { ++_scount; }
 A(const A& t) { ++_scount; }
 ~A() { --_scount; }
 static int GetACount() { return _scount; }
private:
 static int _scount;
};
int A::_scount = 0;
void TestA()
{
 cout << A::GetACount() << endl;
 A a1, a2;
 A a3(a1);
 cout << A::GetACount() << endl;
}

这里就很好理解,a1,a2俩个对象,然后拷贝构造又创建一个对象,总共三个对象。


int _scount = 0;
class A
{
public:
	A() { ++_scount; }
	A(const A& t) { ++_scount; }
	~A() { --_scount; }
private:
	//static int _scount;
};

A aa0;

A Func(A aa)
{
	cout << __LINE__ << ":" << _scount << endl;
	return aa;
}

int main()
{
	cout << __LINE__ << ":" << _scount << endl;
	A aa1;
	static A aa2;
	Func(aa1);
	cout << __LINE__ << ":" << _scount << endl;
	return 0;
}

那上面的这段代码怎么统计呢?

我们来分析一下:aa0是全局创建的一个对象,那么25行就只创建了一个对象,这样也说明了,静态局部变量不会提前初始化,等到了它才存在。然后19行,我创建了aa0,aa1,和静态成员对象aa2,三个对象,然后调用函数的时候,我们传参的时候也创建一个对象,那么总共四个对象。
然后出了作用域之后对象就销毁,29行就只有3个对象。

那我们再来感受一下?

int _scount = 0;
class A
{
public:
	A() { ++_scount; }
	A(const A& t) { ++_scount; }
	~A() { --_scount; }
private:
	//static int _scount;
};

A aa0;

void Func()
{
	static A aa2;
	cout << __LINE__ << ":" << _scount << endl;
}

int main()
{
	cout << __LINE__ << ":" << _scount << endl;
	A aa1;
	Func();
	Func();
	return 0;
}

如果有相同函数调用多次,静态区的变量只定义一次。所以最后的对象是3次。

但是我们有没有发现_scount的值是可以随意修改的,这是全局变量的劣势:任何地方都是可以修改的。

那么如何让_scount封装一下呢?——就是再类中封装

我们首先要区分一下成员变量和静态成员变量的区别。

  • 成员变量:属于每一个类的对象,存储在对象里面

    int _a1 = 1;
    int _a2 = 2;

  • 静态成员变量——属于类,属于类的每一个对象共享。----存储在静态区

    static int _scount;

静态成员变量不像成员变量一样,成员变量可以在类中定义,但是静态成员变量不能再类中定义,要再类外面定义。
那我们这里就不能直接获取_scount了,一般静态成员变量和静态成员函数是成套出现的,所以我们就声明定义了一个静态成员函数来获取对象个数。
静态成员函数——没有this指针,指定类域和访问限定符就可以访问
所以静态成员函数不能访问成员,因为访问成员需要this指针,而静态成员函数没有this指针是无法访问的。
///int _scount = 0;
class A
{
public:
	A() { ++_scount; }
	A(const A& t) { ++_scount; }
	~A() { --_scount; }

//没有this指针,指定类域和访问限定符就可以访问
	static int GetACount() { return _scount; }
private:
	//成员变量:属于每一个类的对象,存储在对象里面
	int _a1 = 1;
	int _a2 = 2;

	//静态成员变量——属于类,属于类的每一个对象共享。----存储在静态区
	static int _scount;
};

//全局位置,类外面定义
int A::_scount = 0;

A aa0;

void Func()
{
	static A aa2;
	cout << __LINE__ << ":" <<A::GetACount()<< endl;
}

int main()
{
	cout << __LINE__ << ":" << A::GetACount() << endl;
	A aa1;
	Func();
	Func();
	return 0;
}

相比全局变量,静态成员就是用类来封装,让数据更规范一些。


🎓特性

  • 1. 静态成员所有类对象所共享,不属于某个具体的对象,存放在静态区
  • 2. 静态成员变量必须在类外定义,定义时不添加static关键字,类中只是声明
  • 3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
  • 4. 静态成员函数没有隐藏的this指针,不能访问任何非静态成员
  • 5. 静态成员也是类的成员,受publicprotectedprivate 访问限定符的限制
  • 6.静态成员变量是不能设置缺省值的,为什么成员变量可以设置缺省值,因为成员变量有初始化列表来接收,要么初始化列表来初始化,要么缺省值给初始化然后给初始化列表,而静态成员变量没有初始化列表,所以不能给缺省值。

【问题】(非)静态调用(非)静态

  • 1. 静态成员函数可以调用非静态成员函数吗?
我们知道,非静态的成员函数需要 this指针,静态的成员函数没有this指针,所以不能调用。

  • 2. 非静态成员函数可以调用类的静态成员函数吗?
我上面说过了 静态成员函数的特性是:没有this指针,指定类域和访问限定符限定就可以访问。
【1】非静态成员函数在类调用类的静态成员函数:

因为在类中,类里面不受类域和访问限定符的限制,类里面就是一个大家庭,所以调用静态是完全可以的。

【2】非静态成员函数在类调用类的静态成员函数:

这里用 指定类域和访问限定符限定进行访问。就可以调用静态成员函数

学了上面的知识我们可以看看这个题目:很好的复习了静态成员变量和静态成员函数的知识。

【题目】累加

1+2+3+...+n ,要求不能使用乘除法、 for while if else switch case 等关键字及条件判断语句( A? B:C点击链接练一下吧
大家看见这个题目肯定很熟悉,但是我们学习了c++并且学习了静态成员变量和静态成员函数,我们就可以利用我们现在所学的知识进行解题,题目也多加限制了条件,出题者就是想让我们用(sttic成员)来解题。
思路:我们累加到n,那么我们就创建一个类Sum,然后我们创建n个Sum类对象,都知道,出了作用域数据就会被销毁,全局变量可以随意修改,那么我们就可以用静态成员变量来记录值。 记住:成员变量在类里声明,在类外定义。但是由于静态成员变量是私有的,我们就需要一个静态成员函数来获取该值。所以这就照应了为什么静态成员变量和静态成员函数是成套出现的,因为静态成员变量需要静态成员函数来获取。
为什么需要静态成员函数?
静态成员函数属于类,而不是对象。
由于私有静态成员无法类外访问。
有了静态成员函数之后。
在访问私有静态成员时,可以在创建对象前,通过类的静态成员函数访问静态成员

类里面不受类域和访问限定符的限制,类里面就是一个大家庭,所以调用静态是完全可以的或者访问私有函数也是可以的,所以我们就需要静态成员函数来调用了。
class Sum
{
public:
    Sum()
    {
        _ret+=_i;
        _i++;
    }
    //因为 _ret是私有的,那么我们就要用静态成员函数获取_ret的值
    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];
        return Sum::Getret();
    }
};

🚩友元

友元提供了一种突破封装的方式,有时提供了便利。但是友元会增加耦合度(耦合度是俩者的关系),破坏了封装,所以友元不宜多用。为什么呢?我们往下学就知道了。
友元分为:友元函数和友元类

🎓友元函数

我们为什么有友元函数呢?

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

我们来分析一下这段代码,ostream是cout的类,我们给ostream创建一个对象_cout,我们需要_cout<<d1,那么我们要先传的形参是_cout是cout输出流对象,第二个参数是_d1,但是上面的代码中,我们知道operator<<重载成全局函数是非静态的成员函数,而C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数,让该指针指向当前对象(函数运行时调用该函数的对象),在函数体中所有“成员变量”的操作,都是通过该指针去访问。所以this指针和cout输出流对象争夺位置,但是第一个参数还是this指针(指针指向的当前对象),然后第二个参数就成了cout输出流,导致形成了d1<<cout,不符合常规调用。

所以我们该如何改进呢?——如果我们要将operator重载成全局函数,这是非静态成员函数,那么无法访问到类中的私有成员,所以这时候我们就引入了友元的知识了。

class Date
{
	friend ostream& operator<<(ostream& _cout, const Date& d);
public:
	Date(int year, int month, int day)
		: _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 << endl;
	return _cout;
}

int main()
{
	Date d1(2003, 10, 5);
	cout << d1 << endl;
	return 0;
}

友元函数可以直接访问类的私有成员,它是定义在类外部普通函数,不属于任何类,但需要在类的内部声明,声明时需要加friend关键字。
说明 :
  • 友元函数可访问类的私有和保护成员,但不是类的成员函数
  • 友元函数不能用const修饰
  • 友元函数可以在类定义的任何地方声明,不受类访问限定符限制
  • 一个函数可以是多个类的友元函数
  • 友元函数的调用与普通函数的调用原理相同

🎓友元类

友元类的所有成员函数都可以是另一个类的友元函数,都可以访问另一个类中的非公有成员。
  • 友元关系是单向的,不具有交换性。 比如上述Time类和Date类,在Time类中声明Date类为其友元类,那么可以在Date类中直接访问Time 类的私有成员变量,但想在Time类中访问Date类中私有的成员变量则不行。
class 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类可以访问。


  • 友元关系不能传递。 比如如果B是A的友元,C是B的友元,则不能说明C时A的友元。
  • 友元关系不能继承,在继承位置再给大家详细介绍。

🚩内部类

概念:如果一个类定义在另一个类的内部,这个内部类就叫做内部类。内部类是一个独立的类,它不属于外部类,更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。(就可以相较于一个工程师给画了一个图纸,工程师给另一个家庭一个福利我可以在图纸里画一下你的家里构造,不占据空间)
注意:内部类就是外部类的友元类,参见友元类的定义,内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
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;
}

特性:

  • 1. 内部类可以定义在外部类的public、protected、private都是可以的。 但是如果定义在public中可以用A::访问限定符给B类创建对象,然后访问其中的私有成员,但如果内部类定义在private中是完全不可以访问任何成员变量和成员函数的,是死死封装住的。

特性一🍭内部类定义在public中:

内部类是定义在public中的

class A
{
private:
	static int k;
	int h;
public:
	class B // B天生就是A的友元
	{
	public:
		B()
			:m(1)
			,n(1)
		{
		}
		void foo()
		{
			cout << m << "-" << n << endl;
		}
	private:
		int m;
		int n;
	};
};

int A::k = 1;
int main()
{
	A::B b;
	b.foo();
	return 0;
}

特性一🍭内部类定义在private中

是完全不能访问的,是任何对象都不可以访问的


  • 2. 注意内部类可以直接访问外部类中的static成员,不需要外部类的对象/类名。
  • 3. sizeof(外部类)=外部类,和内部类没有任何关系。

特性三🍭类大小

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

c++很少用内部类,但是java经常用。


🚩匿名对象

匿名对象可以理解为没有名字的对象。

特性一🍭生命周期

有名对象 -- 生命周期在当前函数局部域   匿名对象 -- 生命周期在当前行
using namespace std;
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) {
        cout << "Sum_Solution" << endl;
        //...
        return n;
    }
};

int main()
{
    A aa(1);//有名对象
    A(2);//匿名对象

    Solution s1;
    s1.Sum_Solution(2);//有名调用函数

    Solution().Sum_Solution(3);//匿名调用函数
    
    return 0;
}

我们可以调试看看

调试完32行之后,我们发现构造和析构都调用了,说明匿名对象生命周期在当前行,即构造即析构。

有名对象的生命周期在局部域内。

特性二🍭匿名对象具有常性

A &ra=A(1);

大家看看ra能不能引用匿名对象?

报错,是不可以的,因为( 匿名对象是具有常性的
这样就成功了

const A&ra=A(1);
但是加上const不仅仅只是给匿名对象进行引用,也会出现一个神奇的结果。
我们上面看到了这里并没有即构造即析构。这里我就要解析一下了。
结论:const引用延长匿名对象的生命周期,生命周期在当前函数局部域
我们可以这样理解匿名对象没有人用它那么就即用即销毁,那么引用的话,有人ra需要引用这个匿名对象,所以延长了匿名对象的生命周期。(通俗易懂的说法)

🚩拷贝对象时一些编译器优化

在传参和传返回值的过程中,一般编译器会做一些优化,减少对象的拷贝,这个在一些场景下还是非常有用的。

比如:

  • 一个表达式中,连续构造+拷贝构造,可以优化为一个构造
  • 隐式类型中:连续构造+拷贝构造,优化为直接构造
  • 连续拷贝构造+拷贝构造,优化为一个拷贝构造
  • 一个表达式中,连续拷贝构造+赋值重载,无法优化

你的大部分时间投入到哪里,你大概率就会成为怎样的人!

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

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

相关文章

香蕉派BPI-M4 Zero单板计算机采用全志H618,板载2GRAM内存

Banana Pi BPI-M4 Zero 香蕉派 BPI-M4 Zero是BPI-M2 Zero的最新升级版本。它在性能上有很大的提高。主控芯片升级为全志科技H618 四核A53, CPU主频提升25%。内存升级为2G LPDDR4&#xff0c;板载8G eMMC存储。它支持5G WiFi 和蓝牙, USB接口也升级为type-C。 它具有与树莓派 …

内部网关协议_路由信息协议RIP_开放路径优先OSPF协议_基本知识

目录: 因特网路由选择协议概述 路由信息协议RIP 开放路径优先OSPF协议 因特网路由选择协议概述 一.路由选择分类 静态路由选择和动态路由选择 静态路由选择: 采用人工配置的方式给路由器添加网络路由、默认路由和特定主机路由等路由条目。静态路由选择简单、开销小&#…

在Spring Boot中使用ECharts绘制数据图表

使用ECharts来完成一些花里胡哨的图表吧&#xff0c;一般这种需求我们在我们的客户端不太常见&#xff0c;但是&#xff0c;我们在后端进行各种数据统计的时候就会发现ECharts的优点了&#xff0c;比如我们常常做的柱状图&#xff0c;折线图&#xff0c;雷达图等可视化形式&…

最常用的5款报表系统

在这个信息化飞速发展的时代&#xff0c;报表系统已经成为了企业管理和决策的重要工具。随着市场的需求不断增长&#xff0c;报表系统也在不断地更新和完善。如今&#xff0c;市面上有数不尽的报表系统&#xff0c;但是哪款才是最常用的呢&#xff1f;接下来&#xff0c;我们将…

CSS伪类选择器详细讲解

前言 伪类选择器在CSS中起到的作用可以说是至关重要的&#xff0c;如果CSS没有伪类选择器&#xff0c;有很多效果都要借助js来完成&#xff0c;这样不仅代码量增加&#xff0c;维护起来你难度也大。这样程序员的工作量大&#xff0c;也违背了CSS诞生的作用&#xff0c;就是提高…

STM32F103C8T6第5天:独立看门狗、窗口看门狗、dma实验

1. 独立看门狗IWDG介绍&#xff08;341.45&#xff09; 什么是看门狗&#xff1f; 在由单片机构成的微型计算机系统中&#xff0c;由于单片机的工作常常会受到来自外界电磁场的干扰&#xff0c;造成程序的跑飞&#xff0c;而陷入死循环&#xff0c;程序的正常运行被打断&#…

美国云服务器:CN2/纯国际/高防线路介绍

​  谈到国外云服务器&#xff0c;美国云服务器必有一席之地。但是&#xff0c;一般来说使用美国云服务器&#xff0c;线路质量是一个重要的考虑因素。如果线路选择不合理&#xff0c;就有可能造成速度减慢或者安全隐患问题产生。本文将介绍美国云服务器的CN2/纯国际/高防三种…

PHP反序列化简单使用

注&#xff1a;比较简陋&#xff0c;仅供参考。 编写PHP代码&#xff0c;实现反序列化的时候魔法函数自动调用计算器 PHP反序列化 serialize(); 将对象序列化成字符串 unserialize(); 将字符串反序列化回对象 创建类 class Stu{ public $name; public $age; public $sex; publi…

有一台电脑一部手机就可以在网上赚钱,这些项目你也可以学会

很多人都希望能够在家中或者闲暇的时候&#xff0c;能够在网上赚钱&#xff0c;而网络给了我们这样的可能。只要有一台电脑和一部手机&#xff0c;你就可以开始你的赚钱之旅。这些项目并不难&#xff0c;只要你肯学&#xff0c;就一定能够成功。 1、美工设计 这个副业主要是推荐…

python plot绘图

使用python绘制t-sne图&#xff0c;并保存 一下是一个将que_im_features向量可视化的例子&#xff1a; def emb_save(que_im_features,i):# 向量[75, 640, 11, 11], episodeimport numpy as npimport pandas as pdfrom sklearn import manifoldimport matplotlib.pyplot as p…

jmeter中调用python代码

1、安装pyinstaller pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pyinstaller 2、将py脚本打包 pyinstaller -F venv/get_image/OCR_jmeter_api.py 3、jmeter中添加OS Process Sampler并调用dist下的程序 4、执行jmeter

Jmeter 压测实战保姆级入门教程

1、Jmeter本地安装 1.1、下载安装 软件下载地址&#xff1a; https://mirrors.tuna.tsinghua.edu.cn/apache/jmeter/binaries/ 选择一个压缩包下载即可 然后解压缩后进入bin目录直接执行命令jmeter即可启动 1.2 修改语言 默认是英文的&#xff0c;修改中文&#xff0c;点击…

RubbleDB: CPU-Efficient Replication with NVMe-oF

RubbleDB: CPU-Efficient Replication with NVMe-oF 前言 这是ATC2023的文章&#xff0c;作者来自哥伦比亚大学这篇工作在LSM-tree多副本存储的场景下&#xff0c;利用NVMe-oF技术避免了LSM-tree副本上的重复合并&#xff0c;减少了CPU开销。 Introduction 为了提供高可用性…

Python 装饰器用法详解

目录 一、基本概念 二、语法形式 三、用法示例 1、用于日志记录 2、用于性能测试 3、用于事务处理 4、用于缓存结果 5、用于权限验证 总结 Python装饰器是Python中一种非常有用且强大的工具&#xff0c;它允许我们在不修改原有函数或类的基础上&#xff0c;对它们进行…

物联网AI MicroPython学习之语法 WDT看门狗外设

学物联网&#xff0c;来万物简单IoT物联网&#xff01;&#xff01; WDT 介绍 模块功能: 看门狗WDT&#xff08;WatchDog Timer&#xff09;外设驱动模块 接口说明 WDT - 构建WDT对象 函数原型&#xff1a;WDT(timeout)参数说明&#xff1a; 参数类型必选参数&#xff1f…

ultralytics yolov8 实例分割 训练自有数据集

参考: https://docs.ultralytics.com/datasets/segment/coco/ http://www.bryh.cn/a/613333.html 1、数据下载与转换yolo格式 1)数据集下载: 参考:https://universe.roboflow.com/naumov-igor-segmentation/car-segmetarion 下载的是coco格式,需要转换 2)coco2yolo t…

银行业务测试

1、商业银行四大类&#xff1a; 业务类系统、渠道类面试、MIS类系统、其他基础平台系统 2、银行系统开发流程&#xff08;UAT是行方&#xff09; 3、银行系统测试流程 4、对于不同的服务方式也不同&#xff0c;如:柜台、手机银行、网上银行&#xff0c;电话外呼&#xff0c;…

局域网共享打印机共享,简单至简至一键处理011bDll等问题

一、电脑系统是否激活&#xff08;可选&#xff09; 二、确保主客户端PC在同一局域网内&#xff08;可选&#xff09; 可以通过ping 目标地址 如ping 192.168.1.202&#xff1b;看是否可以正常通信 下面是惠普类型打印机共享问题关键&#xff08;文本记得保存&#xff09; …

MS2401隔离Σ-Δ调制器,可替代ADI的AD7401

产品简述 MS2401 是一款二阶 Σ-Δ 调制器&#xff0c;集成片上数字隔离器&#xff0c;能 将模拟输入信号转换为高速 1 位码流。调制器对输入信号连续 采样&#xff0c;无需外部采样保持电路。模拟信号输入满量程为 320 mV &#xff0c;转换后的数字码流的最高数据速率为 2…

Unsupervised Condition GAN

Unsupervised Condition GAN主要有两种做法&#xff1a; Direct Transformation 直接输入domain X图片&#xff0c;经过Generator后生成对应的domain Y的图像。这种转化input和output不能够差太多。通常只能实现较小的转化&#xff0c;比如改变颜色等。 Projection to Commo…