构造函数（续）

构造函数体赋值

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值

class Date
{
public:Date(int year, int month, int day){_year = year;_month = month;_day = day;}private:int _year;int _month;int _day;
};

初始化列表

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个成员变量后面跟一个放在括号中的初始值或表达式

class A
{
public:A(int a):_a(a){}
private:int _a;
};class B
{
public://初始化列表：对象的成员定义的位置B(int a, int& ref):_aobj(a),_ref(ref),_n(10){}
private://声明A _aobj; // 没有默认构造函数//特征：必须在定义的时候初始化int& _ref; // 引用const int _n; // const 
};int main()
{int x = 20;B b1(10,x);return 0;
}

注意：

每个成员变量在初始化列表中最多只能出现一次(初始化只能初始化一次)
类中包含以下成员，必须放在初始化列表位置进行初始化：

1. 引用成员变量
2. const成员变量
3. 自定义类型成员(且该类没有默认构造函数时）

尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化

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

class A
{
public:A(int a):_a1(a),_a2(_a1){}void Print() {cout << _a1 << " " << _a2 << endl;}
private:int _a2;int _a1;
};int main()
{A a(1);a.Print();return 0;
}

运行结果：

这里的声明顺序是a2 - a1所以在初始化的时候就是先初始化a2（随机值）再初始化a1

建议声明的顺序和定义的顺序保持一致，可以减少错误的发生

explicit关键字

隐式类型转换

class A
{
public:A(int a):_a(a){}private:int _a;
};
int main()
{A a1(1);A a2 = 2;//隐式类型转换，一个整型转换成自定义类型//2构造一个A的临时对象，临时对象再拷贝构造a2 -->优化为用2直接构造//临时对象具有常性，需要加constconst A& a3 = 3;//这里也会发生隐式类型转换return 0;
}

那如果我们不希望发生转换该怎么处理
那么就可以加上 explicit

class A
{
public:explicit A(int a):_a(a){}private:int _a;
};
int main()
{A a1(1);A a2 = 2;//隐式类型转换，一个整型转换成自定义类型//2构造一个A的临时对象，临时对象再拷贝构造a2 -->优化为用2直接构造//临时对象具有常性，需要加constconst A& a3 = 3;//这里也会发生隐式类型转换return 0;
}

加上了 explicit就无法发生隐式转换因此这段代码就会报错

---

static成员

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化

class A
{
public:A(){ }A(const A& t) { }~A() { }private:};

我们想知道当前还有多少个A对象正在使用该怎么办？
我们可以使用全局变量进行统计，构造一次加一，析构一次减一

int _count = 0;class A
{
public:A(){ ++_count;}A(const A& t) { ++_count;}~A() { --_count;}private:};int main()
{//全局变量的劣势 - 任何地方都可以随意改变_count++;return 0;
}

但是全局变量有一个劣势，就是任何地方都可以对他进行修改，这样的数据就会非常不安全
那么我们就可以把我们的数据封装在类里面

class A
{
public:A()//不能这样定义，因为他不是属于某个对象的成员，他是属于全局的//:_count(0);{ ++_count;}A(const A& t) { ++_count;}~A() { --_count;}//因为是私有的数据，所以需要一个共有的成员函数来访问//静态成员函数 - 特点：没有this指针，指定类域和访问限定符就可以访问//静态成员变量和静态成员函数一般是配套出现的static int GetCount(){return _count;}
private://成员变量 - 存储在对象里面int _a = 1;int _b = 2;//静态成员变量 - 存储在静态区//同理这里也是声明，也是需要在类外面定义static int _count;//区别：成员变量 - 属于每一个类对象//静态成员变量 - 属于类，属于类的每个对象共享
};//全局位置，类外面定义(可以突破一次私有）
int A::_count = 0;void Func()
{static A a2;cout << __LINE__ << "-" << A::GetCount() << endl;
}
int main()
{A a1;cout << __LINE__ << "-" << A::GetCount() << endl;Func();Func();return 0;
}

__LINE__显示当前行数

运行效果：

1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

友元

友元提供了一种突破封装的方式，有时提供了便利，但是友元会增加耦合度，破坏了封装，所以友元不宜多用

友元函数

class Date
{//友元函数声明//友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类//但需要在类的内部声明，声明时需要加friend关键字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修饰
友元函数可以在类定义的任何地方声明，不受类访问限定符限制
一个函数可以是多个类的友元函数
友元函数的调用与普通函数的调用原理相同

友元类

class Time
{//声明Date类为Time的友元类，在Date类中就直接访问Time类中的私有成员变量friend class Date; 
public:Time(int hour = 0, int minute = 0, int second = 0): _hour(hour), _minute(minute), _second(second){}private:int _hour;int _minute;int _second;
};class Date
{
public:Date(int year = 1900, int month = 1, int day = 1): _year(year), _month(month), _day(day){}void SetTimeOfDate(int hour, int minute, int second){// 直接访问时间类私有的成员变量_t._hour = hour;_t._minute = minute;_t._second = second;}void Print(){cout << _t._hour << "-" << _t._minute << "-" << _t._second << endl;}private:int _year;int _month;int _day;Time _t;
};int main()
{//可以在Date类中直接访问Time类的私有成员变量//但在Time类中访问Date类中私有的成员变量则不行Date d1;//通过Date类设置Time类的私有成员d1.SetTimeOfDate(22, 30, 10);//通过Date类访问Time类的私有成员d1.Print();return 0;
}

运行效果：

友元关系不能传递
如果B是A的友元，C是B的友元，则不能说明C时A的友元
友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员

内部类

如果一个类定义在另一个类的内部，这个内部类就叫做内部类， 内部类可以是公有、私有、保护

class A
{
private:static int k;int h;
public:class B //内部类是外部类的友元{public:private:int b;};
};int A::k = 1;int main()
{cout << sizeof(A) << endl;return 0;
}

运行结果：

从结果可以看到B类虽然定义在了A类里面，但是B类并不占用空间
内部类是外部类的友元，所以我们可以通过B类访问A类的成员

class A
{
private:static int _k;int _h = 20;
public:class B //内部类是外部类的友元 - B可以访问A，A不能访问B{public:void Print(const A& a){cout << a._k << endl;//OK//内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名cout << _k << endl;//OKcout << a._h << endl;//OKcout << _b << endl;}private:int _b = 30;};
};int A::_k = 10;int main()
{A a1;//内部类实例化//如果内部类为私有则无法实例化A::B b1;b1.Print(a1);return 0;
}

运行效果：

匿名对象

class A
{
public:A(int a = 0):_a(a){cout << "调用构造函数" << endl;}~A(){cout << "调用析构函数" << endl;}private:int _a;
};int main()
{A a1(1);//有名对象A(2);//匿名对象（没有名字）return 0;
}

运行效果：

匿名对象的作用

class A
{
public:A(int a = 0):_a(a){cout << "调用构造函数" << endl;}~A(){cout << "调用析构函数" << endl;}private:int _a;
};class Solution
{
public:int Sum_Solution(int n){cout << "已调用Sum_Solution" << endl;return n;}
};int main()
{A a1(1);//有名对象A(2);//匿名对象（没有名字)//如果我们想调用Sum_Solution//可以这样调用Solution s;s.Sum_Solution(10);//还可以使用匿名对象调用//如果只想调用一次则可以使用这种方法//类型不能调用函数，需要加()//如果没有默认构造则需要传参（有几个参数就传几个） - Solution(1).Sum_Solution(20);Solution().Sum_Solution(20);return 0;
}

运行效果：

从运行结果还可以看出，匿名对象的生命周期只在当前行，而有名对象的生命周期在当前函数局部域
匿名对象和临时对象一样具有常性

const引用匿名对象

虽然匿名对象的生命周期只在当前行，但是const引用会延长匿名对象的生命周期（生命周期在当前函数局部域）

class A
{
public:A(int a = 0):_a(a){cout << "调用构造函数" << endl;}~A(){cout << "调用析构函数" << endl;}private:int _a;
};class Solution
{
public:int Sum_Solution(int n){cout << "已调用Sum_Solution" << endl;return n;}
};int main()
{A a1(1);//有名对象A(2);//匿名对象（没有名字)//A& ra = A(3); //匿名对象具有常性const A& ra = A(4);Solution().Sum_Solution(20);return 0;
}

运行效果：


补充：编译器的优化

class A
{
public:A(int a = 0):_a(a){cout << "调用构造函数" << endl;}~A(){cout << "调用析构函数" << endl;}private:int _a;
};A Func()
{A aa;return aa;
}int main()
{//编译器会对连续的构造进行优化A a1 = Func(); //拷贝构造+拷贝构造 ->优化为拷贝构造cout << "-------------" << endl;//这种写法干扰了编译器的优化A a2;a2 = Func();//这种写法编译器不会进行优化，应该避免这种写法return 0;
}

运行效果：

---

以上就是本篇文章的全部内容了，希望大家看完能有所收获