1.构造函数知识点补充
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 Date
{
public:
//构造函数
//...
private:
int _year;//对象的声明
int _month;
int _day;
const int _n;//加入const对象会报错 >> 为什么？
};
int main
{
Date d1;//对象整体的定义
return 0;
}
因为const类型必须在变量定义的地方初始化，并且只有这一次机会。
并且因为const类型是内置类型，而构造函数对内置类型不做处理，所以在定义对象的时候有const类型会报错。
而main函数中的Date d1;是对象整体定义的地方，并不是每个成员变量定义的地方。
那么每个成员什么时候定义呢？
C++11规定成员函数可以在声明的地方给缺省值，所以在类的成员变量声明处可以给const对象一个缺省值：const int _n = 0;来解决这个问题。
那么在C++11之前又是怎么解决的呢？
——必须给成员变量找一个定义的位置：
那就是初始化列表
位置：构造函数处
格式：冒号开始，逗号分隔
特性：
- 对象调用构造函数，初始化列表就是它的所有成员变量定义的地方；
- 不管成员变量是否显式的在初始化列表写出，都会在初始化列表初始化，如果显式写出了，就用自己写的初始化，没有写出就用成员变量声明处的缺省值来初始化；
class A
{
public:
A(int a)
:_a(1)
{}
private:
int _a;
}
class Date
{
public:
Date()
:_year(1)//初始化列表
,_n(1)//只写了两个变量，但是初始化的时候四个成员变量都会在这里初始化
,_a(_year)//初始化_a为_year的引用
,a1(0)//
{}
private:
int _year = 1;//缺省值，初始化列表没显式定义的话就用这里的缺省值来初始化
int _month = 1;
int _day = 1;
const int _n = 1;
int& _a;
A a1;//调用默认构造，如果构造有参-没有默认构造，那么就必须用初始化列表
};
【注意】
- 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)；
- 类中包含以下成员，必须放在初始化列表位置进行初始化：
引用成员变量int& _a；
const成员变量const int _b；
自定义类型成员(且该类没有默认构造函数时)；
对自定义类型成员必须要用初始化列表的解析：
class A
{
public:
//A(int a = 1)全缺省——默认构造；
A()//无参——默认构造；
:_a(1)
{}
private:
int _a;
}
class B
{
public:
B(int b)//有参——不是默认构造
:_b(1)
{}
private:
int _b;
}
///
class C
{
public:
Date()
//A可不用初始化列表，因为有默认构造
:B b1(1)//B必须用初始化列表，因为没有默认构造
{}
private:
A a1;//调用默认构造,A中有默认构造，所以可以调用
B b1;//B没有默认构造，不能调用，必须用初始化列表传参
};
- 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后
次序无关。
class A
{
public:
A(int a)
:_a1(a)
,_a2(_a1)
{}
void Print() {
cout<<_a1<<" "<<_a2<<endl;
}
private:
int _a2;
int _a1;
};
int main() {
A aa(1);
aa.Print();
}
总结：
1.不管有没有显式写初始化列表，成员变量都会在初始化列表初始化，就算连冒号和逗号都没写也会走。——初始化列表是成员变量定义的地方
2.所以建议所有成员变量都在初始化列表显式初始化。
1.3.explicit关键字
构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有隐式类型转换的作用。
（C++98对多参数的构造函数不支持隐式类型转换，C++11对多参数的构造函数支持隐式类型转换，使用方法：将参数用{}括起来：若有两个参数则A a1 = {1, 1};）
1.一般情况：
//单参数的构造函数-->支持隐式类型转换
class A
{
public:
A(int a)
:_a(a)
{}
A(const A& a)//拷贝构造也是构造函数，可以有初始化列表
:_a(a._a)
{}
private:
int _a;
};
int main()
{
A a1(1);//构造函数
A a2 = 1;//支持隐式类型转换 --> 构造 + 拷贝构造 + 编译器优化 = 拷贝构造（int->A）
const A& a3 = 10;//隐式类型转换-->构造产生临时对象，
//再用临时对象拷贝构造，而临时对象有常性，
//所以要用const修饰，防止权限放大。
return 0;
}
2.explicit修饰构造函数，禁止类型转换：
class A
{
public:
explicit A(int a)//修饰构造函数，成员变量就无法使用隐式类型转换了
:_a(a)
{}
A(const A& a)
:_a(a._a)
{}
private:
int _a;
};
int main()
{
A a1(1);
A a2 = 1;//无法隐式类型转换，报错
const A& a3 = 10;//无法隐式类型转换，报错
return 0;
}
用explicit修饰构造函数，将会禁止构造函数的隐式转换。
2.static成员
1.声明为static的成员称为类的静态成员，用static修饰的成员变量称之为静态成员变量；
用static修饰的成员函数，称之为静态成员函数。
注意：静态成员变量一定要在类外进行初始化——static int A::_n = 0;
class A
{
public:
A(int a = 0)
{
++count;
}
A(const A& a)
{
++count;
}
static int GetCount()//静态成员函数——没有this指针，无法直接访问非静态成员变量
{ //只能直接访问静态成员变量
return count;
}
private:
static int count;//静态成员变量不能在声明处给缺省值
int _a = 0;
};
int A::count = 0;//静态成员变量在类外初始化定义，并且定义的时候不加static
int main()
{
A a1;
A a2(a1);
A a3[10];//调用10次构造函数
cout << A::GetCount() << endl;
return 0;
}
初始化列表初始化的是非静态成员，是每个对象的成员定义的地方，而static是共有的，不能在初始化列表初始化，也就不能在初始化列表给缺省值。
1.2.特性
- 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
- 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
- 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
- 静态成员函数没有隐藏的this指针，不能访问任何[非静态成员]，但是由于没有this指针，所以可以在不创建对象的情况下去访问[静态成员变量]
- 静态成员也是类的成员，受public、protected、private 访问限定符的限制
基本上静态成员函数和静态成员变量是绑定使用的，可以用来计算一个程序中一共构建了多少了类对象。
–
2.1.匿名对象
Date();——匿名对象，在实例化对象的时候可以不定义对象名称，这种方法实例化的对象叫匿名对象；
1.匿名对象的特点是：
生命周期只在这一行。
2.对比：
一般对象：生命周期在局部域——匿名对象：生命周期在当前一行；
一般对象：Date d1(10); ——匿名对象：Date(10);
3.应用场景：
有时为了调用某个函数就要另外实例化一个对象：
Date d1;
d1.Function(100);
这时就可以直接使用匿名对象：Date().Funtion(100);,更加方便；
4.总结：
匿名对象就相当于是一次性的对象，用完即仍。
3.友元
友元提供了一种突破封装的方式，有时提供了便利。
但是友元会增加耦合度，会破坏封装，所以尽量少用。
友元分为：
- 友元函数
- 友元类
1.友元函数：
友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。
class Date
{
friend void Add(const Date& d1, const Date& d2);//友元函数声明
public:
//...
private:
//...
}
//定义在类外
void Add(const Date& d1, const Date& d2)
{//...
}
2.友元函数的说明：
- 友元函数可以访问私有，但是不是类的成员函数
- 友元函数不能用const修饰
- 友元函数可以在类定义的任何地方声明，不受类访问限定符限制
- 一个函数可以是多个类的友元函数
- 友元函数的调用与普通函数的调用原理相同
4.内部类
一个类定义在另一个类的内部，这个内部类就叫做内部类。
内部类是一个独立的类，不属于外部类，更不能通过外部类的对象去访问内部类的成员。
外部类对内部类没有任何优越的访问权限。
注：内部类默认是外部类的友元，所以内部类可以访问外部类的成员。
（友元不是双向的，内部可以访问外部，但是外部不可以访问内部）
特性：
- 内部类可以定义在外部类的public、protected、private。
- 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
- sizeof(外部类)=外部类，和内部类没有任何关系，计算时不会加入内部类的大小。
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;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
void f1(A aa)
{}
A f2()
{
A aa;
return aa;
}
A f3()
{
return A();
}
int main()
{
A aa1; //构造
A aa2 = 1; //构造+拷贝构造 -> 构造
cout << "------------------------------------------" << endl;
f1(aa1); //拷贝构造
f1(2); //构造+拷贝构造 -> 构造
f1(A(2)); //构造+拷贝构造 -> 构造
cout << "------------------------------------------" << endl;
f2(); //构造+拷贝构造
A aa3 = f2(); //构造+拷贝构造+拷贝构造 -> 构造+拷贝构造
cout << "------------------------------------------" << endl;
f3(); //构造+拷贝构造 ->构造
A aa4 = f3(); //构造+拷贝构造+拷贝构造 ->构造
cout << "------------------------------------------" << endl;
//下面两种写法，对比发现虽然结果一样，但是第一种写法更好
A aa5 = f2();//构造+拷贝构造+拷贝构造->构造+拷贝构造
A aa6; //构造+构造+拷贝构造+赋值重载
aa6 = f2();
cout << "------------------------------------------" << endl;
return 0;
}
总结：
1.传参与返回值时用匿名对象可以减少拷贝构造的调用，可以多使用匿名对象。
2.接收返回值尽量用拷贝构造的方式，不要用赋值重载接收，无法优化。
3.尽量使用const &传参，减少构造与拷贝构造
897
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
