手机ps软件如何做ppt下载网站,公司网站建设总结,论文答辩免费ppt模板下载,微信开放平台创建移动应用#x1f525;博客主页#xff1a; 小羊失眠啦. #x1f3a5;系列专栏#xff1a;《C语言》 《数据结构》 《C》 《Linux》 《Cpolar》 ❤️感谢大家点赞#x1f44d;收藏⭐评论✍️ 文章目录 一、初始化列表1.1 初始化列表的形式1.2 初始化列表的注意事项 二、explicit关键… 博客主页 小羊失眠啦. 系列专栏《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 _year0;};
}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 多参数构造函数
多参数构造函数与单参数类似。C98中只支持除第一个参数外其余参数都有默认值的情况。C11中引进了一种新的写法。
示例1(C98)
namespace Aron
{class Date{public://除第一个参数外其余都有默认值//加上explicit关键字会报错Date(int year, int month0, int day0):_year(year),_month(month),_day(day){}private:int _year;int _month;int _day;};
}int main()
{Aron::Date d2 100;return 0;
}
示例2(C11)
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;};
}静态成员为所有类对象所共享不属于某个具体的对象存放在静态区。
题目链接求123…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 _year0;};
}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;
}
