文章目录
前言：
在
C++类与对象（二）中我们学习了类的默认6个成员函数，本章我们将继续加深对类与对象的学习。本章目标：初始化列表，explicit关键字，static成员，友元，内部类，匿名对象，拷贝对象时的一些编译器优化等
一.初始化列表
在构造函数的学习中，我们知道可以通过构造函数对一个对象的成员变量赋初始值。我们以Date类为例：
class Date
{
public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void print()
{
cout << _year << "年" << _month << "月" << _day << "日" << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2023, 4, 6);
d1.print();
return 0;
}
虽然上述过程中通过构造函数的调用使得对象d1确实有了一个初始值，但是我们并不能将该过程称为对对象中成员变量的初始化。
- 构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。
那么初始化在何时进行呢？下面将介绍初始化列表了：
1.初始化列表的概念
初始化列表的格式：
以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个成员变量后面跟 一个放在括号中的初始值或表达式。
示例：
class Date
{
public:
Date(int year, int month, int day)
//初始化列表
:_year(year),
_month(month),
_day(day)
{}
void print()
{
cout << _year << "年" << _month << "月" << _day << "日" << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2023, 4, 6);
d1.print();
return 0;
}
运行结果：
2.初始化列表的注意事项
-
每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
-
类中包含以下成员，必须放在初始化列表位置进行初始化：
- 引用成员变量
const成员变量- 自定义类型成员(且该类没有默认构造函数时)。
class B
{
public:
B(int b)
:_b(b)
{}
private:
int _b;
};
class A
{
public:
A(int a, int i, int b)
:_a(a),
_i(i),
_b1(b)
{}
private:
int& _a;
const int _i;
B _b1;
};
- 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。
- 成员变量在类中声明顺序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关
class A
{
public:
A()
:b(10),
a(b)
{}
void print()
{
cout << "a= " << a << endl;
cout << "b= " << b << endl;
}
private:
int a;
int b;
};
int main()
{
A a1;
a1.print();
return 0;
}
运行结果：
这是因为：
- 成员变量的声明顺序为先
a后b，则初始化顺序也为先a后b。a在初始化时，使用b的值，而此时b还未初始化b的值为随机值，所以a的值也为随机值。接下来用10初始化b，所以b的值为10。
二.explicit关键字
构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用。
什么是类型转换？
int a=100;
double b = a;
如上所示，a并不是直接赋值给b，而是先进行了隐式类型转换：
- 创建一个
double类型的临时变量 - 将
a的值赋予临时变量 - 将临时变量的值赋予
b。
1.单参数构造函数
定义一个Date类，且该类的构造函数只有一个参数，我们称为单参数构造函数
class Date
{
public:
Date(int year)
:_year(year)
{}
private:
int _year=0;
};
这是我们常见的创建一个对象的写法，此外还可以这样写：
Date d2 = 2023;
注意:
-
此处这种写法是我们的赋值运算符重载吗？
当然不是。赋值重载实现的功能是用一个已存在的对象赋值给另外一个对象。 -
那么为什么
100可以赋值给d1呢？这是由于类型转换的原因。具体实现过程如下：- 用
100构造一个Date类型的临时对象； - 再用临时对象对
d1进行拷贝构造。
- 用
该语句实现了2个过程——1个构造+1个拷贝构造。
🤔那我们如何证明发生了类型转换呢？
这就要用到explicit关键字了。
explicit修饰的构造函数禁止类型转换。
class Date
{
public:
explicit Date(int year)
:_year(year)
{}
private:
int _year=0;
int _month=0;
int _day=0;
};
int main()
{
Date d2 = 100;
return 0;
}
运行结果：
如图所示，此时编译器会报错。
2.多参数构造函数
多参数构造函数与单参数类似。C++98中只支持除第一个参数外，其余参数都有默认值的情况。C++11中引进了一种新的写法。
C++98
class Date
{
public:
//除第一个参数外，其余都有默认值
//加上explicit关键字会报错
Date(int year, int month=0, int day=0)
:_year(year),
_month(month),
_day(day)
{}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d2 = 100;
return 0;
}
C++11
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 d2 ={2023,10,26};//使用大括号
return 0;
}
三.static成员
1.static成员的概念
声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化。
class A
{
public:
int getN()
{
return n;
}
private:
//类中进行声明
static int n;
};
//类外进行定义与初始化
int A::n = 0;
2.static成员的特性
- 静态成员变量必须在类外定义，定义时不添加
static关键字，类中只是声明 - 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
- 静态成员也是类的成员，受
public、protected、private访问限定符的限制
class A
{
public:
int getN()
{
return n;
}
public:
//类中进行声明
static int m;
private:
//类中进行声明
static int n;
};
//在类外进行定义与初始化
int A::n = 0;
int A::m = 0;
int main()
{
A a;
a.m += 10;
cout << a.getN() << endl;
cout << a.m<< endl;
return 0;
}
运行结果：
- 静态成员函数没有隐藏的
this指针，不能访问任何非静态成员
class B
{
public:
static int getN()
{
//错误示例
//静态函数不能直接访问非静态成员
//_a++;
return n;//可以访问静态成员
}
private:
static int n;
int _a;
};
- 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区。
【问题】
- 静态成员函数可以调用非静态成员函数吗？
答：不可以，因为静态成员函数没有this指针，不能访问任何非静态成员 - 非静态成员函数可以调用类的静态成员函数吗?
答：可以，静态成员为所有类对象所共享，this指针可以调用静态成员函数
四.友元
面向对象有三大特性——封装、继承、多态。从学习C++至今，我们一直在谈封装的重要性。但是在某些特殊的情况下，有时需要突破封装的限制。
1.概念
之前我们通过实现日期类来学习运算符重载。其中实现操作符<<（流插入）、>>（流提取）的重载时，我们遇到了难题——如果在类中实现<< >>重载，我们无法调换this指针的位置，导致实现出来的重载<<用起来怪怪的。如下：
class Date
{
//...
//使用因为返回，为了适应连续输入或输出的情况
ostream& operator<<(ostream& out)
{
out << _year << "年" << _month << "月" << _day << "日" << endl;
return out;
}
istream& operator>>(istream& in)
{
in >>_year >>_month >>_day;
return in;
}
//...
}
void Test()
{
Date d1(2023, 4, 1);
d1 << cout;//有点奇怪
}
我们当时将两个函数改为友元函数。如下：
class Date
{
//...
//声明友元函数
friend ostream& operator<<(ostream& out, const Date& d);
friend istream& operator>>(istream& in, Date& d);
//...
}
ostream& operator<<(ostream& out, const Date& d)
{
out << d._year << "年" << d._month << "月" << d._day << "日";
return out;
}
istream& operator>>(istream& in, Date& d)
{
in >> d._year >> d._month >> d._day;
return in;
}
上次我们只是浅浅的看了一下友元函数的使用。今天我们正式认识一下友元。
概念：
友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。
友元分为：友元函数和友元类。
2.友元函数
友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。
class Date
{
//...
//声明友元函数
friend ostream& operator<<(ostream& out, const Date& d);
friend istream& operator>>(istream& in, Date& d);
//...
}
ostream& operator<<(ostream& out, const Date& d)
{
out << d._year << "年" << d._month << "月" << d._day << "日";
return out;
}
istream& operator>>(istream& in, Date& d)
{
in >> d._year >> d._month >> d._day;
return in;
}
友元函数有如下几条重要的性质：
- 友元函数可访问类的私有和保护成员，但它不是类的成员函数
- 友元函数不能用
const修饰 - 友元函数可以在类定义的任何地方声明，不受类访问限定符限制
- 一个函数可以是多个类的友元函数
- 友元函数的调用与普通函数的调用原理相同
3.友元类
友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
class Time
{
//声明日期类为时间类的友元类，则在日期类中可以直接发访问时间类
friend class Date;
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 = 2023, int month = 4, int day = 9)
: _year(year)
, _month(month)
, _day(day)
{}
void SetTime(int hour, int minute, int second)
{
// 直接访问时间类私有的成员变量
_t._hour = hour;
_t._minute = minute;
_t._second = second;
}
private:
int _year;
int _month;
int _day;
Time _t;
};
友元类的重要性质如下：
-
友元关系是单向的，不具有交换性
比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但不能在Time类中访问Date类中私有的成员变量。 -
友元关系不能传递
如果C是B的友元，B是A的友元，则不能说明C是A的友元。 -
友元关系不能继承（先不做解释）
五.内部类
1.概念
如果一个类定义在另一个类的内部，这个类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
内部类有一个重要的性质——内部类天生就是外部类的友元。参照友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
2.内部类的性质
- 内部类可以定义在外部类的
public、protected、private下 - 注意内部类可以直接访问外部类中的
static成员，不需要外部类的对象或类名 sizeof(外部类)=外部类，说明外部类和内部类在空间上没有任何关系。
class A
{
private:
//声明static成员
static int k;
int n=0;
public:
class B // B天生就是A的友元
{
public:
void print(const A& a)
{
cout << k << endl;
cout << a.n << endl;
}
};
};
//初始化static成员
int A::k = 1;
int main()
{
A::B b;//定义B类对象
A a;
b.print(a);
return 0;
}
运行结果：
六.匿名对象
匿名对象，顾名思义，该对象没有名字就叫匿名对象。
匿名对象重要的性质：匿名对象的生命周期只在定义它的那一行
class A
{
public:
A(int a = 0)
:_a(a)
{}
private:
int _a;
};
int main()
{
//普通对象
A a1;
//匿名对象的定义
A();
return 0;
}
匿名对象看似鸡肋，但在某些场合下非常适用。比如，我们只想拿到类内部的某个成员的值，或只是想用一下类中的某个成员函数，为了一件简单的事而专门定义一个对象再销毁显得有点多此一举，那么就可以使用匿名对象。
class solution
{
public:
int Sum_Solution(int n)
{
int sum = 0;
for (int i = 1; i <= n; i++)
{
sum += i;
}
return sum;
}
};
int main()
{
//匿名对象的使用场景
cout << solution().Sum_Solution(100) << endl;
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;
}
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;
}
本章到此结束，码文不易，还请多多支持哦！！
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
