【C++】：类和对象(下)

目录

  • 一，再谈构造函数
    • 1.初始化列表
    • 2. 隐式类型转换的过程及其优化
    • 3. 隐式类型转换的使用
    • 4. explcit关键字
    • 5. 单参数和多参数构造函数的隐式类型转换
  • 二，static成员
    • 1.静态成员变量
    • 2.静态成员函数
  • 三，友元
    • 3.1 友元函数
    • 3.2 友元类
  • 四，内部类
  • 五，匿名对象

一，再谈构造函数

这个语法其实是对前面的构造函数的补充。最重要的是初始化列表的使用，及其特性，隐式类型转换，还有当前阶段需要了解的 explicit 关键字。

1.初始化列表

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

1.1 初始化列表的使用

当我们实现一个MyQueue(用两个栈模拟一个队列)时，如果栈不具备默认构造，MyQueue也无法生成默认构造，此时MyQueue要显示实现默认构造。

如何实现呢？必须用初始化列表。

初始化列表的本质：可以理解为每个对象中成员定义的地方。

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity )
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}

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

	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}

private:
	DataType* _array;
	int _capacity;
	int _size;
};

class MyQueue
{
public:
    //初始化列表
	MyQueue(int n= 20)
		:_pushst(n)//自定义类型会调用构造函数
		, _popst(n)
		//, _size(0) //ok
	{
		//函数体内
		_size = 0;//ok
	}
private:
	//声明
	Stack _pushst;
	Stack _popst;
	int _size;
};

int main()
{
	MyQueue q1(10);
	MyQueue q2;//有缺省值时可以不用赋值，没传默认用缺省值

	return 0;
}

1.2 有些变量只能在初始化列表中初始化，不能在函数体中初始化。
(1) const 成员变量；
const 成员变量必须在定义的地方初始化，因为它只有一次初始化机会。或是在声明时用缺省值。

(2) 引用成员变量；
引用也必须在定义的时候初始化。

(3) 没有默认构造的自定义类型成员。
因为没有默认构造时，必须显式传参调用构造函数。

class MyQueue
{
public:
	MyQueue(int n,int& rr)//这里也可以写缺省值
		:_pushst(n)//自定义类型会调用构造函数
		, _popst(n)
		//, _size(0) //ok

		,_x (1)
		,_ref(rr)
	{
		//函数体内
		_size = 0;//ok

		//_x =1; //err
	}
private:
	//声明
	Stack _pushst;
	Stack _popst;
	int _size;

	//const变量必须在定义的时候初始化。因为它只有一次初始化的机会
	const int _x;

  const int _x = 10;//在这里给缺省值ok
    
	//引用变量必须在定义的时候初始化
	int& _ref;
};

int main()
{
	int xx = 0;

	MyQueue q1(10,xx);
	MyQueue q1(10);

	int& aa = xx;

	return 0;
}

1.3 初始化列表，不管你写不写，每个成员变量都会先走一遍，此时自定义类型的成员会调用默认构造(没有默认构造就编译报错)，内置类型看编译器，有点会处理，有的不会处理。

1.4 在C11中我们知道可以在成员变量声明时给缺省值，实际上这个缺省值就是给初始化列表用的。但是与此同时，如果在初始化列表中给定了值，就以列表中的为准，与缺省值无关。

class MyQueue
{
public:
	//实践总结：尽可能使用初始化列表初始化，不方便再使用函数体初始化
	MyQueue()
		:_pushst(10)
		,_ptr((int*)malloc(40)) //ok
	{
		_size = 2;
	}

private:
	//声明
	Stack _pushst;
	Stack _popst;
	
    //这里的缺省值是1，但是初始化列表中是2，此时_size = 2
	int _size = 1;

	int* _ptr;
};

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

比如下面的代码，运行结果是：1 ，随机值。

这是因为先声明的是_a2 ，所以在初始化时会先走_a2(_a1)这条语句，而此时_a1没有初始化，是随机值，所以_a2是随机值。再初始化_a1。

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

