c++类与对象(下)
文章目录
- 前言
- 一、再谈构造函数
-
- 1、构造函数体赋值
- 2、初始化列表
- 3、explicit关键字
- 二、static成员
-
- 1、概念
- 2、特征
- 四、友元
-
- 1、友元函数
- 2、友元类
- 五、内部类
- 六、匿名对象
- 七、拷贝对象时的一些编译器优化
-
- 1、函数传参的优化
- 2、传值返回的优化
- 3、总结
前言
一、再谈构造函数
1、构造函数体赋值
在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。虽然我们之前写的构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。
class Date
{
public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
当我们定义类的成员时，我们可能会定义const修饰的成员变量，而使用const修饰的变量必须在定义的位置就完成初始化。而我们在下面的代码中虽然在声明时给了_x缺省值，但以后_x变量就不可以改变了，而且有时候我们并不想给_x赋值为缺省值。所以必须给每个成员变量找一个定义的位置，然后在这个位置将这些声明的变量统一进行初始化。
所以c++中在构造函数中还有个初始化列表的概念。
class A
{
private:
//成员变量的声明
int _a1;
int _a2;
//这只是给_x的缺省值，这样定义以后_x变量的值就不能再改变了
const int _x = 1;
};
int main()
{
A aa;
//const修饰的变量必须在定义的位置初始化
const int i = 0;
return 0;
}
2、初始化列表
哪个对象调用构造函数，初始化列表是它所有成员变量定义的位置。
初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。有了初始化列表，上述我们遇到的问题就可以解决，即我们可以在初始化列表中对const修饰的成员变量进行初始化。并且不管是否显示的在初始化列表中对类成员变量进行初始化，编译器都会在初始化列表中对这些变量进行定义初始化，所以说初始化列表才是真正对类成员变量进行初始化的地方。
class A
{
public:
A()
//初始化列表位置，在该位置对const修饰的_x进行初始化
:_x(5),
_a1(2) //此时_a1的缺省值就不会生效了
//虽然在下面没有写 _a2(4)来给_a2初始化，但是_a2在声明时有缺省值，
//所以此时编译器会在初始化列表自动对_a2进行初始化为缺省值
//即 _a2(1)
{
}
private:
//成员变量的声明
int _a1 = 1;
int _a2 = 1;
//这只是给_x的缺省值，这样定义以后_x变量的值就不能再改变了
const int _x;
};
int main()
{
A aa;
//const修饰的变量必须在定义的位置初始化
const int i = 0;
return 0;
}
1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2. 类中包含以下成员，必须放在初始化列表位置进行初始化：
(1). 引用成员变量
(2) .const成员变量
(3). 自定义类型成员(且该类没有默认构造函数时
3. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。
class B
{
public:
//此时类B的构造函数为有参数的构造函数，而默认构造是不需要传参就可以调用的那一个构造函数
//所以类B没有默认构造函数，此时如果在A类中声明了B类类型的对象_bb，就需要在A的初始化列表中将_bb初始化
B(int a)
:_b(0)
{
cout << "B()" << endl;
}
private:
int _b;
};
class A
{
public:
A()
//初始化列表位置，在该位置对const修饰的_x进行初始化
:_x(5),
_a1(2),
_ref(_a1),
_bb(2)
//_a1(3) //每个成员变量在初始化列表只能初始化一次，所以该语句会报错
//虽然在下面没有写 _a2(4)来给_a2初始化，但是_a2在声明时有缺省值，
//所以此时编译器会在初始化列表自动对_a2进行初始化为缺省值
//即 _a2(1)
{
}
private:
//成员变量的声明
int _a1 = 1;
int _a2 = 1;
//const成员变量，引用成员变量，自定义类型成员变量(并且该类没有默认构造函数时)都必须放在初始化列表位置进行初始化
const int _x;
int& _ref;
B _bb;
};
int main()
{
A aa;
//const修饰的变量必须在定义的位置初始化
const int i = 0;
return 0;
}
4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后
次序无关。
例如下面的代码中，虽然在初始化列表中的顺序为先对_a1初始化，再对_a2初始化，但是因为在声明时是先声明的_a2，然后再声明的_a1。所以其实在初始化列表中先执行的是_a2(_a1)，然后再执行_a1(a)，所以该程序的结果为_a1为1，_a2为随机值。
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();
return 0;
}
其实类中声明的所有成员变量(包括内置类型和自定义类型)都会走初始化列表，因为那里才是成员变量定义的地方。内置类型成员虽然不需要显示的在初始化列表出现，但是它们的定义也是在初始化列表中定义为随机值，自定义类型成员也会在初始化列表中定义，即会自动调用该自定义类型的默认构造函数(无参构造函数)，如果没有默认构造函数，就需要显示的在初始化列表中调用自定义类型的有参构造函数。
3、explicit关键字
构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用。
我们知道当内置类型发生隐式类型转换时，其实在中间生成了一个临时变量。例如下面的例子中。
那么当我们将自定义类型进行这样的隐式类型转换时，是不是也会像内置类型一样中间生成临时对象呢？
答：按逻辑来说应该是这样的，但是我们可以分析一下，如果生成临时对象的话，需要先调用构造函数创建一个临时对象tmp，然后又调用一次拷贝构造函数将tmp拷贝给aa2对象，即发生了两次函数的调用。所以其实编译器会对这个过程进行优化，即会将构造+拷贝构造直接优化为构造。即优化为A aa2(1)这样的效果。但是需要注意的是只有类的构造函数为单个参数或者除第一个参数无默认值其余均有默认值时，才具有类型转换的作用(c++98语法)。
A类的构造函数为单个参数时。
A类的构造函数中除第一个参数无默认值其余均有默认值。
而当我们不想让构造函数具有类型转换功能时，就可以使用explicit关键字修改构造函数，此时如果再像上面那样直接使用A aa2 = 1来创建对象时就会发生错误，因为此时构造函数不可以进行类型转换了。即会直接报出不存在从int转换到A的适当构造函数的错误。即用explicit修饰构造函数，将会禁止构造函数的隐式转换。
上面的语法其实是C++98的语法，C++98语法中只支持单参数隐式类型转换，但是在C++11中支持了多参数隐式类型转换。即如果构造函数的参数不为单参数也可以进行隐式类型转换。
二、static成员
1、概念
声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化。
我们可以想一下这个问题：实现一个类，可以计算出该程序中共创建了多少个类对象？
我们看到这个问题的第一个想法应该就是创建一个全局变量，然后在该类的构造函数和拷贝函数中都对这个全局变量进行+1。但是这样写虽然可以得到这个程序中创建了多少个类对象，但是num为全局变量，是可以随意修改的，所以这个办法是很不安全的。
int num = 0;
class A
{
public:
A(int a = 0)
{
++num;
}
A(const A& aa)
{
++num;
}
};
void func(A a)
{
}
int main()
{
A aa1(5);
A aa2(aa1);
A aa3 = aa1;
func(aa1);
cout << num << endl;
return 0;
}
2、特征
1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区。
2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明。
3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问。
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员。
5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制。
所以上面的代码我们就可以使用static将num设为静态成员。此时静态成员num不属于某个对象，它属于所有的对象，属于整个类。但是将num设置为静态成员的话还会遇到一个问题，即如果将num声明为private时，外面就不可以访问到num变量，而如果将num声明为public时，此时num又变得不安全，即可以通过对象.num或者A::num修改num的值。
class A
{
public:
A(int a = 0)
{
++num;
}
A(const A& aa)
{
++num;
}
//private:
//静态成员变量不属于某个对象，属于所有对象，属于整个类，即创建出来的所有对象都共享这一个静态成员变量
static int num;
};
//A类中的静态成员变量定义初始化
//静态成员变量一定要在类外进行初始化
int A::num = 0;
void func(A a)
{
}
int main()
{
A aa1(5);
A aa2(aa1);
A aa3 = aa1;
func(aa1);
//因为静态成员num属于所有对象，属于整个类，所以A::num也可以访问num
cout << aa1.num << endl;
cout << A::num << endl;
//此时并没有对nullptr进行解引用
A* ptr = nullptr;
cout << ptr->num << endl;
return 0;
}
为了解决上面的问题，我们可以再定义一个GetNum()函数用来返回num的值，但是此时如果我们想到的num的值就还需要实例化一个对象，然后再调用该对象的GetNum()方法得到num的值，这又显得很不方便。所以我们可以将GetNum()函数也定义为静态成员函数，即static int GetNum()。这样不但可以通过对象.GetNum()来调用GetNum()函数，也可以通过A::GetNum()来调用GetNum()函数。需要注意的是：== 静态成员函数中不能访问非静态成员变量，也不能调用非静态成员函数，因为函数内没有this指针。非静态成员函数中可以访问静态成员变量，也可以调用静态成员函数。==
class A
{
public:
A(int a = 0)
{
//非静态成员函数中可以访问静态成员变量，也可以调用静态成员函数
GetNum();
++num;
}
A(const A& aa)
{
//非静态成员函数中可以访问静态成员变量
++num;
}
void Print()
{
cout << _a1 << endl;
}
//静态成员函数 -- 没有this指针
static int GetNum()
{
//静态成员函数中不能访问非静态成员变量，也不能调用非静态成员函数，因为函数内没有this指针。
//_a1;
//Print();
return num;
}
private:
//静态成员变量不属于某个对象，属于所有对象，属于整个类，即创建出来的所有对象都共享这一个静态成员变量
static int num; //声明
int _a1;
};
//A类中的静态成员变量定义初始化
//静态成员变量一定要在类外进行初始化
int A::num = 0;
void func(A a)
{
}
int main()
{
A aa1(5);
A aa2(aa1);
A aa3 = aa1;
func(aa1);
cout << aa1.GetNum() << endl;
cout << A::GetNum() << endl;
//此时并没有对nullptr进行解引用
A* ptr = nullptr;
cout << ptr->GetNum() << endl;
return 0;
}
四、友元
友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。
友元分为：友元函数和友元类
1、友元函数
友元函数我们在前面实现Date日期类时其实已经用到了，在我们写<<流插入符和>>流提取符的重载函数时，因为因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置，所以我们需要将这两个符号的重载函数设置为全局函数，而设置为全局函数后，又不能访问Date类中的私有成员变量。所以我们用到了友元函数，即在Date类中将这两个符号的重载函数设置为了友元函数，这样就可以在这两个函数中访问Date类中的私有成员变量了。
class Date
{
public:
Date(int year, int month, int day)
: _year(year)
, _month(month)
, _day(day)
{}
// d1 << cout; -> d1.operator<<(&d1, cout); 不符合常规调用
// 因为成员函数第一个参数一定是隐藏的this，所以d1必须放在<<的左侧
ostream& operator<<(ostream& _cout)
{
_cout << _year << "-" << _month << "-" << _day << endl;
return _cout;
}
private:
int _year;
int _month;
int _day;
};
友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。
友元函数可访问类的私有和保护成员，但不是类的成员函数
友元函数不能用const修饰(因为友元函数中没有this指针)
友元函数可以在类定义的任何地方声明，不受类访问限定符限制
一个函数可以是多个类的友元函数
友元函数的调用与普通函数的调用原理相同
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;
}
2、友元类
友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
友元关系是单向的，不具有交换性。
比如Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
友元关系不能传递，如果C是B的友元， B是A的友元，则不能说明C时A的友元。
class Time
{
friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类
中的私有成员变量
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;
}
private:
int _year;
int _month;
int _day;
Time _t;
};
五、内部类
概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类并不能越界访问内部类的私有成员。
可以在下面的例子中看到A类类型对象中并没有B类的成员b，这时因为A和B在空间上是独立的。
内部类B写在A里面和写在全局没有区别，只是受A的类域限制，所以此时如果想要定义一个B类，就要去A类的类作用域里面找。如果去全局找的话，是找不到B类的。
如果将B类在A类中定义为私有，则外面就无法访问到B，也不能创建B对象，即此时B类就只能在A类中创建。
注意：内部类就是外部类的友元类，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。即内部类B天生就是A的友元类，所以在B中可以访问A的私有成员，但A不能访问B的私有成员。
特性：
1. 内部类可以定义在外部类的public、protected、private都是可以的。
2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
3. sizeof(外部类)=外部类，和内部类没有任何关系。
class A
{
public:
void Print2()
{
B bb;
//但A不能访问B的私有成员。
//cout << bb.b << endl;
}
private:
int h = 1;
static int num;
//内部类
class B
{
public:
void Print(const A& a)
{
//内部类B天生就是A的友元类，所以在B中可以访问A的私有成员，但A不能访问B的私有成员。
cout << a.h << endl;
// 内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
cout << num << endl;
}
private:
int b = 2;
};
};
int A::num = 0;
int main()
{
A aa;
cout << sizeof(aa) << endl;
//定义一个内部类B，需要标明B类在A类的类作用域中
//A::B bb;
return 0;
}
六、匿名对象
临时对象和匿名对象都具有常型，匿名对象的生命周期只在这一行。
class A
{
public:
A()
:_a1(2)
, _a2(4)
{
++num;
}
~A()
{
cout << "~A()"<<endl;
}
int GetNum()
{
return num;
}
private:
int _a1;
int _a2;
static int num;
};
int A::num = 0;
int main()
{
//不能这样定义对象，因为编译器无法识别下面是一个函数声明还是对象定义
//A aa1();
//但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，
// 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数
A aa2;
//当我们想查看创建了多少对象时，我们还需要创建一个对象，然后通过该对象调用GetNum()方法来得到num
cout << aa2.GetNum() << endl;
//我们也可以创建一个匿名对象，该匿名对象的生命周期只在这一行
cout << A().GetNum() << endl;
return 0;
}
七、拷贝对象时的一些编译器优化
1、函数传参的优化
class A
{
public:
A(int a =10)
:_a(a)
{
cout << "构造函数" << endl;
}
A(const A& a)
{
_a = a._a;
cout << "拷贝构造函数" << endl;
}
~A()
{
cout << "析构函数" << endl;
}
private:
int _a;
};
void func1(A aa)
{
}
void func2(const A& aa)
{
}
int main()
{
A aa1 = 1; //构造 + 拷贝构造 -> 优化为直接构造
func1(aa1); //无优化
//按逻辑应该是先将2构造为A类型的临时对象tmp，然后调用func1时调用拷贝构造将tmp拷贝给对象aa
func1(2); //构造 + 拷贝构造 -> 优化为直接构造
func1(A(3)); // 构造 + 拷贝构造 -> 优化为直接构造
cout << "----------------------------" << endl;
//因为为传引用传参，所以不会进行拷贝函数的构造，所以就不会进行优化
func2(aa1); //无优化
func2(2); //无优化
func2(A(3)); //无优化
return 0;
}
2、传值返回的优化
传值返回在返回时会调用拷贝构造函数，但是编译器进行了优化。
class A
{
public:
A(int a = 10)
:_a(a)
{
cout << "构造函数" << endl;
}
A(const A& a)
{
_a = a._a;
cout << "拷贝构造函数" << endl;
}
~A()
{
cout << "析构函数" << endl;
}
private:
int _a;
public:
int b;
};
A func3()
{
A aa; //构造函数
aa.b = 3;
//传值返回在返回时会调用拷贝构造函数，但是编译器进行了优化
return aa; //构造 + 拷贝构造 -> 优化为构造
}
A func4()
{
return A(); //构造匿名对象
}
int main()
{
func3();
A aa1 = func3(); //拷贝构造 + 拷贝构造 -> 优化为一个拷贝构造
func4(); //构造+拷贝构造 -> 优化为构造
A aa2 = func4(); //构造+拷贝构造+拷贝构造 -> 优化为构造
return 0;
}
3、总结
函数传参总结：尽量使用const &传参。
对象返回总结：
(1). 接收返回值对象，尽量拷贝构造方式接收，不要赋值接收。
A aa1 = func3();
//而不要分开写，因为分开写就不会进行优化了
A aa1;
aa1 = func3();
(2). 函数中返回对象时，尽量返回匿名对象。
A func4()
{
//分开写不会进行优化
//A aa;
//reutrn aa;
//一起写才会进行优化
return A();
}