类和对象（下）

类和对象（下）

构造函数初始化列表

在类内部如果有自定义成员时，且自定义成员不具有默认构造函数时，就需要显示写构造函数并将参数传给自定义成员的构造函数，就需要初始化列表来传参。

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。(在函数体与函数声明之间)

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. 类中包含以下成员，必须放在初始化列表位置进行初始化(因为函数体内不能显式调用）： 1)引用成员变量 2)const成员变量 3)自定义类型成员(且该类没有默认构造函数时)

3. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化，再走函数体。

所以

实践中尽可能使用初始化列表初始化，不方便再使用函数体初始化

private:
 int _year=1;//此时再去理解给默认值的补丁，其实就是给初始化列表初始化内置类型的
 int _month=1;
 int _day=1;

重点:

1.成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

2.隐式类型转换，当构造函数只需一个参数时，可以用数字给新对象初始化。其本质上是先进行通过构造函数初始化一个临时变量，再通过拷贝构造函数初始化对象。但是这种现象在编译器中会直接优化为构造。

A & a=1;//权限放大
const A & a=1;//a实际上引用了临时变量，且具有常性

上面研究了单参数的情况，多参数是否也可以以这种方式初始化对象呢？

class A
{
public:
A (int a1,int a2)
:_a1(a1),_a2(a2)
{}
private:
int _a1;
int _a2;
};
int main()
{
A a(1,2);
A aa={1,2};//c++11支持
A aaa{1,2};//新版本支持
return 0;
}

同理：在类中成员变量声明处我们也可以以这样的方式给默认值

class B
{
public:
B(){}
private:
A a={1,2};
}

静态成员变量

静态成员变量存在哪里？静态区，即不影响对象大小

静态成员变量在声明处可以给缺省值吗？缺省值是给初始化列表的，

而静态成员变量不存在类中，不走初始化列表。

特点：

1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区

2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明

3. 类静态成员即可用 类名 ::静态成员 或者 对象.静态成员 来访问

4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员

5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

class A
{
public:
static int a;//声明和定义分离
}
int A::a= 1;

但是在类外该如何调用静态成员变量呢？

如果是公有就可以直接调用，如:cout<<A::a<<endl

静态成员函数

静态修饰变量影响生命周期，修饰函数会影响链接属性，修饰成员函数没有this指针。

这意味着静态成员函数只能访问静态成员，如cout<<A::get_a<<endl;

非静态成员函数时可以访问静态函数

class A
{
public:
static int get_a(){return a;}
private:
static int a;//声明和定义分离
}
int A::a= 1;

友元

友元是单向的，且不能多用，会破坏封装

友元函数

友元函数可访问类的私有和保护成员，但不是类的成员函数

友元函数不能用const修饰//const修饰的是this，而友元函数中

友元函数可以在类定义的任何地方声明，不受类访问限定符限制

一个函数可以是多个类的友元函数

友元函数的调用与普通函数的调用原理相同

友元类

声明位置可以在类的任意位置，但建议在上面

class date
{
friend class time;
public:
private:
};

内部类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。平行关系，外部类对内部类没有任何优越的访问权限。

注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

而且不能直接定义内部类（受类域限制）

特性：

1. 内部类可以定义在外部类的public、protected、private都是可以的。

2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。

3. sizeof(外部类)=外部类，和内部类没有任何关系。

class solution//1+2+...+n
{
class sum
{
public:
sum
{
_i+=_per;
++per;
}
private:
static int _per;
static int _i;
}
public:
getsum(int n)
{
sum arr[n];
return _i;
}
}
int sum::_per=1;
int sum::_i=0;

匿名对象

没有名字的对象。生命周期就在当前行

solution s;
s.getsum(10);//需要两行
​
solution().getsum(10);//一行

拷贝对象时的优化

连续的构造和拷贝构造优化为直接构造

连续的两个拷贝构造优化为一个拷贝构造，

class A
{
public:
A(int a):_a(a){}
A& (const A& pp)
{
cout<<A& (const A& pp)<<endl;
}
~A(){cout<<~A()<<endl;}
private:
int _a;
};
void func(int aa)
{}
int main()
{
A a1;
func(a1);//构造拷贝
func(A(2));//匿名但是也可以不写
func(2);//隐式类型转换，连续的构造和拷贝构造优化为直接构造
return 0;
}

​

A func2()
{
A aa;
return aa;
}
int main()
{
A ret1 =func2();//连续的两个拷贝构造优化为一个拷贝构造，
//上述情况22会跨行优化，函数中的对象，临时对象，主函数对象合三为一，直接构造
A ret2;
ret2 =fun2();//这样会破坏优化，
return 0;
}