2. 隐式类型转换的过程及其优化

隐式类型转换：把内置类型转换为自定义类型。

优化：在一个表达式中，编译器遇到构造 + 拷贝构造时，会优化成直接构造。

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 = aa1;//ok
	
	//过程：先用3构造了一个A的临时对象，再用临时对象去拷贝构造给aa3
	//优化：在一个表达式中，编译器遇到构造 + 拷贝构造，会优化成直接构造
	A aa3 = 3;

	//A& raa = 4;//err
	
	//当用引用时，由于用3构造了一个临时对象，临时对象具有常性，所以加const
	//过程：这里只用3构造了一个临时对象，没有拷贝构造
	
	//raa引用的是类型转换中用3构造的临时对象
	const A& raa = 4;//ok

	return 0;
}

在这里插入图片描述

3. 隐式类型转换的使用

在C++初阶，隐式转换使用的较少，但是在以后是很有用的，使用起来很方便，简洁。

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

	void Print()
	{
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a2;
	int _a1;
};

class Stack
{
public:
	//方式1：ok
	//void Push(A& aa)
	//{
	//	//.......
	//}	

	//方式2：ok
	void Push(const A& aa)
	{
		//....
	}

	//.....
};

int main()
{
	Stack st;

	//方式1：会进行先构造，后拷贝构造
	A a1(1);
	st.Push(a1);

	//方式2：10进行了隐式类型转换，时代码更简洁
	st.Push(10);

	return 0;
}

4. explcit关键字

作用：禁止构造函数的隐式转换。

看看下面的代码，如果在构造函数前加上explcit，运行结果：

class A
{
public:
	//单参数构造函数
	explicit A(int a)
	//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 = aa1;

	A aa3 = 3;

	const A& raa = 4;

	return 0;
}

在这里插入图片描述

5. 单参数和多参数构造函数的隐式类型转换

多参数构造函数的隐式类型转换的过程与第2点中解释的单参数类似。

class A
{
public:
	//单参数构造函数
	//explicit A(int a)
	A(int a)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}

	//多参数构造函数
	A (int a1,int a2)
		:_a(0)
		,_a1(a1)
		,_a2(a2)
	{}

	//拷贝构造
	A(const A& aa)
		:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}

private:
	int _a;
	int _a1;
	int _a2;
};

int main()
{
	A aaa1(1, 2);
	A aaa2 = { 1,2 };//传参时要用花括号
	const A& aaa3 = { 3,2 };

	return 0;
}

二，static成员

对象中只存成员变量，不存静态成员变量，静态成员变量在静态区，也不存函数，函数指针，它们在代码段。

1.静态成员变量

特性：
(1) 静态成员变量在静态区，不在对象中；
(2) 静态成员变量不能给缺省值，因为缺省值是给初始化列表用的，它在静态区，不在对象中，不走初始化列表；
(3) 静态成员变量的定义在全局，如果只有声明，没有定义，会报错！

当用sizeof计算对象的大小时，结果是：8
这就说明 aa1 对象中只有_a1，_a2，没有 _scount。

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

	A(const A& t)
	{
		cout << "A(const A& t)" << endl;

	}

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

	}
private:
	//声明
	int _a1;
	int _a2;

public:
	//在静态区，不在对象中
	//不能给缺省值，因为缺省值是给初始化列表用的
	//它在静态区，不在对象中，不走初始化列表
	static int _scount;
};

//静态成员变量的定义(如果只有声明，没有定义，会报错！)
int A::_scount = 1;


int main()
{
	A aa1;
	cout << sizeof(aa1) << endl;//8

	//如果它是公有的，就可以按如下访问
	//aa1._scount++;
	//cout << A::_scount << endl;

	return 0;
}

在这里插入图片描述

静态成员变量的特点：它属于整个类，属于所有对象。

使用静态成员变量可以统计一共创建了多少个类对象：

因为所有的对象都要走构造或者拷贝构造：在它们之中++，统计累计创建了多少个类对象；
当走完析构函数：统计现在还有多少对象存活。

