【C++初阶:类和对象(下篇)】初始化列表 | static成员 | 友元

news2025/1/9 15:28:00

目录

  • 一、构造函数
    • 构造函数体赋值🐾
    • 初始化列表🐾
    • 💦 explicit关键字
  • 二、static成员🐾
    • 概念
    • **💦 关于静态的特性**
  • 三、友元
    • 💦 **友元函数**
    • 💦 **友元类**
  • **四、内部类**

一、构造函数

构造函数体赋值🐾

❓ 引出初始化列表 ❔

class A
{
public:
	A(int a = 0)
	{
		_a = a;	
	}
private:
	int _a;
};
class B
{
private:
	int _b = 1;
	A _aa;
};
int main()
{
	B b;
	return 0;
}

📝 说明

对于 B,我们不写构造函数,编译器会默认生成 —— 内置类型不处理,自定义类型会去调用它的默认构造函数处理 (无参的、全缺省的、编译器默认生成的),注意无参的和全缺省的只能存在一个,如果写了编译器就不会生成,如果不写编译器会默认生成。这里 C++ 有一个不好的处理 —— 内置类型不处理,自定义类型处理。针对这种问题,在 C++11 又打了一个补丁 —— 在内置类型后可以加上一个缺省值,你不初始化它时,它会使用缺省值初始化。这是 C++ 早期设计的缺陷。

class A
{
public:
	A(int a = 0)
	{
		_a = a;	
		cout << "A(int a = 0)" << endl;
	}
	A& operator=(const A& aa)//不写也行,因为这里只有内置类型,默认生成的就可以完成
	{
		cout << "A& operator=(const A& aa)" << endl;
		if(this != &aa)
		{
			_a = aa._a;
		}
		return *this;
	}
private:
	int _a;
};
class B
{
public:
	B(int a, int b)
	{
		//_aa._a = a;//err:无法访问private成员
		
		/*A aa(a);
		_aa = aa;*/ 
		_aa = A(a);//简化版,同上
		
		_b = b;
	}
private:
	int _b = 1;
	A _aa;
};
int main()
{
	B b(10, 20);
	return 0;
}

📝 说明

对上,_b只能初始化成1,_a只能初始化成0 ❓

这里可以显示的初始化,利用匿名对象来初始化 _a。

但是这种方法代价较大 (见下图)。
在这里插入图片描述

初始化列表🐾

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

class A
{
public:
	A(int a = 0)
	{
		_a = a;	
		cout << "A(int a = 0)" << endl;
	}
	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if(this != &aa)
		{
			_a = aa._a;
		}
		return *this;
	}
private:
	int _a;
};
class B
{
public:
	B(int a, int b)
		:_aa(a)
	{
		_b = b;
	}
private:
	int _b = 1;
	A _aa;
};
int main()
{
	B b(10, 20);
	return 0;
}

在这里插入图片描述

  • 可以看到相比于在函数体内初始化,使用初始化列表初始化可以提高效率 —— 注意对于内置类型你使用函数体或初始化列表来初始化没有区别;但是对于自定义类型,使用初始化列表是更具有价值的。这里还要注意的是函数体内初始化和初始化列表是可以混着用的。

什么成员是必须使用初始化列表初始化的 ❓

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

⚠ 注意

1️⃣ 每个成员变量在初始化列表 (同定义) 中只能出现一次 (初始化只能初始化一次)。

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

1、引用成员变量 (引用成员必须在定义的时候初始化)

2、const 成员变量 (const 类型的成员必须在定义的时候初始化)

3、自定义类型成员 (该类没有默认构造函数)

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

#include<iostream>
using namespace std;
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 选项,因为 C++ 规定成员变量在类中声明次序就是其在初始化列表中的初始化顺序,与其初始化列表中出现的先后次序无关。实际中,建议声明顺序和初始化列表顺序保持一致,避免出现这样的问题。

💦 explicit关键字

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

在这里插入图片描述

📝 说明

A aa2 = 1; 意思和 A aa1(1)相同; 这是 C++98 支持的语法,它本质上是一个隐式类型转换 ,将 int 转换为 A,为什么 int 能转换成 A 呢 ? 因为它支持一个用 int 参数去初始化 A 的构造函数。它俩虽然结果是一样的,都是直接调用构造函数,但是对于编译器而言过程不一样(如下)。因此才会调用两次构造函数而不调用拷贝构造函数
在这里插入图片描述

❓ 如果不想允许这样的隐式类型转换的发生 ❔

