@TOC
1. 初始化列表
1. 概念
- 以一个冒号开始，接着是一个以逗号分隔的1数据成员列表，每个成员变量后面跟一个放在括号的初始值或表达式，即成员变量定义的地方
2. 用法
#include<iostream>
using namespace std;
class date
{
public:
private:
int _year;//声明
int _month;
int _day;
//const int x;//存在会报错
};
int main()
{
date d(2023, 2, 10);//定义
//const int a=0;
return 0;
}
- const修饰的变量必须在定义时初始化，默认构造函数对内置类型不处理，对自定义类型调用它的默认构造函数，const int为内置类型，不会处理
- 正常来说，在date类实例化生成对象d时，是对象整体的定义，即对每个成员变量定义
- 但是像const修饰的变量必须在定义时初始化怎么办？
所以就有了初始化列表 - 那个对象调用构造函数，初始化列表是它所有成员变量定义的位置
- 不管是否显示在初始化列表写，编译器每个变量都会在初始化列表定义初始化
成员变量出现随机值
#include<iostream>
using namespace std;
class date
{
public:
date()
:a(1)//使用初始化列表进行定义
,c(2)
{
}
private:
int a=2;//声明
int b=1;
int q;
};
int main()
{
date d;
return 0;
}
- 可以在类中的成员变量声明处加入缺省值，若该变量在初始化列表中被定义，则该变量为被定义后的值，若在初始化列表中没有被定义，则该变量输出缺省值a=1,b=1,q=随机值不管是否在初始化列表中写入全部的成员变量，都会全部调用一次例如 a，b，两者都有缺省值，在初始化列表中a被定义为1，则输出a=1，
b在初始化列表没有被定义,所以输出缺省值，b=1
q作为内置类型int，没有缺省值，也没有初始化列表定义，所以q为随机值
3.注意事项
1.每个成员变量只能在初始化列表出现一次(初始化只能初始化一次） 2.类中包含 引用成员变量 const成员变量 自定义类型成员(没有默认构造函数) ，必须放在初始化列表位置进行初始化，(剩下的成员在初始化列表写不写都行，但是上述这三类就必须在列表写)
#include<iostream>
using namespace std;
class A
{
public:
//A() //不传参数为默认构造函数
// :_a(1)//如果自定义类型的构造函数为这个 就不用在初始化列表初始化
//{
//}
A(int d)
:_a(d)
{
}
private:
int _a;
};
class date
{
public:
date()
:a(2)
,b(1)
,c(a)
,aa(5)
{
}
private:
int a = 1;//内置类型int
const int b = 2;//const
int& c;//引用
A aa;//自定义类型并且没有默认构造函数
};
int main()
{
//a=2 b=1 c=2 aa._a=5
date d;
return 0;
}
- 因为构造函数对于内置类型不处理，对于自定义类型调用它的默认构造函数，
所以定义时必须初始化的包含自定义类型(不带默认构造函数)
3.成员变量在类中的声明次序就是在初始化列表中的初始化顺序，在初始化列表中的先后次序无关
例题
class A
{
public:
A(int a)
:_a1(a) //1
, _a2(_a1)
//随机值
{}
void Print() {
cout << _a1 << " " << _a2 << endl;
}
private:
int _a2;
int _a1;
};
int main() {
A aa(1);
aa.Print();// 1随机值
}
由于是先声明 _a2，再声明_a1，所以在初始化列表中先调用_a2，由于刚开始_a1为随机值 ，所以_a2为随机值，再调用_a1，将a的值1传给_a1,所以_a1=1，最终是 1 随机值
2.explicit关键字
1.单参数的构造函数 (C++98) ，支持类型转换
#include<iostream>
using namespace std;
class A
{
public:
A(int n)//构造函数
:_a(n)
{
cout << "A(int n)" << endl;
}
A(A& d)//拷贝构造
{
cout << "A(A&d)" << endl;
}
private:
int _a;
};
int main()
{
A a(1);//构造函数 构造
A b = 1;//隐式类型转换 构造+拷贝构造->优化 构造
//int i = 1;
//double d = i;//隐式类型转换
return 0;
}
- 是int对于double的类型转换，产生一个类型为double的临时变量，再将临时变量传给d
内置类型int对于自定义类型A的类型转换,通过构造产生一个类型为A的临时变量，再通过拷贝构造传给b
但是程序运行发现，只进行了两次构造，并没有拷贝构造，
说明C++对于自定义类型产生临时变量，编译器会做优化
1. 验证临时变量的存在
#include<iostream>
using namespace std;
class A
{
public:
A(int n)
:_a(n)
{
cout << "A(int n)" << endl;
}
A(A& d)
{
cout << "A(A&d)" << endl;
}
private:
int _a;
};
int main()
{
//A& ret = 1;//错误
const A& ret = 1;
return 0;
}
- A&ret=1会报错，而const A&ret=1却可以
- 因为通过构造生成一个类型为A的临时变量，而临时变量具有常性，ret为临时变量的别名， 将临时变量传过去，由const A类型到A类型会造成权限放大，所以要加const修饰ret，说明临时变量的存在
2.关键字explicit的使用
#include<iostream>
using namespace std;
class A
{
public:
explicit A(int n)//构造
:_a(n)
{
cout << "A(int n)" << endl;
}
A(A& d)//拷贝构造
{
cout << "A(A&d)" << endl;
}
private:
int _a;
};
int main()
{
A a(1);//构造函数
A b = 1;//隐式类型转换 加入关键字explicit会报错
return 0;
}
- 为了防止隐式类型转换发生，所以在构造函数前加入关键字explicit
2.多参数构造函数(C++11) 使用{ }支持类型转换
#include<iostream>
using namespace std;
class A
{
public:
explicit A(int n,int a)
:_a(n)
,_b(a)
{
cout << "A(int n,int a)" << endl;
}
A(A& d)
{
cout << "A(A&d)" << endl;
}
private:
int _a;
int _b;
};
int main()
{
//多参数的构造函数
A a(1, 2);
A a = { 1,2 };//隐式类型转换 加入关键字explicit就会报错
return 0;
}
同样在多参数的构造函数中，使用关键字explicit也可以防止隐式类型转换的发生
3.友元
1.友元函数
1.概念
为了在类外面使用类中私有的成员变量，友元提供了突破封装的方式，<font color=red>在类中加入 friend+函数定义 但是这样会增加耦合度，所以不建议多用
2.实现cout功能
#include<iostream>
using namespace std;
class date
{
public:
date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void operator<<(ostream& out)
{
out << _year << "-" << _month <<"-"<< _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
date d1(2023, 2, 10);
//cout << d1; 我们想实现成的
d1 << cout; //实际在类中生成的
return 0;
}
在类中，左操作数作为隐藏的this指针，指针类型为date*，
cout<<d1等价于cout.operator<<(d1)，若为cout<<d1，就会将cout作为左操作数，
cout是标准库std命名里面一个ostream类型的全局对象，与this指针类型不符，所以在类中只能写成 d1<<cout
虽然输出了日期，但是输出方式不是我们想要的结果，我们想要使用 cout<<d1
#include<iostream>
using namespace std;
class date
{
public:
friend void operator<<(ostream& out, date& d);//firend+函数定义 说明函数为类的友元函数
date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
void operator<<(ostream& out, date&d)
{
out << d._year << "-" << d._month << "-" << d._day << endl;
}
int main()
{
date d1(2023, 2, 10);
cout << d1;
return 0;
}
所以设置在类外面，这样就会把两个操作数都传过来当参数，没有this指针的问题， 同时 在类中 friend+函数定义，说明该函数是date类的友元函数，该函数不受访问限定符的限制
3.实现cin的功能
#include<iostream>
using namespace std;
class date
{
public:
friend void operator>>(istream& in, date& d);
private:
int _year;
int _month;
int _day;
};
void operator>>(istream& in, date& d)
{
in >> d._year >> d._month >> d._day;
}
int main()
{
date d1;
cin >> d1;
return 0;
}
<font color=blue>cin是标准库std命名里面一个istream类型的全局对象，
在类外面定义需要在date类中加入friend+函数定义，使函数成为类的友元函数，该函数不受访问限定符的限制</font>
4.说明
1.友元函数可以访问类的私有和保护成员，但是不是类的成员函数
2.友元函数不能用const修饰
3.友元函数可以在类的定义的任何地方声明，不受访问限定符限制
2.友元类
class Time
{
public:
friend class date;//日期类是时间类的友元
Time(int hours=0,int minute=0,int second=0)
{
_hour = hours;
_minute = minute;
_second = second;
}
private:
int _hour;
int _minute;
int _second;
};
class date
{
public:
date(int year=1, int month=1, int day=1)
{
_year = year;
_month = month;
_day = day;
}
void print(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.友元是单向的，不具有交换性 2.友元不能传递，如果C是B的友元，B是A的友元，不能说明C是A的友元
4.static 成员
1.概念
用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化(后面会解释)
2.实现一个类，计算类中创建了多少个对象
#include<iostream>
using namespace std;
class A
{
public:
A(int a=0)
{
n++;
}
A(A& d)
{
n++;
}
static int getn()//静态成员函数没有this指针
{
return n;
}
private:
//不属于某个对象，属于所有对象，属于整个类
static int n;//静态成员变量声明
};
int A::n = 0;//静态成员变量定义
int main()
{
A a;//构造
A b;//构造
A c(a);//拷贝构造
A d(b);//拷贝构造
cout << A::getn() << endl;//4
return 0;
}
静态成员变量声明时可以有缺省值吗？ 不可以，缺省值是在初始化列表处进行初始化，而初始化列表是初始化非静态成员(属于对象的成员)，而static修饰的成员属于共有的
3. 特性
- 1.静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
static修饰的成员变量 不属于某个对象，属于所有对象，属于整个类 - 2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
静态成员变量属于共有的，不能在初始化列表初始化，所以只能在类外初始化 - 3.静态成员函数没有隐藏的this指针，不能访问任何非静态成员<font color=red>4.静态成员也是类的成员，受public、protected、privae 访问限定符的限制
若在类外直接使用，对象调用处于类中私有的成员变量
5. 匿名对象
#include<iostream>
using namespace std;
class date
{
public:
date()
{
cout << "date()" << endl;
}
~date()
{
cout << "~date()" << endl;
}
void print()
{
cout << "print" << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
date();//匿名对象，生命周期只在第一行
date().print();
return 0;
}
匿名对象特点为不用取名字，由于它的生命周期只有这一行，在下一行会自动调用析构函数 同时可以不用创建对象来调用类中的函数，直接使用匿名对象.函数
匿名对象的返回
#include<iostream>
using namespace std;
class date
{
public:
void print()
{
cout << "print" << endl;
}
int sum(int n)
{
return n;
}
private:
int _year;
int _month;
int _day;
};
class A
{
public:
A(int n)
{
}
};
A fun()
{
int n = 0;
cin >> n;
int ret = date().sum(n);
//A d=ret; //正常来说创建一个对象接收 ，在返回对象
//return d;
return A(ret);//直接返回匿名对象
}
int main()
{
date();//匿名对象，生命周期只在第一行
return 0;
}
- 正常来说，需要创建一个A类型对象通过隐式类型转换接收ret，在返回对象 或者直接返回匿名对象 A(ret)
6.内部类
如果在一个类定义在另一个类的内部，这个类就叫做内部类
#include<iostream>
using namespace std;
class A
{
private:
int n;
public:
class B
{
public:
void print()
{
}
private:
int b;
};
};
int main()
{
cout << sizeof(A) << endl;//4
A::B b;//必须通过A类，然后才能访问B类创建对象b
return 0;
}
当我们计算A类的大小时发现为4，说明只计算了A类自身私有的成员变量n，并没有算上内部类B的成员变量 说明内部类B跟A是独立的，受A的类域限制
内部类是外部类的友元
class A
{
public:
class B//B是A的友元
{
public:
void print(A&d)
{
//在B类中可以调用A的私有成员变量
cout << d.n << endl;
}
private:
int b;
};
private:
int n;
};
int main()
{
cout << sizeof(A) << endl;//4
return 0;
}
- 可以在内部类B中调用外部类A的私有成员变量n
7.拷贝对象时的一些编译器优化
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
private:
int _a;
};
int main()
{
A aa=1;//构造函数+拷贝构造 优化为 构造
return 0;
}
单参数的构造函数，编译器把构造函数+拷贝构造优化为构造(上面的explicit关键字做出详细解释)
1.传值传参
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
private:
int _a;
};
void func(A a)
{
}
int main()
{
func(2);//构造+拷贝构造 优化-> 构造
return 0;
}
- 这里的传值传参func(2)可以看作是在一个表达式中，将内置类型int的2传给 自定义类型A的a，发生隐式类型转换
- 编译器 把构造函数+拷贝构造 优化为构造
2.引用传参
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
private:
int _a;
};
void func2(const A& a)//必须使用const修饰，临时变量具有常性
{
}
int main()
{
func2(2);//无优化
return 0;
}
- A&a=2 这样写会报错，而加上const 修饰变成 const A&a=2就通过了
说明存在临时变量，而临时变量具有常性，a作为临时变量的别名，要加上const保持权限一致 - 无优化，必须存在临时变量
3.传值返回
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
A(const A& aa)
:_a(aa._a)
{
cout << "A(const A& aa)" << endl;
}
private:
int _a;
};
A func3()
{
A a;//构造
return a;
//拷贝构造
}
int main()
{
func3();//构造+拷贝构造 无优化
return 0;
}
return a返回时，因为传值返回，所以会拷贝构造一个临时变量 不会优化，因为 A a与 return a不在一个表达式中
#include<iostream>
using namespace std;
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
A(const A& aa)
:_a(aa._a)
{
cout << "A(const A& aa)" << endl;
}
private:
int _a;
};
A func3()
{
A a;
return a;
}
int main()
{
A b=func3();
return 0;
}
- retun a返回通过拷贝构造生成一个临时变量，再把临时比变量拷贝构传给b 正常来说是进行 一次构造、两次拷贝构造
两次拷贝构造属于一个连续的步骤，所以编译器进行了优化，
最终只进行了 一次构造、一次拷贝构造
4.匿名对象的传值返回
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
A(const A& aa)
:_a(aa._a)
{
cout << "A(const A& aa)" << endl;
}
private:
int _a;
};
A func4()
{
return A();
}
int main()
{
A b=func4();//构造+拷贝构造+拷贝构造 优化成 构造
return 0;
}
因为整体都在一个表达式中，所以在构造匿名对象，拷贝构造生成一个临时变量，在用临时变量拷贝构造传给b这个过程中都会被编译器优化，构造+拷贝构造+拷贝构造 优化成 构造
5.两种习惯之间的差异
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
A(const A& aa)
:_a(aa._a)
{
cout << "A(const A& aa)" << endl;
}
A& operator=(const A& aa)
{
cout << "A& operator=(const A& aa)" << endl;
if (this != &aa)
{
_a = aa._a;
}
return *this;
}
private:
int _a;
};
A func4()
{
A a;
return a;
}
int main()
{
A c = func4();//构造+拷贝构造+拷贝构造 优化->构造+拷贝构造
cout << "---------------" << endl;
A b;//构造
b = func4();//构造+拷贝构造+赋值 无优化
return 0;
}
横线上面直接用一个表达式调用函数，调用函数，A a 构造一次，return a,拷贝构造生成一个临时变量，再用临时变量拷贝构造b，由于 两次拷贝构造是连续步骤，所以优化成一次拷贝构造
即 构造+拷贝构造
而横线下面先是在主函数中 A b构造一次 ，调用func4函数， A a构造一次 ，return a拷贝构造生成一个临时变量，由于此时的b已经被定义雇过了，所以此时 属于将临时变量赋值给 b ，进行运算符重载
所以 <font color=red>无优化 即 构造+构造+拷贝构造+赋值
