🔥🔥本章重内容
类和对象（下）
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 初始化列表
初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。
class Date
{
public:
//这样才是类的初始化
Date(int year, int month, int day)
:_year(year)
,_month(month)
,_day(day)
{}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2023,5,15);
return 0;
}
【注意】
- 每个成员变量在初始化列表中最多只能出现一次(初始化只能初始化一次)
- 类中包含以下成员，必须放在初始化列表位置进行初始化：
- 引用成员变量
- const成员变量
- 自定义类型成员(且该类没有默认构造函数时)
class B
{
public:
B(int x, int y)
:_x(x)
,_y(y)
{}
private:
int _x;
int _y;
};
class A
{
public:
A(int& c)
{
_a = 1;
_c = c;
}
private:
const int _a;
B _b;
int& _c;
};
int main()
{
return 0;
}
可以看到A类中的_a和_c都不能在函数体内赋值完成。
const类型和引用有一个共同特征那就是：必须在定义时初始化
但是C++的规定是他们可以在初始化列表内初始化，代码如下:
A(int& c)
:_a(1)
,_c(c)
{}
那当自定义类型没有默认构造时也要用初始化列表，进行初始化。
A(int& c)
:_a(1)
,_b(2,3)
,_c(c)
{}
这里我们可以得出一个结论：如果自定义类型要调用默认构造函数的话，它是在初始化列表中调用的。
如果类中的成员变量类型有const，引用，自定义类型成员，要在初始化列表中初始化
代码如下：
class B
{
public:
B(int x, int y)
:_x(x)
,_y(y)
{}
private:
int _x;
int _y;
};
class A
{
public:
A(int& c)
:_a(1)
,_b(2,3)
,_c(c)
{}
private:
const int _a;//const类型
B _b;//自定义类型
int& _c;//引用
};
int main()
{
int n = 10;
A a(n);
return 0;
}
- 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。
class B
{
public:
B(int x = 1, int y = 1)
:_x(x)
, _y(y)
{}
private:
int _x;
int _y;
};
class A
{
public:
A(int& c)
:_a(1)
//自定义类型我们不去初始化
//, _b(2, 3)
//之前我们说如自定义类型有默认构造，
//它会自动调用默认构造，它实际上是在初始化列表里调用的，
//就算我们不写，他也会自动调用
, _c(c)
{}
private:
const int _a;
B _b;
int& _c;
};
int main()
{
int n = 10;
A a(n);
return 0;
}
初始化列表走完，我们的自定义类型类被初始化了，说明自定义类型自动调用构造函数是在初始化列表内完成的
它也会进入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();
}
//A.输出1 1
//B.程序崩溃
//C.编译不通过
//D.输出1 随机值
答案选D，因为我先声明的_a2初始化也是先初始化_a2,初始化_a2时_a1还是随机值，后初始化_a1,用1初始化_a1,所以输出结果为：1，随机数
由此得出结论：类中给内置类型的缺省值实际上是给初始化列表服务的，（可以直接通过调试来观察），当类中自定义类型有缺省值，初始化列表又没有显示的去初始化自定义类型，通过一步一步的调试可以发现在走初始化列表时会走到，我们给缺省值的位置
初始化列表，不管你写不写，每个成员变量都会先走一遍
自定义类型的成员会调用默认构造
内置类型有缺省值用缺省值，没有的话就不确定，有的编译器会初始化，有的不会
1.3 explicit关键字
explicit函数的作用是防止类型的隐式类型转换
先来看一段会隐式类型转换的代码：
#include <iostream>
using namespace std;
class A
{
public:
A(int a = 1)
{
cout << "A(int a = 1)" << endl;
_a = a;
}
A(A& x)
{
cout << "A(A& x)" << endl;
_a = x._a;
}
private:
int _a;
};
int main()
{
A a1(1);
A a2 = 5;
return 0;
}
这里调用了两次构造函数。
我们来讲一下第二行代码是怎么调用的。
那有的同学就会说了你怎么知道它是构造了临时对象，再拷贝构造给a2的呢？
那我们看一下这行代码：
A& a2 = 5;
大家认为这样写对吗？用自定义类型引用 5 ？
看似是不可以的，但我们说临时对象据有常性！，C++中允许权限的平移，但不允许权限的扩大，但这里的引用相当于对临时对象权限的扩大
所以我们给 A& a2 前加一个 const
可以看到程序可以这样写，并且调用了两次构造函数，这是5在隐式类型转换时调用的，所以我们说：A a2 = 5; ，会先调用构造函数，再调用拷贝构造函数，但是编译器看到，构造+拷贝构造会优化成构造函数。
我们了解了隐式类型转换后，如果我们给构造函数前加一个explicit来限制它的自动类型转换，这样程序就运行不起来了。
2. static成员
2.1 概念
声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化
类中的静态成员变量不能给缺省值，不能在构造函数中初始化。
正确的初始化方式为：
#include <iostream>
using namespace std;
class A
{
public:
A(int b = 1)
:_b(b)
{}
static int Get_a()
{
return _a;
}
private:
static int _a;
int _b;
};
//类中的静态类型变量初始化
int A::_a = 1;
int main()
{
cout << A::Get_a() << endl;
return 0;
}
由上图可以看出来
类中静态类型函数不需要对象就可以调用，说明它没有this指针
类中静态类型变量不用创造对象也会有自己的值，它不属于某个具体的对象，存放在静态区
计算下面程序中创建出了多少个类对象。
class A
{
public:
A() { ++_scount; }
A(const A& t) { ++_scount; }
~A() { --_scount; }
static int GetACount() { return _scount; }
private:
static int _scount;
};
int A::_scount = 0;
void TestA()
{
cout << A::GetACount() << endl;
A a1, a2;
A a3(a1);
cout << A::GetACount() << endl;
}
a1，a2调用构造，a3调用拷贝构造
class A
{
public:
A() { ++_scount; }
A(const A& t) { ++_scount; }
~A() { --_scount; }
static int GetACount() { return _scount; }
private:
static int _scount;
};
int A::_scount = 0;
static A b2;
void TestA()
{
cout << A::GetACount() << endl;
static A b1;
A a1, a2;
A a3(a1);
cout << A::GetACount() << endl;
}
int main()
{
TestA();
return 0;
}
第一个函数输出的1，是因为全局的静态变量在全局中会在进入main函数前创建。
第二个函数输出5，这里我们又可以知道：局部创建的静态变量，只有在走到它那里才会创建，如果没有走就不会创建。
2.2 特性
- 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
- 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
- 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
- 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
- 静态成员也是类的成员，受public、protected、private 访问限定符的限制
提问：
- 静态成员函数可以调用非静态成员函数吗？
答案是不可以，因为静态成员函数没有this指针- 非静态成员函数可以调用类的静态成员函数吗？
答案是可以
3. 友元
友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。
友元分为：友元函数和友元类
友元函数
之前我们在写日期类时就遇到了问题，要想重载>>输入，<<输出，我们函数一定是 对象.函数名，但我们使用输入输出都是：
cout << 对象，会转换成cout.对象
cin >> 对象，会转换成 cin.对象
我们的参数第一个必须是对象，所以只能借助友元函数，把函数定义在外面。
如下代码：
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)
{}
//错误写法
/*ostream& operator<<(ostream& _cout)
{
_cout << _year << "-" << _month << "-" << _day << endl;
return _cout;
}*/
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修饰（因为它就没有this指针，const修饰函数实际上是修饰this指针）
- 友元函数可以在类定义的任何地方声明，不受类访问限定符限制
- 一个函数可以是多个类的友元函数
- 友元函数的调用与普通函数的调用原理相同
3.2 友元类
友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。（这段话可能读起来有点绕口，可以想象一个类，在另一个类中声明成友元）
如下代码：
class A
{
//B是A的友元函数，所以B可以访问A，但A不可以访问B
friend class B;
public:
void fun1()
{
};
private:
int _a;
};
class B
{
public:
void fun2()
{
A a1;
a1.fun1();
a1._a = 1;
}
private:
int _b;
};
int main()
{
return 0;
}
注意：友元关系不能传递，如果C是B的友元， B是A的友元，则不能说明C时A的友元。
4. 内部类
概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
特性：
-
内部类可以定义在外部类的public、protected、private都是可以的。
-
注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
-
sizeof(外部类)=外部类，和内部类没有任何关系。
int aaa = 1;
class A
{
private:
static int k;
int h;
public:
class B // B天生就是A的友元
{
public:
void foo(const A& a)
{
cout << k << endl;//OK
cout << a.h << endl;//OK
cout << aaa << endl;//OK
}
};
};
int A::k = 1;
int main()
{
A::B b;
b.foo(A());
return 0;
}
5.匿名对象
class A
{
public:
A(int a = 1)
{
cout << "~A(int a = 1)" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
int main()
{
//匿名对象
//特点：即用即销毁
A();
A(2);
A a1(10);
return 0;
}
6.拷贝对象时的一些编译器优化
在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝，这个在一些场景下还是非常有用的。
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;
f1(aa1);
cout << endl;
// 传值返回
f2();
cout << endl;
// 隐式类型，连续构造+拷贝构造->优化为直接构造
f1(1);
// 一个表达式中，连续构造+拷贝构造->优化为一个构造
f1(A(2));
cout << endl;
// 一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造
A aa2 = f2();
cout << endl;
// 一个表达式中，连续拷贝构造+赋值重载->无法优化
aa1 = f2();
cout << endl;
return 0;
}
4989
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