这里可以使用关键字 explicit


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

int main()
{
	A aa2 = 1;
	return 0;
}
//error C2440: “初始化”: 无法从“int”转换为“A”

❓ 多参数隐式类型转换 ❔

class A
{
public:
	A(int a1, int a2)
		:_a(a1)
	{
		cout << "A(int a1, int a2)" << endl;	
	}
	A(const A& aa)
	{
		cout << "A(const A& aa)" << endl;	
	}
private:
	int _a;
};
int main()
{
	A aa1(1, 2);
	//A aa2 = 1, 2;//error
	A aa2 = {1, 2};
	return 0;
}

📝说明

  • A aa2 = 1, 2; 是错误写法, C++98 不支持多参数的隐式类型转换,但是 C++11 是支持的, A aa2 = {1, 2};同样编译器依然会优化。当我们使用 explicit 关键字限制时,它会 error C2440:“初始化”: 无法从“int”转换为“A”

  • 如果你将单参数构造函数改为explicit A(int a),那么A aa2 = 1;这行代码就会导致编译错误,因为编译器被禁止进行从int到A的隐式类型转换。你必须显式地调用构造函数,像A aa2(1);这样。

  • 总的来说,explicit关键字可以帮助你控制类型转换,防止因为不希望的隐式类型转换而导致的错误。

二、static成员🐾

概念

❓ 写一个程序,计算程序构造了多少个对象 (构造+拷贝构造) ❔

int countC = 0;//记录调用构造函数的次数
int countCC = 0;//记录调用拷贝构造函数的次数
class A
{
public:
	A()
	{
		++countC;
	}
	A(const A& a)
	{
		++countCC;
	}
};
A f(A a)
{
	A ret(a);
	return ret;
}
int main()
{
	A a1 = f(A());
	A a2;
	A a3;
	a3 = f(a2);
	cout << countC << endl;
	cout << countCC << endl;
	return 0;
}

在这里插入图片描述

📝说明

这样虽然能计算出结果,但是有一个问题,countC 和 countCC 是可以随便改的,这样就很不好。

优化 ❓

class A
{
public:
	A()
	{
		++_count;
	}
	A(const A& a)
	{
		++_count;
	}
	//静态成员函数特点是没有this指针
	static int GetCount()
	{
		return _count;	
	}
private:
	int _a;
	static int _count;//注意静态成员不能给缺省值,使用静态可以保证不同成员函数
	//++_count是同一个_count,而不是不同的临时变量
	//_count不是属于某个对象的,而是属于整个类的
};
//定义初始化
int A::_count = 0;
A f(A a)
{
	A ret(a);
	return ret;
}
int main()
{
	A a1 = f(A());
	A a2;
	A a3;
	a3 = f(a2);
	cout << sizeof(A) << endl;
	
	//这里就体现了static成员属于整个类,也属于每个定义出来的对象共享,但限制于公有
	/*cout << A::_count << endl;	
	cout << a1._count << endl;
	cout << a2._count << endl;*/

	/*A ret;
	cout << ret.GetCount() - 1 << endl;*/
	/*cout << A().GetCount() - 1 << endl;*/
	cout << A::GetCount() << endl;
	return 0;
}

在这里插入图片描述

📝说明

int _a; 存在定义出的对象中,属于对象。

static int _count; 存在静态区,属于整个类,也属于每个定义出来的对象共享。跟全局变量比较,它受类域和访问限定符限制,更好的体现封装,别人不能轻易修改。

static成员 ❓

对于非 static 成员它们的定义是在初始化列表中,但在 C++ 中,static 静态成员变量是不能在类的内部定义初始化的,这里的内部只是声明。注意这里虽然是私有成员,但是对于 static 成员它支持在外部进行定义,且不需要加上 static,sizeof 在计算的时候并不会计算 static 成员的大小。

  • _count是私有,怎么访问 ❓

定义一个公有函数 GetCount 函数,返回 _count:调用函数
1、最后实例化对象后调用 GetCount 函数并减 1
2、直接匿名对象并减 1
3、将 GetCount 函数定义成静态成员函数并使用类域调用

💦 关于静态的特性

1️⃣ 静态成员变量为所有类对象所共享,不属于某个具体的实例。

2️⃣ 静态成员变量必须在类外定义,定义时不添加 static 关键字。

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

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

5️⃣ 静态成员和类的普通成员一样,也有 public、protected、private3种访问级别,也可以具有返回值。


【面试题1】
static 的作用 C 语言 | C++ ❓

C 语言:

