【C++】类和对象(下)—— 再谈构造函数 | static成员 | C++11补丁 |友元

🌈欢迎来到C++专栏 ~~ 类和对象(下)


  • (꒪ꇴ꒪(꒪ꇴ꒪ )🐣,我是Scort🎓
  • 🌍博客主页:张小姐的猫~江湖背景
  • 快上车🚘,握好方向盘跟我有一起打天下嘞!
  • 送给自己的一句鸡汤🤔:
  • 🔥真正的大师永远怀着一颗学徒的心
  • 作者水平很有限,如果发现错误,可在评论区指正,感谢🙏
  • 🎉🎉欢迎持续关注!
    在这里插入图片描述

请添加图片描述

兼容ios

assert

类和对象(下)

人工神经网络

请添加图片描述

eeprom

一、再谈构造函数

🎨构造函数体赋值

以前构造函数,我们是在函数体内赋值的

YOLOv5

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

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

动态分区

函数体内初始化相当于先初始化再赋值

permission配置

但对于像const成员变量,必须在定义的时候同时初始化,如果在函数体内初始化就会报错 ——

kafka3.0

在这里插入图片描述
为此我们引入了初始化列表,就是给成员变量找到一个依次定义处理的地方

web

🎨初始化列表

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

pyqt

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

private:
	int _year; //声明
	int _month;
	int _day;
};

int main()
{
	Date d1(2022, 2, 22); 
	return 0;
}

【注意】
每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

前端开发

🔥 1.类中包含以下成员,必须放在初始化列表进行初始化。注意,初始化列表就是成员变量定义的地方理解的关键

r语言

  • const成员变量

    温度传感器

    因为const成员变量必须在定义的时候同时初始化

    面向对象

  • 引用成员变量

    ccna

    引用必须在定义的时候初始化,因为初始化列表就是成员变量定义的地方

    os

举例:

超级玛丽

class Date
{
public:
	Date(int year, int month, int x)
		: _N(10)
		, _ref(x)
	{
		_year = year;
		_ref++;
	}
private :
	const int _N;//声明
	int& _ref;

	int _year;
	int _month;
	int _day;
};

int main()
{
	int x = 0;
	Date d1(2022, 2, x);
	return 0;
}
  • 没有默认构造函数自定义类型成员

没有默认构造函数,编译器调不动,需要在定义的时候自己显式的传参去调

反射

  • 哪什么情况下没有?比如我们自己写了一个构造函数,还是带参的,编译器不再自动生成的 —— 举例如下
class Time
{
public: 
    Time(int hour)
    {
        _hour = hour;
    }
private:
	int _hour;
};
class Date
{
public: 
    //要初始化_t 对象,只能通过初始化列表
    Date(int year, int hour)
	    :_t(hour)
    {
       _year =year;
    }
private: 
    int _year;
    Time _t;
};

int main()
{
    Date d(2022,1)
    return 0;
}

牢记!!!!很重要
ps:所有成员都会在初始化列表进行初始化,在进入花括号{}之前都会先去调用初始化列表

str和repr原理

  • 初始化列表成员变量定义的地方
  • main函数里:对象整体定义的地方
  • 私有域:成员变量声明的地方

请添加图片描述

wireshark


🔥 2.尽量使用初始化列表初始化,提高效率。对于自定义类型变量,一定会先使用初始化列表初始化

大数据

举例来说明:

JWT


class Time
{
public:
    Time(int hour = 0)
    {
        _hour = hour;
    }
private:
    int _hour;
};
class Date
{
public:
    //要初始化_t 对象,只能通过初始化列表
    //Date(int year, int hour)
    //    :_t(hour)
    //{
    //    _year = year;
    //}

    //在函数体内赋值,但是还是会先走初始化列表调用Time的默认构造,不健康
    Date(int year, int hour)
    {
        _year = year;
        Time t(hour);
        _t = t;
    }
private:
    int _year;
    Time _t;
};

int main()
{
    Date d(2022, 1);
    return 0;
}
  • 先调用了初始化列表去构造、再对Time构造Time t(hour)、再赋值_t = t —— 不高效

💚总结:内置类型成员,在函数体和在初始化列表初始化都可以;自定义类型的成员建议在初始化列表初始化,这样更高效

一起进大厂


🔥彩蛋:C++11为了在构造时候对内置类型不处理的情况打了补丁,即在声明的时候赋予了缺省值

