目录
再谈构造函数
隐式类型的转换
explicit关键字
单参数
多参数
static静态
一道关于static的题目
友元
友元函数
友元类
内部类
匿名对象
拷贝对象时的一些编译器优化
结束语
再谈构造函数
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
初始化列表
初始化列表：以一个
冒号开始
，接着是一个以
逗号分隔的数据成员列表
，每个
"
成员变量
"
后面跟
一个
放在括号中的初始值或表达式。
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 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
};3. 尽量使用初始化列表初始化，因为 不管你是否使用初始化列表(即使没有也会走一遍) ，对于自定义类型成员变量，一定会先使用初始化列表初始化。
4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序， 与其在初始化列表中的先后次序无关
一道题目
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 ();}/*A . 输出 1 1B . 程序崩溃C . 编译不通过D . 输出 1 随机值*/
隐式类型的转换
explicit关键字
构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值 的构造函数，还具有类型转换的作用。用 explicit 修饰构造函数，将会禁止构造函数的隐式转换 。
单参数
//隐式类型的转换
class Date
{
public:
// 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用
// explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译
Date(int year) //当在此语句前添加explicit就不会进行隐式类型的转换了
:_year(year)
{}
Date& operator=(const Date& d)
{
if (this != &d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
return *this;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2022);
//隐式类型的转换
Date d2 = 2022; //先构造，再拷贝构造，但是现在的编译器可以直接构造
Date d3(d1);
Date d4 = d1;
const Date& d5 = 2022; //引用
return 0;
}
检测优化的方式
//统计A对象创建了多少个，这里测试的比较少，还有传值传参、传值返回之类的都会调用构造
int N = 0;
class A
{
public:
A(int a = 0) //构造
:_a(a)
{
N++;
}
A(const A& aa) //拷贝构造 -- 拷贝构造也算构造
:_a(aa._a)
{
N++;
}
private:
int _a;
};
int main()
{
A aa1(1);
A aa2 = 1; //显然这里是被优化之后的结果,否则会显示4个
A aa3 = aa1;
cout << N << endl;
return 0;
}
用途
多参数
//隐式类型的转化
class Date
{
public:
// 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具有类型转换作用
// explicit修饰构造函数，禁止类型转换
Date(int year, int month = 1, int day = 1) //缺省一个，或者全缺省也可以发生隐式类型的转换
: _year(year)
, _month(month)
, _day(day)
{}
Date& operator=(const Date& d)
{
if (this != &d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
return *this;
}
private:
int _year;
int _month;
int _day;
};
//注意是C++11后面支持的多参数，单参数的隐式类型转换在C++98就已经支持了
int main()
{
//隐式类型的转换
Date d1 = (2022,12,22); //先构造，再拷贝构造，但是现在的编译器可以直接构造
//等价于下面的写法，但是本质上是不同的，上面是优化后的结果
Date d2(2022, 12, 22);
const Date& d3 = { 2022 ,12 ,22}; //引用
return 0;
}static静态
优化下检测，引入静态成员函数与静态成员变量
//static -- 静态成员变量与静态成员函数
//显然我们通常并不会去使用全局变量，容易被误改
//将它约束到类中显然是一种好方法
class A
{
public:
A(int a = 0) //构造
:_a(a)
{
N++;
}
A(const A& aa) //拷贝构造 -- 拷贝构造也算构造
:_a(aa._a)
{
N++;
}
static int GetN()//为了让外部得到内部的静态数据
//可以利用静态成员函数来实现，通常这俩是一起的
{ //当然这里是不能访问非静态的成员，静态的只能访问静态的
return N;
}
private:
int _a;
static int N; //这是声明，所以不能定义初始化，也不能通过初始化列表去初始化
//注意这个N并不在栈帧中，而是在静态区中
//我们也一般设置成私有的，而不是共有的
};
int A::N = 0; //定义初始化,只能在类外部去初始化，注意要指定类域
int main()
{
A aa1(1);
A aa2 = 1;
cout << aa1.GetN() << endl;
cout << A::GetN() << endl; //有了静态成员函数也可以直接调用，不需要重新定义类对象出来
A* ptr = nullptr; //这种也是可以的，不过我们一般不这样做
cout << ptr->GetN() << endl;
return 0;
}一道关于static的题目
JZ64 求1+2+3+...+n -- 链接
描述
求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。数据范围： 0 < n \le 2000<n≤200
示例1
输入：
5返回值：
15示例2
输入：
1返回值：
1进阶： 空间复杂度 O(1) ，时间复杂度 O(n)
解答
class sum{
public:
static int GetRet() //让外部得到数据
{
return _ret;
}
sum()
{
_ret += _i;
_i++;
}
private:
static int _i; //静态的，让其共享一份
static int _ret;
};
int sum::_i = 1;
int sum::_ret = 0;
class Solution {
public:
int Sum_Solution(int n) {
sum a[n];
return sum::GetRet();
}
};//要求禁止常规创建对象的解决方法
class A{
public:
static A GetObj(int a = 0)
{
A aa1(a);
return aa1;
}
private: //放到私有就无法常规创建对象了
A(int a = 0)
:_a(a)
{
}
private:
int _a;
};
int main()
{
//static A aa1; //拷贝构造
//A* ptr = new aa3; //new 在堆上创建
//A aa2; //最常见的构造 这三种都不可以创建了
A aa = A::GetObj(10); //静态成员函数没有this指针
return 0;
}友元
友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。友元分为： 友元函数和友元类
友元函数
问题：现在尝试去重载 operator<< ，然后发现没办法将 operator<< 重载成成员函数。 因为 cout 的 输出流对象和隐含的 this 指针在抢占第一个参数的位置 。 this 指针默认是第一个参数也就是左操作数了。但是实际使用中cout 需要是第一个形参对象，才能正常使用。所以要将 operator<< 重载成 全局函数。但又会导致类外没办法访问成员，此时就需要友元来解决。operator>> 同理。
解决方法：友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加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;
}说明 :1、友元函数可访问类的私有和保护成员，但 不是类的成员函数2、友元函数不能用 const 修饰3、友元函数可以在类定义的任何地方声明， 不受类访问限定符限制4、一个函数可以是多个类的友元函数5、友元函数的调用与普通函数的调用原理相同
友元类
友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。①友元关系是单向的，不具有交换性。 A是B的友元，但是反过来B却不是A的友 元比如上述 Time 类和 Date 类，在 Time 类中声明 Date 类为其友元类，那么可以在 Date 类中直接访问 Time 类的私有成员变量，但想在 Time 类中访问 Date 类中私有的成员变量则不行。②友元关系不能传递如果C 是 B 的友元， B 是 A 的友元，则不能说明 C 时 A 的友元。③ 友元关系不能继承，在继承再做介绍。
内部类
概念： 如果一个类定义在另一个类的内部，这个内部类就叫做内部类 。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。注意： 内部类就是外部类的友元类 ，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。特性：1. 内部类可以定义在外部类的public、protected、private都是可以的。2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。3. sizeof(外部类)=外部类，和内部类没有任何关系。
优化上面所做的题目
class Solution {
public:
class sum { //内部类
public:
sum() {
_ret += _i;
_i++;
}
};
int Sum_Solution(int n) {
sum a[n];
return _ret;
}
private:
static int _i; //静态的，让其共享一份
static int _ret;
};
int Solution::_i = 1;
int Solution::_ret = 0;这样看起来要简洁许多了
注意事项：
关于友元与内部类其实C++并不太喜欢用，Java用的比较多，这种行为会破环类的封装
匿名对象
//匿名对象
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;
}
};
A F()
{
//A aa1(10);
//return aa1;
return A(10); //有了匿名对象上面两句就直接可以简化成一句了
}
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;
}
A f3()
{
//A aa(10);
//return aa;
return A(10);
}
int main()
{
//优化场景1
//A aa1 = 1; //A tmp(1) + A aa1(tmp) -> 优化 A aa1(1)
//优化场景2
//A aa1(10);
//f1(aa1);
//f1(A(10)); // 构造 + 拷贝构造 -> 优化 构造
//f1(1); //有隐式类型转换 构造 + 拷贝构造 -> 优化 构造
//优化场景3
//f2();
//A ret = f2(); //构造+拷贝构造+拷贝构造 -> 优化 构造
//不可取
//A ret;
//ret = f2();
//优化场景4
A ret = f3();
return 0;
}
结束语
钟鼎山林都是梦，人间荣辱休惊，只消闲处过平生。
-- 《临江仙·再用前韵，送祐之弟归浮梁》