代码实现如下：

class A
{
public:
	A()
	{
		++_scount;
	}

	A(const A& t)
	{
		++_scount;
	}

	~A()
	{
		--_scount;
	}

private:
	//声明
	int _a1;
	int _a2;

public:
	static int _scount;
};

int A::_scount = 0;

int main()
{
	A aa1;
	//cout << sizeof(aa1) << endl;//8

	A aa2;
	A aa3;

	cout << A::_scount << endl;

	return 0;
}

在这里插入图片描述

2.静态成员函数

第1点中对静态变量的使用都是它在公有的前提下，那么它在私有时该如何访问呢？就要使用静态成员函数了。

特点：static修饰成员函数，没有this指针，意味着只能访问静态成员，不能访问其他的成员变量。

class A
{
public:
	A()
	{
		++_scount;
	}

	A(const A& t)
	{
		//但是非静态的可以调用静态的
		GetCount();//ok

		++_scount;
	}

	~A()
	{
		--_scount;
	}

	//特点：static修饰成员函数，没有this指针，意味着只能访问静态成员
	//不能访问其他的成员变量
	static int GetCount()
	{
		return _scount;
	}

private:
	//声明
	int _a1;
	int _a2;

	static int _scount;
};

int A::_scount = 0;

int main()
{
	A aa1;

	A aa2;
	A aa3;

	//调用方式
	cout << A::GetCount() << endl;

	return 0;
}

三，友元

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

3.1 友元函数

问题：
现在尝试去重载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修饰，因为const修饰this指针;
  3. 友元函数可以在类定义的任何地方声明，不受类访问限定符限制;
  4. 一个函数可以是多个类的友元函数;
  5. 友元函数的调用与普通函数的调用原理相同

3.2 友元类

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

class Time
{
   //声明 Date是Time的友元
   //则在Date中可以访问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;
};

特性：

  1. 友元关系是单向的，不具有交换性；
    比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接
    访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
  2. 友元关系不能传递；
    如果C是B的友元， B是A的友元，则不能说明C时A的友元。
  3. 友元关系不能继承，在继承位置再给大家详细介绍。

四，内部类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。

内部类是一个独立的类，它不属于外部类，它仅仅是受到外部类域的限制，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。

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

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都是可以的。
  2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
  3. sizeof(外部类)=外部类，和内部类没有任何关系。

五，匿名对象

匿名对象的生命周期只在当前这一行，即用即销毁。

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

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

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

相关文章

Vue ui 创建vue项目，详细使用攻略。

Vue ui 创建vue项目，详细使用攻略。

1.安装及启动 1.1 Vue ui 使用前提是全局安装vue.js 命令如下 npm install vue -g 1.2 安装过Vue.js 之后 随便在自己系统的一个地方打开命令面板 1.3 使用命令启动vue ui面板创建项目 vue ui 如图运行后显示这种就是启动成功&#xff0c;成功之后会弹出页面或者直接访问你的…
阅读更多...
QT5制做两个独立窗口

QT5制做两个独立窗口

目录 增加第二个窗口 主窗口文件添加一个私有成员为子窗口 定义两个槽函数和 关联按钮和子窗口和主窗口 添加子窗口成员 子窗口处理函数 补充回顾 增加第二个窗口 1、 2、 3 主窗口文件添加一个私有成员为子窗口 在mainwidget.h文件 同时添加两个槽&#xff1b;来处理…
阅读更多...
Visual studio 2019 编程控制CH341A芯片的USB设备

Visual studio 2019 编程控制CH341A芯片的USB设备

1、硬件 买了个USB可转IIC、或SPI、或UART的设备&#xff0c;主芯片是CH341A 主要说明USB转SPI的应用&#xff0c;绿色跳线帽选择IIC&SPI&#xff0c;用到CS0、SCK、MOSI、MISO这4个引脚 2、软件 2.1、下载CH341A的驱动 点CH341A官网https://www.wch.cn/downloads/CH34…
阅读更多...
人工智能工具的强大之处：我用过的最好用的AI工具