1、 static 修饰局部变量,改变了局部变量的生命周期 (本质上是改变了变量的存储类型),局部变量由栈区转向静态区,生命周期同全局变量一样

2、 static 修饰全局变量,使得这个全局变量只能在自己所在的文件内部使用,而普通的全局变量却是整个工程都可以使用

❓ 为什么全局变量能在其它文件内部使用 ❔

因为全局变量具有外部链接属性;但是被 static 修饰后,就变成了内部链接属性,其它源文件不能链接到这个静态全局变量了

3、 static 修饰函数,使得函数只能在自己所在的文件内部使用,本质上 static 是将函数的外部链接属性变成了内部链接属性 (同 static 修饰全局变量)

C++:

1、修饰成员变量和成员函数,成员变量属于整个类,所有对象共享,成员函数没有 this 指针。


三、友元

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

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

💦 友元函数

❓ 重载<< ❔

class Date
{
	friend ostream& operator<<(ostream& out, const Date& d);
	//友元,位置可任意,一般是开头
	friend istream& operator>>(istream& in, Date& d);//友元
public:
	Date(int year = 0, int month = 0, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
	/*void operator<<(ostream& out)
	{
		out << _year << "/" << _month << "/" << _day << endl;
	}*/
private:
	int _year;
	int _month;
	int _day;
};
ostream& operator<<(ostream& out, const Date& d)//支持连续输出
{
	out << d._year << "/" << d._month << "/" << d._day << endl;
	return out;
}
istream& operator>>(istream& in, Date& d)//支持连续输入
{
	in >> d._year >> d._month >> d._day;
	return in;
}
int main()
{
	Date d1, d2;
	cin >> d1 >> d2;

	//cout << d1 ? d1 << cout
	//cout << d1;
	/*d1.operator<<(cout);
	d1 << cout;*/
	cout << d1 << d2;
	return 0;
}

📝说明

cin | cout 怎么接收 ❓
在这里插入图片描述

在 C++ 里 cout 是一个 ostream 的对象;cin 是一个 istream 的对象。

cout << d1 | d1 << cout(d1.operator<<(cout)) ❓

**为啥不能 cout << d1 呢 ?**❓

运算符有几个操作数,重载函数就有几个参数。如果有两个操作数,左操作数是第一个参数,右操作数是第二个参数

在 Date 类成员函数 operator<< 里对象是第一个参数,因为隐含的 this 指针已经默认占据了,那么 cout 就只能作第二个操作数了。可以倒也可以,但是用起来不符合流运算符原来的特性。

**怎么改成 cout << d1 呢 ?**❓

也就是把 cout 作为第一个参数,那么这里就不能用成员函数了,之前我们用成员函数是因为成员变量是私有的。

如何取舍:使用成员函数 | 使用全局函数。这里成员函数的可读性差影响较大,所以将之舍弃,使用全局函数。

支持 cout << d1 后怎么解决私有 ?

解决方案1:提供公有的成员函数 GetYear、GetMonth、GetDay

解决方案2:友元函数

这里我们就引出了友元,C++ 默认是不能在类外访问私有的,但是它提供了友元以帮助我们解决这种场景的问题。友元函数可以直接访问类的私有成员,它是定义在类外部的普通函数,不属于任何类,但需要在类的内部声明,声明时需要加 friend 关键字。

💨小结

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

2、友元函数不能用 const 修饰,因为 const 修饰的是 this 指针指向的对象。

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

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

5、友元函数的调用与普通函数的调用和原理相同。

🍳拓展

这里主要拓展代码错误的解决能力,先来看一段代码。

class A
{
	friend void f(const A& aa, const B& bb);
public:
	A(int a = 0)
		: _a(0)
	{}
private:
	int _a;
};
class B
{
	friend void f(const A& aa, const B& bb);
private:
	int _b = 0;
	A _aa;
};
void f(const A& aa, const B& bb)
{
	cout << aa._a << endl;	
	cout << bb._b << endl;
}
int main()
{
	A aa;
	B bb;
	f(aa, bb);
	return 0;
}

📝分析

相信到了这里绝大部分的人都能凭借着自己的经验去解决大部分的 bug了。但是对于上面代码出现的错误又百思不得其解。
在这里插入图片描述

注意面对这种情况的时候,有时候编译器报的错误是不准确的,这里有两条建议能帮助提升查找 bug 的能力。

1、有很多错误的时候,一定是看最上面的错误,因为下面的错误有可能是上面的错误间接导致的。

2、排除法,这里有一百行代码(程序崩了),你注释掉了部分代码程序正常了,那么不用怀疑,错误就是注释处代码引发的。

经过分析,我们发现错误处是:在 B 类的友元里能找到 A、B;但是在 A 类的友元里就找不到 B 了。所以解决方法就是加前置声明 —— class B;


💦 友元类

class Date; //前置声明
class Time
{
	friend class Date;
	 //声明日期类为时间类的友元类,则在日期类中就直接访问Time类中的私有成员变量
public:
	Time(int hour, int minute, int second)
 	: _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;
};

📝分析

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

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

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

四、内部类

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

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

特性:

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	
		}
	private:
		int _b;
	};
};
int A::k = 0;
int main()
{
	cout << sizeof(A) << endl;//4
	A::B b;//要用B去定义,必须得指定域
	b.foo(A());
	return 0;
}

