一、构造函数补充
1.1 初始化列表
创建对象时,编译器通过调用构造函数,给对象中各个成员变量一个合适的初始值。 但是不能将其称作为类对象成员的初始化,构造函数体中的语句只能将其称作为赋初值,而不能称作初始化。因为初始化只能初始化一次,而构造函数体内可以多次赋值。所以初始化,就需要初始化列表。class Date { public: Date(int year, int month, int day) :_year(year)//初始化列表里定义 , _month(month) , _day(day) { } private: //这里是声明,没定义 int _year; int _month; int _day; };
初始化列表: 以一个冒号开始,接着是一个以逗号分隔的数据成员列表,每个"成员变量"后面跟一个放在括号中的初始值或表达式。
需要注意的点:
1.初始化列表可以认为就是对象的成员变量定义的地方,每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2.当类中包含以下成员,必须放在初始化列表位置进行初始化:
-
引用成员变量
-
const成员变量
-
自定义类型成员( 该类没有默认构造函数 )
class B
{
public:
//没有默认构造函数
B(int x)
{}
private:
int x;
};
class A
{
public:
A(int a, int b, int c)
:_a(a)
, _b(b)
, _c(c)
{}
private:
//可以定义时初始化
//也可以定义时不初始化,后面再赋值修改
int t;
//只能在定义时初始化
B _a;//没有默认构造函数的自定义类型成员
const int _b;//const修饰的成员变量
int& _c;//引用成员变量
};
3.尽量使用初始化列表初始化
4.成员变量在类中声明次序就是其在初始化列表中的初始化顺序,与其在初始化列表中的先后次序无关
class A
{
public:
A(int a, int b, int c)
:_c(c)//初始化顺序与这里无关
,_b(b)
,_a(a)
{}
private:
//初始化列表初始化顺序,_a -> _b -> _c
int _a;
int _b;
int _c;
};
1.2 explicit关键字
构造函数不仅可以构造与初始化对象,对于单个参数的构造函数,还具有类型转换的作用,需要使用explicit关键字。
class Date
{
public:
/* Date(int year)
:_year(year)
{}*/
explicit Date(int year)
:_year(year)
{}
private:
int _year;
};
int main()
{
Date d1(2022);
//d1 = 2021; 这种类型转换的赋值将不被允许
}
用explicit修饰构造函数,将会禁止单参构造函数的隐式转换。
二、static成员
2.1 特性
用static修饰的成员变量,称之为静态成员变量;用static修饰的成员函数,称之为静态成员函数。
计算创造出多少个类对象:
class A
{
public:
//默认构造函数
A()
{
_count1++;
}
//拷贝构造函数
A(const A& t)
{
_count2++;
}
//静态成员函数,static函数没有this指针
//获得默认构造函数调用的次数
static int GetACount1()
{
//不能访问非静态成员,因为没有this指针
//_a = 0; 不能访问,没有this指针,不知道是谁的_a
return _count1;
}
//获得拷贝构造函数调用的次数
static int GetACount2()
{
return _count2;
}
private:
int _a;
//静态成员变量
static int _count1;
static int _count2;
};
//静态的成员变量一定要在类外进行初始化
int A::_count1 = 0;
int A::_count2 = 0;
int main()
{
A a1, a2;
A a3(a1);
//因为没有this指针,
//而且静态成员变量属于整个类,类的所有对象都可以用
//所以下面写法效果都一样
//cout << d1.GetACount1() << endl;
//cout << d2.GetACount1() << endl;
cout << A::GetACount1() << endl;
//cout << d1.GetACount2() << endl;
//cout << d2.GetACount2() << endl;
cout << A::GetACount2() << endl;
return 0;
}
静态的成员变量一定要在类外进行初始化!!!!!
特性:
静态成员为所有类对象所共享,不属于某个具体的实例 静态成员变量必须在类外定义,定义时不添加static关键字 类静态成员即可用类名::静态成员或者对象.静态成员来访问 静态成员函数没有隐藏的this指针,不能访问任何非静态成员 静态成员和类的普通成员一样,也有public、protected、private3种访问级别,也可以具有返回值
三、C++11 的成员初始化新方式
给声明的非静态成员变量缺省值,但不是初始化
class A
{
public:
private:
//非静态成员变量,可以在成员声明时给缺省值。
int _a = 10;
int* _b = (int*)malloc(sizeof(int)*6);
//静态变量不行
static int _c;
};
四、友元
4.1 友元函数
友元函数可以直接访问类的私有成员,它是定义在 类外部 的普通函数, 不属于任何类 ,但需要在类的内部声明,声明时需要加friend关键字。
class Date
{
public:
//友元函数
friend ostream& operator<<(ostream& _cout, const Date& d);
friend istream& operator>>(istream& _cin, Date& d);
Date(int year = 0, int month = 0, int day = 0)
:_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 >> d._month >> d._day;
return in;
}
int main()
{
Date d(2022, 5, 23);
cin >> d;
cout << d << endl;
return 0;
}
需要注意的是:
友元函数可访问类的私有和保护成员,但不是类的成员函数 友元函数不能用const修饰 友元函数可以在类定义的任何地方声明,不受类访问限定符限制 一个函数可以是多个类的友元函数 友元函数的调用与普通函数的调用和原理相同
4.2 友元类
友元类的所有成员函数都可以是另一个类的友元函数,都可以访问另一个类中的非公有成员。
class Date;//前置声明
class Time
{
//声明Date类是Time类的友元类
friend class Date;
public:
Time(int hour = 1, int minute = 1, int second = 1)
:_hour(hour)
, _minute(minute)
, _second(second)
{}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
public:
Date(int year = 0,int month = 0,int day = 0)
:_year(year)
,_month(month)
,_day(day)
{}
void Init(int hour, int minute, int second)
{
//可以直接访问Time类私有的成员变量
t._hour = hour;
t._minute = minute;
t._second = second;
}
private:
int _year;
int _month;
int _day;
Time t;
};
特性:
1.友元关系是单向的,不具有交换性。
如上,在Time类中,声明Date类是Time类的友元类,则在Date类中可以直接访问Time类的私有成员变量,但是反过来Time类中就不能访问Date类私有成员变量。
2.元关系不能友传递例如A是B的友元类,B是C的友元类,但A不是C的友元类。
五、内部类
如果一个类定义在另一个类的内部,这个内部类就叫做内部类。这个内部类是一个独立的类,它不属于外部类,更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。
class A
{
public:
//内部类
class B
{
public:
void Print(const A& a)
{
//B类天生就是A类的友元,可以直接访问A类的私有成员变量
//但是A类不是B类的友元
cout << a._a << endl;
cout << a._b << endl;
}
};
private:
int _a = 1;
int _b = 1;
};
int main()
{
A::B a;
A b;
a.Print(b);
return 0;
}
特性:
- 内部类可以定义在外部类的public、protected、private。
- 注意内部类可以直接访问外部类中的static、枚举成员,不需要外部类的对象/类名。
- sizeof(外部类)=外部类,和内部类没有任何关系,如上,sizeof(A)即计算A类的大小,而B类不包括在其中,与B类无关