人工智能工具的强大之处：我用过的最好用的AI工具

人工智能工具的强大之处&#xff1a;我用过的最好用的AI工具 在当今科技迅速发展的时代&#xff0c;人工智能(AI)工具已经成为我们日常生活和工作中不可或缺的一部分。从语音助手到自动化内容创建工具&#xff0c;再到数据分析软件&#xff0c;AI的应用领域广泛且深远。本篇博…
阅读更多...
【antd + vue】InputNumber 数字输入框 输入限制

【antd + vue】InputNumber 数字输入框 输入限制

一、需求说明 只能输入数字和小数点&#xff0c;保留小数点后两位&#xff1b;最多输入6位&#xff1b;删除所有内容时&#xff0c;默认为0&#xff1b; 二、问题说明 问题1&#xff1a;使用 precision 数值精度 时&#xff0c;超出规定小数位数时会自动四舍五入&#xff1b;…
阅读更多...
LLM应用：让大模型prompt总结生成Mermaid流程图

LLM应用：让大模型prompt总结生成Mermaid流程图

生成内容、总结文章让大模型Mermaid流程图展示&#xff1a; mermaid 美人鱼, 是一个类似 markdown&#xff0c;用文本语法来描述文档图形(流程图、 时序图、甘特图)的工具&#xff0c;您可以在文档中嵌入一段 mermaid 文本来生成 SVG 形式的图形 Prompt 示例&#xff1a;用横向…
阅读更多...
PDF 正确指定页码后，挂载的书签页码对不上

PDF 正确指定页码后，挂载的书签页码对不上

这个问题与我的另一篇中方法一样 如何让一个大几千页的打开巨慢的 PDF 秒开-CSDN博客 https://blog.csdn.net/u013669912/article/details/138166922 另做一篇原因是一篇文章附带一个与该文章主题不相关的问题时&#xff0c;不利于被遇到该问题的人快速搜索发现以解决其遇到的…
阅读更多...
深度学习口型驱动Visemenet使用小结

深度学习口型驱动Visemenet使用小结

说明 我前一篇博客《使用共振峰提取元音音素/从声音生成口型动画》探索了使用共振峰分析元音&#xff0c;然后从元音音素映射到视位的口型驱动方案。当时我就在想&#xff0c;如果能用深度学习法方法从音频直接生成音素流&#xff0c;然后转换成对应视位&#xff0c;不就很容易…
阅读更多...
Vue项目打包APK----Vue发布App

Vue项目打包APK----Vue发布App

时隔多年我又来跟新了&#xff0c;今天给大普家及下前端Vue傻瓜式发布App&#xff0c;话不多说直接上干货。 首先准备开发工具HBuilder X&#xff0c;去官网直接下载即可&#xff0c;算了直接给你们上地址吧HBuilderX-高效极客技巧。 打开软件&#xff0c;文件-->新建--&g…
阅读更多...
ARM学习（27）链接库依赖学习（二）dlopen failed：library xxxx.so

ARM学习（27）链接库依赖学习（二）dlopen failed：library xxxx.so

笔者继续学习一下链接的依赖库。 1、起因 Android下面需要需要一个日志解码库&#xff0c;所以笔者就编译了一个parse.so来进行解码&#xff0c; 编译器&#xff1a;Clang&#xff0c;基于llvm后端的编译器平台&#xff1a;交叉编译&#xff0c;linux -> aarch64 linux An…
阅读更多...
Java | Leetcode Java题解之第62题不同路径

Java | Leetcode Java题解之第62题不同路径

题目&#xff1a; 题解&#xff1a; class Solution {public int uniquePaths(int m, int n) {long ans 1;for (int x n, y 1; y < m; x, y) {ans ans * x / y;}return (int) ans;} }
阅读更多...
Python+PYGObject/PYGtk+CSS样式--2024python示例

Python+PYGObject/PYGtk+CSS样式--2024python示例

