【C++】类和对象终章
CSDN 2024-06-27 12:05:20 阅读 56
🔥博客主页: 小羊失眠啦.
🎥系列专栏:《C语言》 《数据结构》 《C++》 《Linux》 《Cpolar》
❤️感谢大家点赞👍收藏⭐评论✍️
文章目录
一、初始化列表1.1 初始化列表的形式1.2 初始化列表的注意事项
二、explicit关键字2.1 单参数构造函数2.2 多参数构造函数
三、static成员3.1 static成员的概念3.2 static成员的特性
四、友元4.1 概念4.2 友元函数4.3 友元类
五、内部类(不常用)5.1 内部类的性质
六、匿名对象七、关于拷贝对象时一些编译器优化
本章我们将继续加深对构造函数的学习。认识初始化列表
、explicit关键字
、static成员
、学习static成员的相关特性
、学习友元
的概念,包含友元函数
和友元类
;内部类
;匿名对象
以及关于拷贝构造
时一些编译器优化
的情况等。
一、初始化列表
在构造函数的学习中,我们知道可以通过构造函数对一个对象的成员变量赋初始值。我们以Date
类为例:
namespace Aron
{
class Date
{
public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void print()
{
cout << _year << "年" << _month << "月" << _day << "日" << endl;
}
private:
int _year;
int _month;
int _day;
};
}
int main()
{
Aron::Date d1(2024, 3, 16);
d1.print();
return 0;
}
虽然上述过程中通过构造函数的调用使得对象d1
确实有了一个初始值,但是我们并不能将该过程称为对对象中成员变量的初始化。
构造函数体中的语句只能将其称为赋初值,而不能称作初始化。因为初始化只能初始化一次,而构造函数体内可以多次赋值。
那么初始化在何时进行呢?这就要提一提本章的主角之一初始化列表
了。
1.1 初始化列表的形式
初始化列表:
以一个冒号开始,接着是一个以逗号分隔的数据成员列表,每个成员变量后面跟 一个放在括号中的初始值或表达式
。
示例:
namespace Aron
{
class Date
{
public:
Date(int year, int month, int day)
:_year(year)
,_month(month)
,_day(day)
{
/*_year = year;
_month = month;
_day = day;*/
}
void print()
{
cout << _year << "年" << _month << "月" << _day << "日" << endl;
}
private:
int _year;
int _month;
int _day;
};
}
int main()
{
Aron::Date d1(2024, 3, 16);
d1.print();
return 0;
}
1.2 初始化列表的注意事项
每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次
);
类中包含以下成员,必须放在初始化列表位置进行初始化:
引用成员变量
;
const成员变量
;
自定义类型成员(且该类没有默认构造函数时)
。
namespace Aron
{
class A
{
public:
A(int a)
:_a(a)
{ }
private:
int _a;
};
class B
{
public:
B(int a,int i,int b)
:_b(a)
,_i(i)
,_a(b)
{ }
private:
int& _b;
const int _i;
A _a;
};
}
尽量使用初始化列表初始化,因为不管你是否使用初始化列表,对于自定义类型成员变量,一定会先使用初始化列表初始化
。
注意事项
有的小伙伴会误认为给成员变量赋缺省值
就是初始化,切记只有在初始化列表中才进行初始化。
namespace Aron
{
class Date
{
public:
void print()
{
cout << _year << "年" << _month << "月" << _day << "日" << endl;
}
private:
int _year = 0;
int _month = 0;
int _day = 0;
};
}
成员变量在类中声明顺序就是其在初始化列表中的初始化顺序
,与其在初始化列表中的先后次序无关
。
示例1:
namespace Aron
{
class C
{
public:
C()
:a(10)
,b(a)
{ }
void print()
{
cout << "a=" << a << endl;
cout << "b=" << b << endl;
}
private:
int a;
int b;
};
}
int main()
{
Aron::C c;
c.print();
return 0;
}
示例2:
namespace Aron
{
class D
{
public:
D()
:b(10)
, a(b)
{ }
void print()
{
cout << "a=" << a << endl;
cout << "b=" << b << endl;
}
private:
int a;
int b;
};
}
int main()
{
Aron::D d;
d.print();
return 0;
}
示例2
中,出现该结果的原因是成员变量的声明顺序为先a后b
,则初始化顺序
也应该为先a后b
。a
在初始化时,使用b
的值,而此时b
还未初始化b
的值为随机值
,所以a
的值也为随机值
。接下来用10
初始化b
,所以b
的值为10
。
二、explicit关键字
构造函数不仅可以构造与初始化对象,对于单个参数
或者除第一个参数无默认值其余均有默认值
的构造函数,还具有类型转换
的作用。
什么是类型转换?
int a = 100;
double b = a;
如上所示,a
并不是直接赋值给b
,而是先进行了隐式类型转换
:
创建一个double
类型的临时变量
;将a
的值赋予临时变量
;将临时变量
的值赋予b
。
2.1 单参数构造函数
举例
定义一个Date
类,且该类的构造函数只有一个参数,我们称为单参数构造函数
:
namespace Aron
{
class Date
{
public:
Date(int year)
:_year(year)
{ }
private:
int _year=0;
};
}
Aron::Date d1(2024);
这是我们常见的创建一个对象的写法,此外还可以这样写:
Aron::Date d2 = 2024;
注意事项
此处这种写法是我们的赋值运算符重载
吗?
答案是,当然不是。赋值重载
实现的功能是用一个已存在的对象赋值给另外一个已存在的对象
。
那么为什么100
可以赋值给d1
呢?这是由于类型转换
的原因。具体实现过程如下:
用100
构造一个Date
类型的临时对象
;
再用临时对象
对d1
进行拷贝构造。
总结起来就是,该语句实现了2个过程——1个构造+1个拷贝构造
。
如何证明这一过程呢?
这就要用到explicit
关键字了。
explicit
修饰的构造函数禁止类型转换
。
示例
namespace Aron
{
class Date
{
public:
explicit Date(int year)
:_year(year)
{ }
private:
int _year = 0;
int _month = 0;
int _day = 0;
};
}
int main()
{
Aron::Date d = 100;
return 0;
}
2.2 多参数构造函数
多参数构造函数与单参数类似。C++98
中只支持除第一个参数外,其余参数都有默认值的情况。C++11
中引进了一种新的写法。
示例1(C++98)
namespace Aron
{
class Date
{
public:
//除第一个参数外,其余都有默认值
//加上explicit关键字会报错
Date(int year, int month=0, int day=0)
:_year(year),
_month(month),
_day(day)
{ }
private:
int _year;
int _month;
int _day;
};
}
int main()
{
Aron::Date d2 = 100;
return 0;
}
示例2(C++11)
namespace Aron
{
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()
{
Aron::Date d2 ={ 2024,3,16};//使用大括号
return 0;
}
三、static成员
3.1 static成员的概念
声明为static
的类成员称为类的静态成员
,用static
修饰的成员变量,称之为静态成员变量
;用static
修饰的成员函数,称之为静态成员函数
。静态成员变量一定要在类外进行初始化
。
namespace Aron
{
class A
{
public:
int getN()
{
return n;
}
private:
//类中进行声明
static int n;
};
//类外进行定义与初始化
int A::n = 0;
}
3.2 static成员的特性
静态成员变量必须在类外定义
,定义时不添加static
关键字,类中只是声明
;类静态成员即可用 类名::静态成员
或者 对象.静态成员
来访问;静态成员也是类的成员,受public、protected、private
访问限定符的限制;
示例1
namespace Aron
{
class A
{
public:
int getN()
{
return n;
}
static int m;
private:
//类中进行声明
static int n;
};
//类外进行定义与初始化
int A::n = 0;
int A::m = 0;
}
int main()
{
Aron::A a;
a.m += 10;
cout << a.getN() << endl;
cout << a.m << endl;
return 0;
}
静态成员函数没有隐藏的this
指针,不能访问任何非静态成员
;
示例2
namespace Aron::
{
class B
{
public:
static int getN()
{
//错误示例
//静态函数不能直接访问非静态成员
//_a++;
return n;//可以访问静态成员
}
private:
static int n;
int _a;
};
}
静态成员为所有类对象所共享
,不属于某个具体的对象,存放在静态区。
题目链接:求1+2+3+…+n。
这道题可以很好的帮我们理解第5条性质。
解题思路
利用static
成员被类的所有对象所共用的特性。声明static
成员变量n
,每创建一个对象就++n
。再声明一个static
成员变量sum
,求所有n
的和。
class sum
{
public:
sum()
{
_sum += _i;
_i++;
}
static int GetSum()
{
return _sum;
}
private:
static int _sum;
static int _i;
};
int sum::_sum = 0;
int sum::_i = 1;
class Solution
{
public:
int Sum_Solution(int n)
{
sum a[n];
return sum::GetSum();
}
};
四、友元
面向对象有三大特性——封装
、继承
、多态
。从学习C++至今,我们一直在谈封装的重要性。但是在某些特殊的情况下,有时需要突破封装的限制。
举例
之前我们通过实现日期类
来学习运算符重载
。其中实现操作符<<(流插入)、>>(流提取)
的重载时,我们遇到了难题——如果在类中
实现<<>>
重载,我们无法调换this
指针的位置,导致实现出来的重载<<
用起来怪怪的。如下:
namespace Aron
{
class Date
{
//...
//使用因为返回,为了适应连续输入或输出的情况
ostream& operator<<(ostream& out)
{
out << _year << "年" << _month << "月" << _day << "日" << endl;
return out;
}
istream& operator>>(istream& in)
{
in >>_year >>_month >>_day;
return in;
}
//...
}
}
void Test()
{
Aron::Date d1(2024, 3, 16);
d1 << cout;//有点奇怪
}
还记得当时我们是怎么解决的吗?答案是,可以将两个函数改为友元函数
。例如:
namespace Aron
{
class Date
{
//...
//声明友元函数
friend ostream& operator<<(ostream& out, const Date& d);
friend istream& operator>>(istream& in, Date& d);
//...
};
ostream& operator<<(ostream& out, const Date& d)
{
out << d._year << "年" << d._month << "月" << d._day << "日";
return out;
}
istream& operator>>(istream& in, Date& d)
{
in >> d._year >> d._month >> d._day;
return in;
}
}
上次我们只是浅浅的看了一下友元函数的使用。今天我们正式认识一下友元
。
4.1 概念
友元提供了一种突破封装的方式,有时提供了便利。但是友元会增加耦合度,破坏了封装
,所以友元不宜多用。
友元分为:友元函数
和友元类
。
4.2 友元函数
友元函数
可以直接访问类的私有成员,它是定义在类外部的普通函数
,不属于任何类
,但需要在类的内部声明
,声明时需要加friend
关键字。
友元函数的重要性质
友元函数有如下几条重要的性质:
友元函数可访问类的私有和保护成员,但它不是类的成员函数;友元函数不能用const
修饰;友元函数可以在类定义的任何地方
声明,不受类访问限定符限制
;一个函数可以是多个类的友元函数
;友元函数的调用与普通函数的调用原理相同;
4.3 友元类
友元类
的所有成员函数
都可以是另一个类的友元函数
,都可以访问另一个类中的非公有成员
。
namespace Aron
{
class Time
{
friend class Date;//声明日期类为时间类的友元类,则在日期类中可以直接发访问时间类
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 = 2023, int month = 4, int day = 9)
: _year(year)
, _month(month)
, _day(day)
{ }
void SetTime(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
类的私有成员变量,但想在Time
类中访问Date
类中私有的成员变量则不行。
友元关系不能传递
;
如果C是B的友元, B是A的友元,则不能说明C是A的友元。
友元关系不能继承
(先不做解释);
五、内部类(不常用)
如果一个类定义在另一个类的内部,这个类就叫做内部类
。内部类是一个独立的类,它不属于外部类,更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
内部类有一个重要的性质——内部类天生就是外部类的友元
。参照友元类的定义,内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
5.1 内部类的性质
内部类可以定义在外部类的public、protected、private
下。注意内部类可以直接访问外部类中的static
成员,不需要外部类的对象或类名
。sizeof(外部类)=外部类
,说明外部类和内部类在空间上
没有任何关系。
六、匿名对象
匿名对象
,顾名思义,该对象没有名字就叫匿名对象。匿名对象重要的性质:
匿名对象的生命周期只在定义它的那一行
;
示例
namespace Aron
{
class A
{
public:
class B // B天生就是A的友元
{
public:
void print(const A& a)
{
cout << k << endl;
cout << a.n << endl;
}
};
private:
//声明static成员
static int k;
int n = 0;
};
//初始化static成员
int A::k = 1;
}
int main()
{
Aron::A::B b;//定义B类对象
Aron::A a;
b.print(a);
return 0;
}
匿名对象看似鸡肋,但在某些场合下非常适用。比如,我们只想拿到类内部的某个成员的值,或只是想用一下类中的某个成员函数,为了一件简单的事而专门定义一个对象再销毁显得有点多此一举,那么就可以使用匿名对象
。
namespace Aron
{
class solution
{
public:
int Sum_Solution(int n)
{
int sum = 0;
for (int i = 1; i <= n; i++)
{
sum += i;
}
return sum;
}
};
}
int main()
{
//匿名对象的使用场景
cout << Aron::solution().Sum_Solution(100) << endl;
return 0;
}
七、关于拷贝对象时一些编译器优化
对于有些场景下,若出现拷贝构造与构造同时出现的情况,编译器可能省略中间的拷贝构造,转化为直接构造。(此种情况取决于不同编译器不同的实现方法)
示例
上面我们谈到类型转换
。这是典型的1个拷贝构造+1个构造优化为——>直接构造
。
namespace Aron
{
class Date
{
public:
Date(int year)
:_year(year)
{ }
private:
int _year=0;
};
}
void Test()
{
//1个拷贝构造+1个构造优化为——>直接构造
Aron::Date d = 2024;
}
其它情况
class A
{
public:
A(int a = 0)
:_a(a)
{ }
private:
int _a;
};
void func1(A aa)
{
}
void func2(const A& aa)
{
}
A func3()
{
A aa;
return aa;
}
A func4()
{
return A();
}
int main()
{
A aa1 = 1; // 构造+拷贝构造 ——> 优化为直接构造
func1(aa1); // 无优化
func1(2); // 构造+拷贝构造 ——> 优化为直接构造
func1(A(3)); // 构造+拷贝构造——> 优化为直接构造
func2(aa1); // 无优化
func2(A(3)); // 无优化
A aa2 = func3(); // 拷贝构造+拷贝构造 -- 优化为一个拷贝构造
A aa3;
aa3 = func3(); // 不能优化
func4(); // 构造+拷贝构造 -- 优化为直接构造
A aa4 = func4(); // 构造+拷贝构造+拷贝构造 -- 优化为直接构造
return 0;
}
声明
本文内容仅代表作者观点,或转载于其他网站,本站不以此文作为商业用途
如有涉及侵权,请联系本站进行删除
转载本站原创文章,请注明来源及作者。