C++修炼:类和对象(下)

Hello大家好!很高兴我们又见面啦!给生活添点passion,开始今天的编程之路!

我的博客: <但凡.

我的专栏: 《编程之路》《数据结构与算法之美》《题海拾贝》《C++修炼之路》

欢迎点赞,关注!

目录

[1、 初始化列表](#1、 初始化列表)

2、类型转换

3、取地址运算符重载

4、static成员

5、友元

6、内部类

7、匿名对象


1、 初始化列表

我们在实例化类的对象的时候都是调用构造函数来进行初始化的。但之前我们都是把初始化的成员函数放在函数体内赋值。在这里我们介绍一种新的赋值方式,就是初始化列表。

函数体内赋值:

cpp 复制代码
DATE(int year = 2000, int mouth = 11, int day = 1)
{
	_year = year;
	_mouth = mouth;
	_day = day;
}

初始化列表:

cpp 复制代码
DATE(int year = 2000, int mouth = 11, int day = 1)
	:_year(year)
	, _mouth(mouth)
	, _day(day)
{
	
}

以上是两种初始化方式的对比。

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

初始化列表是每个成员变量进行初始化的位置,无论是否显示写初始化列表,每个成员初始化都需要走初始化列表。并且每个成员变量只能在初始化列表出现一次。

也就是说就算我们写成函数体内初始化的样子,成员变量初始化时也是会走初始化列表的。

如果我们写成如下代码的样子,其实初始化时是先走初始化列表,再走函数体,而函数体里面的再走初始化列表。那倒不如直接都写到促使华列表里面。

cpp 复制代码
DATE(int year = 2000, int mouth = 11, int day = 1)
	:_year(year)
	, _mouth(mouth)
	
{
	_day = day;
}

引用成员变量,const成员变量,没有默认构造的类类型变量,必须放在初始化列表位置进行初始化(或给定缺省值),否则会编译报错。

然后再介绍一点,C++11支持在成员变量声明时给定缺省值。这个缺省值是给没有显示在初始化列表里的成员变量使用的。

cpp 复制代码
#include<iostream>
using namespace std;
class DATE
{
public:
	DATE(int x)
		:t(x)
	{
		cout << t<<" "<<d << endl;
	}
private:
	int t = 1;
	int d = 2;
};
int main()
{
	DATE ti(0);

	return 0;
}

输出结果为0和2,也就是说当我们不写成初始化列表时成员变量的值就是缺省值,如果给定新的值就用新的值走初始化列表。

现在我们梳理一下成员变量走初始化列表的逻辑:

1、显示在初始化列表的成员变量就拿这个值进行初始化。

2、对于不显示在初始化列表的成员变量按他的缺省值初始化。

3、对于既没显示在初始化列表的,也没有缺省值的,我们分以下三种情况来讨论:

(1)如果说内置成员变量,可能会初始化为0或者随机值,根据编译器来定。

(2)如果是自定义类成员,调用该类的默认构造函数。

(3)对于引用成员变量,const成员变量,没有默认构造函数的成员变量,必须写在初始化列表或给定缺省值,不然编译报错。

初始化列表中按照成员变量在类中声明顺序进行初始化,跟成员在初始化列表出现的的先后顺序无关。建声明顺序和初始化列表顺序保持一致。

下面我们来看一到题巩固一下:

cpp 复制代码
#include<iostream>
using namespace std;
class A
{
public:
 A(int a)
     :_a1(a)
     , _a2(_a1)
{
}
 void Print() 
 {
     cout << _a1 << " " << _a2 << endl;
 }
private:
     int _a2 = 2;
     int _a1 = 2;
};
int main()
{
     A aa(1);
     aa.Print();
}

上面这代码的输出结果是什么?

先说答案,说出结果是输出1和随机值。

分析一下,首先这道题和缺省值没什么关系,因为既然a1,a2都显示在初始化列表里面了那就不需要用缺省值走初始化列表了。现在需要注意一点,初始化的顺序和声明的顺序保持一致。那也就是说先初始化a2,再初始化a1。那这样的话a2在初始化的时候他的值和a1的值相等,而a1此时的值是随机值,在这之后a1进行初始化,他的值等于1.

经过上述分析,输出结果为1和随机值。

2、类型转换

C++支持内置类型隐式类型转换为类类型对象,需要有相关内置类型为参数的构造函数。

构造函数前面加explicit就不再支持隐式类型转换。

类类型的对象之间也可以隐式转换,需要相应的构造函数支持。

下面我们看这样一串代码:

cpp 复制代码
#include<iostream>
using namespace std;
class A
{
public:
	A(int x)
		:t(x)
	{
	}
	void print()
	{
		cout << t << endl;
	}
private:
	int t = 1;
};
int main()
{
	A tt=10;
	tt.print();
	return 0;
}

对于A tt=10这句代码,我上一期提到过,这也是调用构造函数而不是=的运算符重载。 但是这种构造并不是简单的构造。他其实是先用10构造出一个临时对象,在把临时对象拷贝构造给tt(这里用的拷贝构造是编译器自己生成的拷贝构造),但是经过编译器优化之后,优化成了直接构造。这其实就是隐式类型转换。

cpp 复制代码
#include<iostream>
using namespace std;
class A
{
public:
	A(int x)
		:t(x)
	{
	}
	void print()
	{
		cout << t << endl;
	}
private:
	int t = 1;
};
int main()
{
	A tt=10;
	tt.print();


	A& tt1 = tt;
	tt1.print();
	const A& tt2 = 1;

	return 0;
}

现在我又把上面的代码新增了两句,对于const A& tt2=1;这一句,如果我们去掉const就会发现编译报错,这是为什么?

我们来分析一下。首先1创建临时对象,由于临时对象具有常性,如果直接用A&的话就会造成权限放大的问题,编译报错。所以我们必须const引用。

**隐式类型转换实际上是极大程度方便我们编写程序的。**现在想像这样一个场景,如果我们新学习了一个数据结构叫栈,栈里面插入的数据都是A类型的,那我们push的时候是先构造一个A类型的数据,再把A传入push函数,还是直接把这个数据传入更方便呢?肯定是让他自己进行隐式类型转换,直接传入数据更方便的。

3、取地址运算符重载

为什么我会提到这个东西呢?不知道大家发现没有我在上面的代码中并没有打印tt2,因为如果直接调用print函数的话会报错:

因为我们的print函数里面的this指针类型和constA&并不匹配。

首先我们的printf函数里的this指针实际上应该是A* const this。这里的const意思是限制this的指向不能改变。他说到底还是A*类型的。那这不对啊,我们调用的时候传入的参数实际上是const A*类型的,这又是权限放大了。那应该怎么办呢?

我们对打印函数进行升级:

cpp 复制代码
void print() const
{
	cout << t << endl;
}

这个操作就是把this指针的类型改成了const A* const this。这样我们所有的变量都可以正常打印了。

4、static成员

**用static修饰的成员变量,称之为静态成员变量。**这个大家应该都知道,因为我们在C语言阶段就接触过static了。

静态成员变量⼀定要在类外进行初始化。

**静态成员存放在静态区,不在类对象中。**正因此我们在进行如下代码时是会报错的:

cpp 复制代码
class A
{
public:
	A(int x)
		:t(x)
	{
	}
	void print() const
	{
		cout << t << endl;
	}
private:
	int t = 1;
	static int b = 5;
};

大家可以这样理解,我们static成员都不在类中存储,那他初始化其实根本就不用走初始化列表,那我们怎么能过他给缺省值呢? 也正因此,我们的静态成员变量在类外进行初始化。

cpp 复制代码
#include<iostream>
using namespace std;
class A
{
public:
	A(int x)
		:t(x)
	{
	}
	void print() const
	{
		cout << t <<" "<< b << endl;
	}
private:
	int t = 1;
	static int b;
};
int A::b = 100;
int main()
{
	A tt=10;
	tt.print();
	
	return 0;
}

以上代码正确的对静态成员b进行了类外初始化。

**对于静态成员的访问,如果是公有的情况下,tt.b和A::b都可以进行访问。**但是如果是私有成员就不能这样随便访问了。因为静态成员也受private等的限制。

如果在函数返回值类型前加上static那么他就是一个静态函数。静态函数不能访问非静态的成员变量,因为他没有this指针。但是可以访问静态的成员变量。

现在我们把print函数改成了静态函数,那我们需要对这个函数进行改造才能正常使用:

cpp 复制代码
#include<iostream>
using namespace std;
class A
{
public:
	A(int x)
		:t(x)
	{
	}
	static void print(const A& tt)
	{
		cout << tt.t <<" "<< b << endl;
	}
private:
	int t = 1;
	static int b;
};
int A::b = 100;
int main()
{
	A tt=10;
	tt.print(tt);
	
	return 0;
}

如果函数外打印静态成员的话,我们可以通过调用函数简介访问:

cpp 复制代码
static int getnum()
{
	return b;
}

5、友元

友元是一种声明,可以用过友元声明突破访问限定。

cpp 复制代码
#include<iostream>
using namespace std;

class A
{
public:
	A(int x)
		:t(x)
	{
	}
	friend int add(const A& a);
	
private:
	static int b;
	int t = 1;
};
int add(const A& a)
{
	return a.b + a.t;
}
int A::b = 100;
int main()
{
	A tt = 10;
	cout << add(tt) << endl;
	return 0;
}

例如上面这串代码,我们把add函数声明成友元,那么add函数就可以访问A里面的私有成员。

我们也可以把一个类定义成另一个类的友元:

cpp 复制代码
#include<iostream>
using namespace std;
class B
{
	friend class A;
private:
	int r = 5;
};
class A
{
public:
	A(int x)
		:t(x)
	{
	}
	void print(const B& R)
	{
		cout << R.r << endl;
	}
	
private:
	static int b;
	int t = 1;
};

int A::b = 100;
int main()
{
	A tt = 10;
	B bb;
	tt.print(bb);
	return 0;
}

我们把classA 声明为B的友元,就可以通过A突破访问限定符直接访问B的私有成员。

需要注意的是,友元类的关系是单向的,不具有交换性,比如A类是B类的友元,但是B类不是A类的友元。友元类关系不能传递,如果A是B的友元,B是C的友元,但是A不是C的友元。

我们一定要弄清谁是谁的友元,比如A是B的友元,那么就可以通过A访问B。顺序不能反。

另外就是上面两串代码中都是声明友元的那一部分放在上面(先定义)。

友元这个东西大家了解就好,因为友元会破坏封装,不推荐大量使用。

6、内部类

我们可以把一个类声明在另一个类里面 ,这样的声明下处在别的类内部的类就叫内部类

**内部类是外部类的友元。**如果我们把内部类声明为外部类的私有成员,那么这个内部类就可以成为外部类的私有类。

cpp 复制代码
class A
{
private:
     static int _k;
     int _h = 1;
public:
 class B // B默认就是A的友元 
 {
     public:
     void foo(const A& a)
     {
         cout << _k << endl; //OK
         cout << a._h << endl; //OK
     }
 
     int _b1;
     };
};
int main()
{
    A::B b;
    
}

7、匿名对象

用类型定义出来的对象叫匿名对象,匿名对象生命周期只有一行。

cpp 复制代码
#include<iostream>
using namespace std;
class B
{
	friend class A;
private:
	int r = 5;
};
class A
{
public:
	A(int x=8)
		:t(x)
	{
	}
	void print(const B& R)
	{
		cout << R.r << endl;
	}
	
private:
	static int b;
	int t = 1;
};

int A::b = 100;
int main()
{
	
	B bb;
	A().print(bb);
	return 0;
}

我们把上一段代码稍加改造就是匿名对象的使用场景。比如在上面的代码中我们就想调用一下print,那就用匿名对象调用就行了,没必要搞出来一个有名对象。

需要注意的是匿名对象的构造需要调用我们的构造函数,也就是说我们的写出来这个构造函数,而且构造函数参数里面要给缺省值,不然匿名对象无法创建会报错。

好了,今天的内容就分享到这,我们下期再见!

相关推荐
珊瑚里的鱼15 分钟前
第三讲 | C/C++内存管理完全手册
c语言·c++·笔记·程序人生·visualstudio·visual studio
网络安全指导员24 分钟前
威胁驱动的网络安全方法论
开发语言·学习·安全·web安全·php
柯ran31 分钟前
C++|面试准备二(常考)
开发语言·c++·面试
_GR1 小时前
2021年蓝桥杯第十二届C&C++大学B组真题及代码
c语言·数据结构·c++·算法·蓝桥杯
杨筱毅1 小时前
【性能优化点滴】odygrd/quill 中一个简单的标记位作用--降低 IO 次数
c++·性能优化
小宋要上岸2 小时前
[特殊字符] C++ 常见 Socket 错误与优化指南
c++·socket
冯渺岚2 小时前
Lua语言的配置管理
开发语言·后端·golang
Hardess-god2 小时前
STL性能优化方法
开发语言·c++·性能优化
Run1.2 小时前
深入解析C++面向对象三大特性:封装、继承与多态v
c++
打死不学Java代码2 小时前
Redis分布式锁如何实现——简单理解版
java·开发语言·redis·分布式·缓存·面试