隔久点不用老是会忘&#xff0c;留个笔记。。 PythonPYGObject/PYGtk&#xff0c;加载 CSS 样式的演示代码 demo 运行的效果截图&#xff1a; #!/usr/bin/env python3 import sys import gigi.require_version("Gtk", "3.0") from gi.repository import …
阅读更多...
Web APIs 学习归纳5--- BOM浏览器对象

Web APIs 学习归纳5--- BOM浏览器对象

前面几节主要针对DOM进行了学习&#xff0c;现在开始新的内容的学习---DOM浏览器对象。 DOM是更注重页面&#xff08;document&#xff09;内容的设计&#xff0c;但是BOM不仅限于页面&#xff08;document&#xff09;的设计&#xff0c;而是更加全面包括页面的刷新&#xff0…
阅读更多...
【小迪安全2023】第59天:服务攻防-中间件安全CVE复现lSApacheTomcatNginx

【小迪安全2023】第59天:服务攻防-中间件安全CVE复现lSApacheTomcatNginx

&#x1f36c; 博主介绍&#x1f468;‍&#x1f393; 博主介绍&#xff1a;大家好&#xff0c;我是 hacker-routing &#xff0c;很高兴认识大家~ ✨主攻领域&#xff1a;【渗透领域】【应急响应】 【Java、PHP】 【VulnHub靶场复现】【面试分析】 &#x1f389;点赞➕评论➕收…
阅读更多...
Taro引入echarts【兼容多端小程序（飞书/微信/支付宝小程序）】

Taro引入echarts【兼容多端小程序（飞书/微信/支付宝小程序）】

近期接到公司新需求&#xff0c;开发飞书小程序&#xff0c;并且原型中含有大量的图表&#xff0c;本想使用飞书内置图表组件 —— chart-space&#xff0c;但官方表示已经停止维护了&#xff0c;无奈之下&#xff0c;只能另寻他路&#xff0c;于是乎&#xff0c;图表之王&…
阅读更多...
Content type ‘application/json；charset=UTF-8‘ not supported异常的解决过程

Content type ‘application/json；charset=UTF-8‘ not supported异常的解决过程

1.首先说明开发场景 *就是对该json格式数据传输到后台 后台实体类 import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import com.fasterxml.jackson.annotation.JsonIgnore; import lombok.Data; import org.sp…
阅读更多...
CSS移动端弹性布局

CSS移动端弹性布局

一级标题 二倍图 <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><meta name"viewport" content"widthdevice-width, initial-scale1.0"><title>背景图片</title><styl…
阅读更多...
LLM系列(4)：通义千问7B在Swift/DeepSpeed上微调秘诀与实战陷阱避坑指南

LLM系列(4)：通义千问7B在Swift/DeepSpeed上微调秘诀与实战陷阱避坑指南

LLM系列(4)：通义千问7B在Swift/DeepSpeed上微调秘诀与实战陷阱避坑指南 阿里云于 2023年8 月 3 日开源通义千问 70 亿参数模型，包括通用模型 Qwen-7B 以及对话模型 Qwen-7B-Chat，这也是国内首个开源自家大模型的大厂。在诸多权威大模型能力测评基准上，如 MMLU、C-Eval、…
阅读更多...
VSCode 配置 CMake

VSCode 配置 CMake

VSCode 配置 C/C 环境的详细过程可参考&#xff1a;VSCode 配置 C/C 环境 1 配置C/C编译环境 方案一 如果是在Windows&#xff0c;需要安装 MingW&#xff0c;可以去官网(https://sourceforge.net/projects/mingw-w64/)下载安装包。 注意安装路径不要出现中文。 打开 windows…
阅读更多...
备忘录模式（行为型）

备忘录模式（行为型）

目录 一、前言 二、备忘录模式 三、总结 一、前言 备忘录模式(Memento Pattern&#xff09;是一种行为型设计模式&#xff0c;在不破坏封装性的前提下&#xff0c;捕获一个对象的内部状态&#xff0c;并在该对象之外保存这个状态&#xff0c;这样可以在之后将该对象恢复到原…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站