📝说明

sizeof 在计算 A 类型对象大小的时候,不考虑 B 类。因为 B 作为 A 的内部类,跟普通类没有什么区别,只是定义在 A 的内部,它受到 A 的类域的限制和访问限定符的限制。

一般情况是一个类专门为另一个类服务是才会用到内部类。


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

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

相关文章

Spring 事务原理总结四

作为一名认知有限的中国人&#xff0c;我对年的喜爱&#xff0c;胜过其他一切&#xff0c;因为它给了我拒绝一切的合理理由。每到这个时候&#xff0c;我都会用各种理由来为自己的不作为开脱&#xff0c;今年亦是如此。看着频频发出警报的假期余额&#xff0c;我内心的焦躁变得…

分布式文件系统 SpringBoot+FastDFS+Vue.js【一】

分布式文件系统 SpringBootFastDFSVue.js【一】 一、分布式文件系统1.1.文件系统1.2.什么是分布式文件系统1.3.分布式文件系统的出现1.3.主流的分布式文件系统1.4.分布式文件服务提供商1.4.1.阿里OSS1.4.2.七牛云存储1.4.3.百度云存储 二、fastDFS2.1.fastDSF介绍2.2.为什么要使…

详解CC++内存管理(new和delete)

文章目录 写在前面1. C&C内存分布2. C语言中动态内存管理方式&#xff1a;malloc/calloc/realloc/free3. C内存管理方式&#xff08;语法&#xff09;3.1 new/delete操作内置类型3.2 new和delete操作自定义类型 4. new和delete的实现原理4.1 operator new与operator delete…

【MySQL】学习外键约束处理员工数据

&#x1f308;个人主页: Aileen_0v0 &#x1f525;热门专栏: 华为鸿蒙系统学习|计算机网络|数据结构与算法 ​&#x1f4ab;个人格言:“没有罗马,那就自己创造罗马~” #mermaid-svg-g4glZPIY0IKhiTfe {font-family:"trebuchet ms",verdana,arial,sans-serif;font-siz…

STM32—DHT11温湿度传感器

文章目录 一.温湿度原理1.1 时序图 二.代码 一.温湿度原理 1.1 时序图 (1).下图一是DHT11总的时序图。 (2).图二对应图一的左边黑色部分&#xff0c;图三对应图一的绿色部分&#xff0c;图四的左部分图对应图一的红色部分&#xff0c;图四的右部分对应图一的黄色部分。 (3)…

计算机组成原理(1)----主存储器

目录 1.基本半导体元件及原理 2.寻址 1.基本半导体元件及原理 一个主存储器可以分为存储器&#xff0c;MAR&#xff08;地址寄存器&#xff09;和MDR&#xff08;数据寄存器&#xff09;&#xff0c;这三个部件由在时序控制逻辑的控制下工作 其中存储体用来存放二进制数据0和…

[BIZ-缓存] - 3.金融交易系统缓存架构设计

1. 前置文章 [BIZ] - 1.金融交易系统特点https://blog.csdn.net/besthezhaowen/article/details/136118133 [缓存] - 1.缓存共性问题https://blog.csdn.net/besthezhaowen/article/details/136111466 [缓存] - 2.分布式缓存重磅中间件 Redis-CSDN博客文章浏览阅读1.4k次&…

docker (一)-简介

1.什么是docker Docker 是一个开源的应用容器引擎&#xff0c;由于docker影响巨大&#xff0c;今天也用"Docker" 指代容器化技术。 2.docker的优势 一键部署&#xff0c;开箱即用 容器使用基于image镜像的部署模式&#xff0c;image中包含了运行应用程序所需的一…