线性规划模型

缺省值最终给到了初始化列表
在这里插入图片描述

hadoop数据排序实现

🔥 3. 初始化列表中的初始化顺序是在类中的声明次序,与其在初始化列表中的先后次序无关

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关键字

为什么一个整型能转换为日期类?

#include<iostream>
using namespace std;

class Date
{
public:
	Date(int year)
		:_year(year)
	{
		cout << "Date(int year)" << endl;
	}

	Date(const Date& dd)
	{
		_year = dd._year;
		cout << "Date(const Date& year)" << endl;
	}
private:
	int _year;

};

int main()
{
	Date d1(2002);//直接调用构造
	Date d2 = 2022;//思考?  隐式类型转化:构造 + 拷贝构造 + 优化 》直接调用构造
	return 0;
}

这其实是因为单参数的构造函数中发生了隐式类型转换

回忆之前的

	// 隐式类型转换 - 相近类型 
	double d = 1.1;
	int i = d;
	const int& i = d; 

忘记的可以去看看,点这里跳转:C++入门 里面有讲解

在这里插入图片描述

这里本来是用2022构造一个临时对象Date(2022)但是C++在连续的过程中,编译器会优化多个构造,合二为一,因此这里被优化为直接就是一个构造

在这里插入图片描述

相当于以下两句——

Date tmp(2022); //先构造
Date d2(tmp);	//再拷贝构造

但是这样的可读性就会大大降低,用explicit修饰构造函数,将会禁止单参构造函数的隐式转换 ——
在这里插入图片描述

💚匿名对象

Date(2022,10,26); //匿名对象————声明周期只有这一行

Solution slt;
slt.Sum_Solution(10);//有名对象调用,专门开辟了slt来调用

//匿名对象调用
Solution().Sum_Solution(10);//节省空间

二、static成员

🌍静态成员变量

声明为static的类成员称为类的静态成员,用static修饰的成员变量,称之为静态成员变量;用static修饰的成员函数,称之为静态成员函数

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

思路:如果我们要对同一个变量进行++,唯一想到的就是定义一个全局变量,但是这样如果有两个类共用一个count会有累加效应,且暴露在外面可能被人随意更改

这时候就要引入static成员

特性:

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

作为私有成员,怎么样在类外访问呢?只能提供一个公用的成员函数getCount。代码如下 ——

我们可以通过对象来访问成员函数getCount

#include<iostream>
using namespace std;

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		_scount++;
	}
    
	A(const A& aa)
		: _a(aa._a)
	{
		_scount++;
	}
    
	int getCount()
	{
		return _scount;
	}
private:
	int _a;
	static int _scount; //静态成员变量
};

int A::_scount = 0;	//静态成员变量必须在类外的全局定义

int main()
{
	A a1;
	A a2;
	A a3(a2);
	cout << a1.getCount() << endl; //通过对象来访问成员函数
	return 0;
}

那么有没有更好的方式,不需要定义对象就可以获取到呢?这要引入我们的静态成员函数

🌍静态成员函数

❤️ 静态成员函数没有隐藏的this指针,只能访问静态成员变量和函数。不能访问任何非静态成员

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		_scount++;
	}

	A(const A& aa)
		:_a(aa._a)
	{
		_scount++;
	}
	//静态成员函数  -- 没有this指针,不能访问非静态的成员
	static int GetCount()
	{
		return _scount;
	}
private:
	int _a;
	//静态成员变量,属于整个类,存在于静态区,生命周期在整个程序运行期间
	static int _scount;
};

int A::_scount = 0;

int main()
{
	A a1;
	A a2;
	A a3(a2);

	cout << A::GetCount() << endl;//可以通过类域来找 —— 突破类域
	cout << a1.GetCount() << endl;//也可以通过对象来找
}

【问题】:

  1. 静态成员函数可以调用非静态成员函数吗? 不行❌,没有this
  2. 非静态成员函数可以调用类的静态成员函数吗? 可以,属于整个类

三.、友元

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

查阅 Reference可知,coutcin对于内置类型之所以能“自动识别类型”,是因为库里面已经把函数重载都写好了

在这里插入图片描述

在这里插入图片描述

运算符重载:让自定义类型对象可以用运算符,转换成调用这个重载函数
函数重载:支持函数名相同的函数同时存在
二者没有必然联系,好比张伟和大张伟不是同一个人一样

