构造函数
初始化列表
以一个冒号开始,然后是一个以逗号分隔的数据成员列表,每个“成员变量”后面跟一个放在括号中的初始值或表达式
比如:
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成员变量
3.自定义类型成员且没有默认构造函数
所以我们就尽量在初始化列表初始化,因为自定义类型成员变量他一定会会在初始化列表初始化。
还有需要注意的是成员变量的声明次序就是初始化的次序,和在列表的顺序无关。
explicit关键字
构造函数不仅可以构造和初始化对象,对于单个参数或者第一个参数无默认值其余均有默认值的构造函数,还具有类型转换的作用。
explicit修饰构造函数 作用是禁止类型转换。
static成员
声明为static的类成员称之为类的静态成员,用static修饰的成员变量,称之为静态成员变量;用static修饰的成员函数,称之为静态成员函数。静态成员变量一定要在类外进行初始化
特性
1.静态成员为所有类对象共享,不属于某个具体的对象,存放在静态区
2.静态成员变量必须在类外定义,定义时不加static关键字,类中只是声明
3.类静态成员可以用 类名::静态成员 也可以 对象.静态成员 来访问
4.静态成员函数没有隐藏的this指针,不能访问任何非静态成员
5.静态成员也是类成员,受public 、protected、private访问限定符的限制
友元
友元函数可以直接访问类的私有成员,他是定义在类外的普通函数,不属于任何类,但需要在类的内部声明,声明时需要加friend关键字。
class Date {
friend ostream& operator<<(ostream& _cout, const Date& d);
friend istream& operator>>(istream& _cin, Date& d);
public:
Date(int year = 1900, int month = 1, int day = 1)
: _year(year)
, _month(month)
, _day(day)
{}
private:
int _year;
int _month;
int _day; };
ostream& operator<<(ostream& _cout, const Date& d)
{
_cout << d._year << "-" << d._month << "-" << d._day;
return _cout;
}
istream& operator>>(istream& _cin, Date& d)
{
_cin >> d._year;
_cin >> d._month;
_cin >> d._day;
return _cin;
}
int main() {
Date d;
cin >> d;
cout << d << endl;
return 0;
}
友元函数特性
友元函数可访问类的私有和保护成员,但不是类的成员函数
友元函数不能用const修饰
友元函数可以再类定义的任何地方声明,不受类访问限定符的限制
一个函数可以是多个类的友元函数
友元函数的调用与普通函数的调用原理相同
友元类
友元类的所有成员函数都可以是另一个类的友元函数,都可以访问另一个类的非公有成员。
友元关系是单向的,不具有交换性。
友元关系不能传递
C是B的友元,B是A的友元,不能说明C是A的友元
友元关系不能继承
内部类
一个类定义在另一个类的内部,这个类就叫内部类。他是独立的一个类,不属于外部类,不能通过外部类的对象访问内部类的成员,外部类对内部类没有任何优越的访问权限。
但是:内部类就是外部类的友元类。内部类可以通过外部类的对象参数访问外部类的所有成员,但外部类不是内部类的友元
sizeof(外部类)=外部类,和内部类没关系。
匿名对象
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
~A() {
cout << "~A()" << endl;
}
private:
int _a;
};
class Solution {
public:
int Sum_Solution(int n) {
//...
return n; }
};
int main() {
A aa1;
// 不能这么定义对象,因为编译器无法识别下面是一个函数声明,还是对象定义
//A aa1();
// 但是我们可以这么定义匿名对象,匿名对象的特点不用取名字,
// 但是他的生命周期只有这一行,我们可以看到下一行他就会自动调用析构函数 A();
A aa2(2);
// 匿名对象在这样场景下就很好用,当然还有一些其他使用场景,这个我们以后遇到了再说
Solution().Sum_Solution(10);
return 0;
}
拷贝对象时的一些编译器优化
在传参和传返回值的过程中,一般编译器会做一些优化,减少对对象的拷贝,这个在一些场景下很有用。
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;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
void f1(A aa)
{}
A f2()
{
A aa;
return aa;
}
int main()
{
// 传值传参
A aa1; f1(aa1);
cout << endl;
// 传值返回 f2();
cout << endl;
// 隐式类型,连续构造+拷贝构造->优化为直接构造
f1(1);
// 一个表达式中,连续构造+拷贝构造->优化为一个构造
f1(A(2));
cout << endl;
// 一个表达式中,连续拷贝构造+拷贝构造->优化一个拷贝构造
A aa2 = f2();
cout << endl;
// 一个表达式中,连续拷贝构造+赋值重载->无法优化
aa1 = f2();
cout << endl;
return 0;
}
再次理解类和对象
类是对某一类实体(对象)来进行描述的,描述该对象具有那些属性,那些方法,描述完成后就形成了一种新的自定义类型,用该自定义类型就可以实例化具体的对象。