【Java程序员面试专栏 分布式中间件】ElasticSearch 核心面试指引

关于ElasticSearch 部分的核心知识进行一网打尽,包括ElasticSearch 的基本概念,基本架构,工作流程,存储机制等,通过一篇文章串联面试重点,并且帮助加强日常基础知识的理解,全局思维导图如下所示 基础概念 从数据分类入手,考察全文索引的基本概念 现实世界中数据有哪…

【教程】Kotlin语言学习笔记(二)——数据类型(持续更新)

写在前面&#xff1a; 如果文章对你有帮助&#xff0c;记得点赞关注加收藏一波&#xff0c;利于以后需要的时候复习&#xff0c;多谢支持&#xff01; 【Kotlin语言学习】系列文章 第一章 《认识Kotlin》 第二章 《数据类型》 文章目录 【Kotlin语言学习】系列文章一、基本数据…

机器学习和统计学的区别?

1、本质区别&#xff1a; 目标&#xff1a;机器学习的核心目标是建立一个可以自动学习和改进的模型&#xff0c;以预测未知数据。它更关注结果的准确性和模型的泛化能力&#xff0c;通常不关心模型是否可以解释。而统计学的目标是探究变量之间的关系&#xff0c;理解数据的内在…

Python数据科学:Scikit-Learn机器学习

4.1Scikit-Learn机器学习 Scikit-Learn使用的数据表示&#xff1a;二维网格数据表 实例1&#xff1a;通过Seaborn导入数据 def skLearn():scikit Learn基本介绍:return:import seaborn as sns#导入Iris数据集#注&#xff1a;一般网络访问不了iris sns.load_dataset(iris)ir…

Spring Boot 笔记 020 redis集成

1.1 安装redis Windows 下 Redis 安装与配置 教程_redis windows-CSDN博客 2.1 引入redis坐标 <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency> 2.2 配置…

144.【Activiti 7】

Activiti 7 工作流 (一)、工作流程1.概念2.工作流系统3.适用行业4.具体应用5.实现方式 (二)、Activiti7概述1.介绍(1).BPM 介绍(2).BPM软件(3). BPMN 2.使用步骤(1).部署activiti(2).流程定义(3).流程定义部署(4).启动一个流程实例(5).用户查询待办任务(Task)(6).用户办理任务(…

第13讲创建图文投票

创建图文投票实现 图文投票和文字投票基本一样&#xff0c;就是在投票选项里面&#xff0c;多了一个选项图片&#xff1b;、 <view class"option_item" v-for"(item,index) in options" :key"item.id"><view class"option_input&…

如何在JavaScript中使用大于和小于运算符

在你的 JavaScript 程序中&#xff0c;你经常需要比较两个值&#xff0c;以确定一个是否大于另一个或小于另一个。这就是大于和小于运算符派上用场的地方。 在本文中&#xff0c;我们将通过代码示例更详细地介绍如何使用这些运算符。 &#xff08;本文内容参考&#xff1a;ja…

Mysql中关于on,in,as,where的区别

目录 Mysql on,in,as,where的区别 Mysql语句问题解决 1、left join数据筛选问题 2、相同数据重复筛选使用问题 3、根据某个字段排序取每个类别最后三条数据或前三条数据 4、业务逻辑书写位置问题 5、查找另一表内和本表相关字段的数量 6、关于union的使用 7、limit的巧…

Ubuntu如何设置成中文

1、右上角点击&#xff08;音量图标和电池图标位置&#xff09;&#xff0c;选择“Settings”&#xff08;设置&#xff09;。 2、左侧选择“Region & Language”&#xff08;区域与语言&#xff09;&#xff0c;然后选择“Manage Installed Languages”&#xff08;管理已…

测试开发-2-概念篇

文章目录 衡量软件测试结果的依据—需求1.需求的概念2.从软件测试人员角度看需求3.为什么需求对软件测试人员如此重要4.如何才可以深入理解被测试软件的需求5.测试用例的概念6.软件错误&#xff08;BUG&#xff09;的概念7.开发模型和测试模型8.软件的生命周期9.瀑布模型&#…

中科大计网学习记录笔记(十一):CDN

前言&#xff1a; 学习视频&#xff1a;中科大郑烇、杨坚全套《计算机网络&#xff08;自顶向下方法 第7版&#xff0c;James F.Kurose&#xff0c;Keith W.Ross&#xff09;》课程 该视频是B站非常著名的计网学习视频&#xff0c;但相信很多朋友和我一样在听完前面的部分发现信…