我想让Date类这样的自定义类型,怎么样像内置类型一样,直接使用流提取、流插入打印呢?

 Date d1(2022,10,12);
 cout<<d1;
 cout<<(d1+100);

我们不能往库函数里再加一个函数,我们尝试在Date类中重载

在这里插入图片描述

这是因为运算符有多个操作数的时候,第一个参数为左操作数,第二个参数是右操作数,那么很明显谁才是第一位:d1.operator<<(cout) d1

在这里插入图片描述

跑是能跑起来,但是这样合适吗?因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象,才能正常使用
于是我们把它挪到类外,将operator<<重载成全局函数摆脱隐藏的this指针约束,但是又有类外无法访问成员的问题

注:这里为了支持连续输出,重载函数需要有返回值ostream&,原理类似于连续赋值,只不过cout的结合性是从左至右:
cout<< d1<< d2

在这里插入图片描述
这时候就要引入友元来解决问题了

🌈友元函数

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

  • 友元函数可访问类的私有和保护成员,但不是类的成员函数
  • 友元函数不能用const修饰
  • 友元函数可以在类定义的任何地方声明,不受类访问限定符限制(但一般在开头)
  • 一个函数可以是多个类的友元函数
  • 友元函数的调用与普通函数的调用原理相同
#include<iostream>
using namespace std;

class Date
{
    //友元函数 -- 这个函数内部可以使用Date对象访问私有保护成员
	friend ostream& operator << (ostream& out, const Date& d);
	friend istream& operator>>(istream& in, Date& d);
public:
	Date(int year = 2022, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
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;
	in >> d._month;
	in >> d._day;
	return in;
}

int main()
{
	Date d1(2022, 10, 26); 
	Date d2(2022, 10, 12); 
	cout << d1 << d2;
	cin >> d1 >> d2;
	return 0;
}

ps:流提取的时候,需要写入,右操作数不能用const来修饰

🌈友元类

友元类所有成员函数都可以是另一个类的友元函数,都可以访问另一个类中的非公有成员(私有/保护)

  • 友元关系是单向的,不具有交换性

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

  • 友元关系不能传递

    如果B是A的友元,C是B的友元,则不能说明C时A的友元

#include<iostream>
using namespace std;

class Date; // 前置声明
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;
};

四、内部类

C++用的少,java用的多。谐音累不累,我累了

🌈如果一个类定义在另一个类的内部,这个类就叫做内部类。内部类天生就是就是外部类的友元类
内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元

特性:

  1. 内部类可以定义在外部类的public、protected、private都是可以的。
  2. 注意内部类可以直接访问外部类中的static成员,不需要外部类的对象/类名。
class A {
private:
	static int k;
	int h = 0;

public:
	//B定义在A的里面
	// 1、受A的类域的限制,访问限定符
	// B天生是A的友元
	class B
	{
	public:
		void foo(const A& a)
		{
			cout << k << endl;	//可以访问外部类的static
			cout << a.h << endl;//可以访问外部类的private
		}
	private:
		int _b;
	};
};

int A::k = 1;

int main()
{
	A::B b; //只是受类域的限制
	b.foo(A());
	return 0;
}

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

	cout << sizeof(A) << endl;

在这里插入图片描述

五、练习(易错)

众所周知,编译器会优化代码 ——
先抛结论:连续一个表达式步骤中,连续构造一般会优化—— 合二为一

W f3()
{
	W ret;
	return ret;
 }

int main()
{
	f3();//1次构造  1次拷贝
	cout << endl << endl;

	W w1 = f3();//本来:1次构造  2次拷贝  ——》优化:1次构造  1次拷贝 
}

那这里是怎么样优化的呢?
在这里插入图片描述

那么为什么可以跳过tmp,直接返回呢?这就要涉及到栈桢

在这里插入图片描述

问:以下代码调用了__次构造? __次拷贝构造?

W f(W u)
{
	W v(u);
	W w = v;
	return w;
}
main()
{
	W x;
	W y = f(f(x));
}

每层循环分开来看

在这里插入图片描述

这个图应该只有我能看懂了,所以优化完是7次的拷贝构造,不优化是:9次

六. 再次理解类和对象

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

在这里插入图片描述

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

📢写在最后

dwg从网吧队打到世界冠军,我要是他,我比他还狂,冠军也会落寞,也印证了失败才是人生的主旋律,成功只是偶尔,加油少年

请添加图片描述

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注