再谈构造函数
构造函数题赋值
在创建对象时编译器通过调用构造函数,给对象中各个成员变量一个合适的初识值。
class Date
{
public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称作为类对象成员的初始化，构造函数体中的语句只能将其称作为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。
解释：
那么如何实现在定义的阶段就完成初始化呢？
此时引出了初始化列表的概念：
初始化列表
初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个“成员变量”后面跟一个放在括号中的初始值和表达式。
class Date
{
public:
// 构造函数
Date(int year = 0, int month = 1, int day = 1)
:_year(year)
, _month(month)
, _day(day)
{}
private:
int _year;
int _month;
int _day;
};
注意事项：
一、每个成员变量在初始化列表中只能出现一次
因为初始化只能进行一次，所以同一个成员变量在初始化列表中不能多次出现。
二、类中包含以下成员，必须放在初始化列表进行初始化：
1.引用成员变量
引用类型的变量在定义时就必须给其一个初始值，所以引用成员变量必须使用初始化列表对其进行初始化。
int a = 10;
int& b = a;// 创建时就初始化
2.const修饰的成员变量
被const修饰的变量也必须在定义时就给其一个初始值，也必须使用初始化列表进行初始化。
const int a = 10;//correct 创建时就初始化
const int b;//error 创建时未初始化
3.自定义类型成员（该类没有默认构造函数）
若一个类没有默认构造函数，那么我们在实例化该类对象时就需要传参对其进行初始化，所以实例化没有默认构造函数的类对象时必须使用初始化列表对其进行初始化。
默认构造函数的概念：
1.我们不写，编译器自动生成的构造函数。
2.无参的构造函数。
3.全缺省的构造函数。
class A //该类没有默认构造函数
{
public:
A(int val) //注：这个不叫默认构造函数（需要传参调用）
{
_val = val;
}
private:
int _val;
};
class B
{
public:
B()
:_a(2021) //必须使用初始化列表对其进行初始化
{}
private:
A _a; //自定义类型成员（该类没有默认构造函数）
};
总结一下：在定义时就必须进行初始化的变量类型，就必须放在初始化列表进行初始化。
三、尽量使用初始化列表初始化
因为初始化列表实际上就是当你实例化一个对象时，该对象的成员变量定义的地方，所以无论你是否使用初始化列表，都会走这么一个过程（成员变量需要定义出来）。
1.对于内置类型：
是否写初始化列表其实意义不大，原因见下图
2.对于自定义类型，使用初始化列表可以提高代码的效率
自定义类型若没有默认构造函数必须使用初始化列表否则报错，除此之外，还能使代码更加的高效简洁
class Time
{
public:
Time(int hour = 0)
{
_hour = hour;
}
private:
int _hour;
};
class Test
{
public:
// 使用初始化列表
Test(int hour)
:_t(12)// 调用一次Time类的构造函数
{}
private:
Time _t;
};
对于以上代码，当我们要实例化一个Test类的对象时，我们使用了初始化列表，在实例化过程中只调用了一次Time类的构造函数。
我们若是想在不使用初始化列表的情况下，达到我们想要的效果，就不得不这样写了：
class Time
{
public:
Time(int hour = 0)
{
_hour = hour;
}
private:
int _hour;
};
class Test
{
public:
// 在构造函数体内初始化（不使用初始化列表）
Test(int hour)
{ //初始化列表调用一次Time类的构造函数（不使用初始化列表但也会走这个过程）
Time t(hour);// 调用一次Time类的构造函数
_t = t;// 调用一次Time类的赋值运算符重载函数
}
private:
Time _t;
};
这是需要先实例化一个临时变量，然后通过赋值运算符重载将这个值赋给我们要的变量，使得代码效率变得底下，因此初始化列表的优势就体现了出来。
四、成员变量在类中声明的次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后顺序无关
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();
}
解释：
代码中，初始化列表的顺序是按照定义的时候来的，因此先初始化_a2,再初始化_a1,所以打印的结果如上，_a1为1，_a2的结果是随机值。
explicit关键字
构造函数不仅可以构造和初始化对象，对于单个参数的构造函数，还支持隐式类型转换
#include <iostream>
using namespace std;
class Date
{
public:
Date(int year = 0) //单个参数的构造函数
:_year(year)
{}
void Print()
{
cout << _year << endl;
}
private:
int _year;
};
int main()
{
Date d1 = 2021; //支持该操作
d1.Print();
return 0;
}
在语法上：代码中Date d1 = 2021等价于以下两句代码：
Date tmp(2021); //先构造
Date d1(tmp); //再拷贝构造
所以在早期的编译器中，当编译器遇到Date d1 = 2021这句代码时，会先构造一个临时对象，再用临时对象拷贝构造d1；但是现在的编译器已经做了优化，当遇到Date d1 = 2021这句代码时，会按照Date d1(2021)这句代码处理，这就叫做隐式类型转换。
类似于我们在C语言中接触的隐式类型转换
int a = 10;
double b = a;
在这个过程中，编译器首先会建立一个临时变量(double)来接收a的值，然后将该临时变量的值赋给b。这就是为什么函数可以返回局部变量的值，先将这个值传递给一个临时变量。函数栈帧销毁以后，里边的变量也就被销毁了，但是因为有这个临时变量的存在，所以才可以完成函数值的返回。
但是，对于单参数的自定义类型来说，Date d1 = 2021这种代码的可读性不是很好，我们若是想禁止单参数构造函数的隐式转换，可以用关键字explicit来修饰构造函数。
static成员
概念
声明为static的类成员称为类的静态成员。用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化。
特性
一、静态成员为所以类对象所共享，不属于某个具体的对象
鉴于此，我们看看以下代码的运行结果：
#include <iostream>
using namespace std;
class Test
{
private:
static int _n;
};
int main()
{
cout << sizeof(Test) << endl;
return 0;
}
结果计算Test类的大小为1，因为静态成员_n是存储在静态区的，属于整个类，也属于类的所有对象。所以计算类的大小或是类对象的大小时，静态成员并不计入其总大小之和。
二、静态成员变量必须在类外定义，定义时不添加static关键字
class Test
{
private:
static int _n;
};
// 静态成员变量的定义初始化
int Test::_n = 0;
注意：这里静态成员变量_n虽然是私有，但是我们在类外突破类域直接对其进行了访问。这是一个特例，不受访问限定符的限制，否则就没办法对静态成员变量进行定义和初始化了。
三、静态成员函数没有隐藏的this指针，不能访问任何非静态成员
class Test
{
public:
static void Fun()
{
cout << _a << endl; //error不能访问非静态成员
cout << _n << endl; //correct
}
private:
int _a; //非静态成员
static int _n; //静态成员
};
小贴士：含有静态成员变量的类，一般含有一个静态成员函数，用于访问静态成员变量
四、访问静态成员变量的方法
1.当静态成员变量为公有时，有以下几种访问方式：
#include <iostream>
using namespace std;
class Test
{
public:
static int _n; //公有
};
// 静态成员变量的定义初始化
int Test::_n = 0;
int main()
{
Test test;
cout << test._n << endl; //1.通过类对象突破类域进行访问
cout << Test()._n << endl; //3.通过匿名对象突破类域进行访问
cout << Test::_n << endl; //2.通过类名突破类域进行访问
return 0;
}
2.当静态成员变量为私有时，有以下几种访问方式：
#include <iostream>
using namespace std;
class Test
{
public:
static int GetN()
{
return _n;
}
private:
static int _n;
};
// 静态成员变量的定义初始化
int Test::_n = 0;
int main()
{
Test test;
cout << test.GetN() << endl; //1.通过对象调用成员函数进行访问
cout << Test().GetN() << endl; //2.通过匿名对象调用成员函数进行访问
cout << Test::GetN() << endl; //3.通过类名调用静态成员函数进行访问
return 0;
}
五、静态成员和类的普通成员一样，也有public、private和protected这三种访问级别
所以当静态成员变量设置为private时，尽管我们突破了类域，也不能对其进行访问。
注意区分两个问题：
1、静态成员函数可以调用非静态成员函数吗？
2、非静态成员函数可以调用静态成员函数吗？
答：
（1）不可以。因为非静态成员函数的第一个形参默认为this指针，而静态成员函数中没有this指针，故静态成员函数不可调用非静态成员函数。
（2）可以。因为静态成员函数和非静态成员函数都在类中，在类中不受访问限定符的限制。
友元
友元分为友元函数和友元类。友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。
友元函数
友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。
对于之前实现的日期类，我们现在尝试重载operator<<，但是我们发现没办法将其重载为成员函数，因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置：this指针默认是第一个参数，即左操作数，但是实际使用中cout需要是第一个形参对象才能正常使用。
所以我们要将operator<<重载为全局函数，但是这样的话，又会导致类外没办法访问成员，那么这里就需要友元来解决。上一篇博客有讲到过！
友元函数说明：
1、友元函数可以访问类是私有和保护成员，但不是类的成员函数。
2、友元函数不能用const修饰。
3、友元函数可以在类定义的任何地方声明，不受访问限定符的限制。
4、一个函数可以是多个类的友元函数。
5、友元函数的调用与普通函数的调用原理相同。
友元类
友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中非公有成员
class A
{
// 声明B是A的友元类
friend class B;
public:
A(int n = 0)
:_n(n)
{}
private:
int _n;
};
class B
{
public:
void Test(A& a)
{
// B类可以直接访问A类中的私有成员变量
cout << a._n << endl;
}
};
友元类说明：
1、友元关系是单向的，不具有交换性。
例如上述代码中，B是A的友元，所以在B类中可以直接访问A类的私有成员变量，但是在A类中不能访问B类中的私有成员变量。
2、友元关系不能传递。
如果A是B的友元，B是C的友元，不能推出A是C的友元。
内部类
概念：如果一个类定义在另一个类的内部，则这个类被称为内部类
注意：
1.此时的内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象区调用内部类。
2、外部类对内部类没有任何优越的访问权限。
3、内部类就是外部类的友元类，即内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
特性
1、内部类可以定义在外部类的public、private以及protected这三个区域中的任一区域。
2、内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名。
3、外部类的大小与内部类的大小无关。
#include <iostream>
using namespace std;
class A //外部类
{
public:
class B //内部类
{
private:
int _b;
};
private:
int _a;
};
int main()
{
cout << sizeof(A) << endl; //外部类的大小
return 0;
}
这里外部类A的大小为4，与内部类的大小无关
匿名对象
有的时候调用某些成员函数的时候，如果单独为了调用某个函数实例化一个新的对象时，显得不是很方便，所以引入了匿名对象的概念，匿名对象的好处是，执行完当前行，就会进行析构，而构造出的对象，需要出当前函数作用域才会被析构，因此匿名函数的好处不言而喻，当然也有其他的作用，后面再谈。
具体的解析，可以看下面的代码。
#include <iostream>
using namespace std;
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();
//匿名对象在这样的场景下就很好使用，当然还有一些其他的应用场景
Solution().Sum_Solution(10);
return 0;
}
拷贝对象时的一些编译器优化
当我们在进行实例化对象的过程中，有可能会出现一些繁琐的操作，编译器是智能的，因此，它会进行一些优化，能使代码变得效率更高，下面将一一介绍，构造过程、数传参(拷贝构造)以及返回值(拷贝构造)的过程中，编译器做的优化，并且会提及怎么样的写法会使得编译器变得高效！
1.创建新对象
#include <iostream>
using std::cout;
using std::endl;
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;
};
int main()
{
A aa1 = 2;
return 0;
}
注:如果不想让编译器对这个过程进行优化，可以在定义类的时候加入explicit关键字，这个方法在前面的章节单独介绍过了，如有疑惑，去查看即可！
2.函数传值传参
#include <iostream>
using std::cout;
using std::endl;
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)
{}
int main()
{
// 传值传参
A aa1;
f1(aa1);
cout << endl;
return 0;
}
分析：这里可以感觉到对于一些特殊的场景，上面的做法是多余，看下面的代码改进！
#include <iostream>
using std::cout;
using std::endl;
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)
{}
int main()
{
// 传值传参
/*A aa1;
f1(aa1);
cout << endl;*/
f1(A(1));
cout << endl;
f1(1);
cout << endl;
return 0;
}
3.函数返回类对象
#include <iostream>
using std::cout;
using std::endl;
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(1);
aa1 = f2();
return 0;
}
改进写法1:
#include <iostream>
using std::cout;
using std::endl;
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 = f2();
return 0;
}
总结：从上面的代码可以分析出返回值的时候，编译器做了优化，相较于最初的写法，少了一个步骤，这就是编译器做了优化。因此，我们在以后写的过程中，接受类对象的返回值时，直接创建一个新的，就会省去很多步骤！
注：只有固定写法，编译器才会做优化，最初的版本编译器不会做优化的，它虽然很智能，但还没有那么的智能。
改进写法2:
#include <iostream>
using std::cout;
using std::endl;
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()
{
//下面的构造匿名对象方法都可以
//return A();
return A(1);
}
int main()
{
A aa1 = f2();
return 0;
}
总结：对于不同的场景，我们有不同的代码写法，但是能让代码高效的地方，尽可能的让它高效，这些都是一些细节，是我从《深度探索C++对象模型》这本书看到的，当有了一定的基础，去看一些书籍，对我们的内功提升还是很大的，但是不建议小白去看书，这是一种很耗费时间的学习方法！
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
