目录
- 一,再谈构造函数
-
- 1.初始化列表
- [2. 隐式类型转换的过程及其优化](#2. 隐式类型转换的过程及其优化)
- [3. 隐式类型转换的使用](#3. 隐式类型转换的使用)
- [4. explcit关键字](#4. explcit关键字)
- [5. 单参数和多参数构造函数的隐式类型转换](#5. 单参数和多参数构造函数的隐式类型转换)
- 二,static成员
- 三,友元
-
- [3.1 友元函数](#3.1 友元函数)
- [3.2 友元类](#3.2 友元类)
- 四,内部类
- 五,匿名对象
一,再谈构造函数
这个语法其实是对前面的构造函数的补充。最重要的是初始化列表的使用,及其特性,隐式类型转换,还有当前阶段需要了解的 explicit 关键字。
1.初始化列表
初始化列表:以一个冒号开始 ,接着是一个以逗号分隔的数据成员列表 ,每个"成员变量 "后面跟一个放在括号中的初始值或表达式。
1.1 初始化列表的使用
当我们实现一个MyQueue(用两个栈模拟一个队列)时,如果栈不具备默认构造,MyQueue也无法生成默认构造,此时MyQueue要显示实现默认构造。
如何实现呢?必须用初始化列表。
初始化列表的本质:可以理解为每个对象中成员定义的地方。
c
typedef int DataType;
class Stack
{
public:
Stack(size_t capacity )
{
_array = (DataType*)malloc(sizeof(DataType) * capacity);
if (NULL == _array)
{
perror("malloc申请空间失败!!!");
return;
}
_capacity = capacity;
_size = 0;
}
void Push(DataType data)
{
// CheckCapacity();
_array[_size] = data;
_size++;
}
~Stack()
{
if (_array)
{
free(_array);
_array = NULL;
_capacity = 0;
_size = 0;
}
}
private:
DataType* _array;
int _capacity;
int _size;
};
class MyQueue
{
public:
//初始化列表
MyQueue(int n= 20)
:_pushst(n)//自定义类型会调用构造函数
, _popst(n)
//, _size(0) //ok
{
//函数体内
_size = 0;//ok
}
private:
//声明
Stack _pushst;
Stack _popst;
int _size;
};
int main()
{
MyQueue q1(10);
MyQueue q2;//有缺省值时可以不用赋值,没传默认用缺省值
return 0;
}
1.2 有些变量只能在初始化列表中初始化,不能在函数体中初始化。
(1) const 成员变量;
const 成员变量必须在定义的地方初始化,因为它只有一次初始化机会。或是在声明时用缺省值。
(2) 引用成员变量;
引用也必须在定义的时候初始化。
(3) 没有默认构造的自定义类型成员。
因为没有默认构造时,必须显式传参调用构造函数。
c
class MyQueue
{
public:
MyQueue(int n,int& rr)//这里也可以写缺省值
:_pushst(n)//自定义类型会调用构造函数
, _popst(n)
//, _size(0) //ok
,_x (1)
,_ref(rr)
{
//函数体内
_size = 0;//ok
//_x =1; //err
}
private:
//声明
Stack _pushst;
Stack _popst;
int _size;
//const变量必须在定义的时候初始化。因为它只有一次初始化的机会
const int _x;
const int _x = 10;//在这里给缺省值ok
//引用变量必须在定义的时候初始化
int& _ref;
};
int main()
{
int xx = 0;
MyQueue q1(10,xx);
MyQueue q1(10);
int& aa = xx;
return 0;
}
1.3 初始化列表,不管你写不写,每个成员变量都会先走一遍,此时自定义类型的成员会调用默认构造(没有默认构造就编译报错),内置类型看编译器,有点会处理,有的不会处理。
1.4 在C11中我们知道可以在成员变量声明时给缺省值,实际上这个缺省值就是给初始化列表用的。但是与此同时,如果在初始化列表中给定了值,就以列表中的为准,与缺省值无关。
c
class MyQueue
{
public:
//实践总结:尽可能使用初始化列表初始化,不方便再使用函数体初始化
MyQueue()
:_pushst(10)
,_ptr((int*)malloc(40)) //ok
{
_size = 2;
}
private:
//声明
Stack _pushst;
Stack _popst;
//这里的缺省值是1,但是初始化列表中是2,此时_size = 2
int _size = 1;
int* _ptr;
};
1.5 成员变量 在类中声明次序 就是其在初始化列表中的初始化顺序,与其在初始化列表中的先后次序无关。
比如下面的代码,运行结果是:1 ,随机值。
这是因为先声明的是_a2 ,所以在初始化时会先走_a2(_a1)这条语句,而此时_a1没有初始化,是随机值,所以_a2是随机值。再初始化_a1。
c
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();
}
2. 隐式类型转换的过程及其优化
隐式类型转换:把内置类型转换为自定义类型。
优化:在一个表达式中,编译器遇到构造 + 拷贝构造时,会优化成直接构造。
c
class A
{
public:
//单参数构造函数
A(int a)
:_a(a)
{
cout << "A(int a)" << endl;
}
//拷贝构造
A(const A& aa)
:_a(aa._a)
{
cout << "A(const A& aa)" << endl;
}
private:
int _a;
};
int main()
{
A aa1(1);
//拷贝构造
A aa2 = aa1;//ok
//过程:先用3构造了一个A的临时对象,再用临时对象去拷贝构造给aa3
//优化:在一个表达式中,编译器遇到构造 + 拷贝构造,会优化成直接构造
A aa3 = 3;
//A& raa = 4;//err
//当用引用时,由于用3构造了一个临时对象,临时对象具有常性,所以加const
//过程:这里只用3构造了一个临时对象,没有拷贝构造
//raa引用的是类型转换中用3构造的临时对象
const A& raa = 4;//ok
return 0;
}
3. 隐式类型转换的使用
在C++初阶,隐式转换使用的较少,但是在以后是很有用的,使用起来很方便,简洁。
c
class A
{
public:
A(int a)
:_a1(a)
, _a2(_a1)
{}
void Print()
{
cout << _a1 << " " << _a2 << endl;
}
private:
int _a2;
int _a1;
};
class Stack
{
public:
//方式1:ok
//void Push(A& aa)
//{
// //.......
//}
//方式2:ok
void Push(const A& aa)
{
//....
}
//.....
};
int main()
{
Stack st;
//方式1:会进行先构造,后拷贝构造
A a1(1);
st.Push(a1);
//方式2:10进行了隐式类型转换,时代码更简洁
st.Push(10);
return 0;
}
4. explcit关键字
作用:禁止构造函数的隐式转换。
看看下面的代码,如果在构造函数前加上explcit,运行结果:
c
class A
{
public:
//单参数构造函数
explicit A(int a)
//A(int a)
:_a(a)
{
cout << "A(int a)" << endl;
}
//拷贝构造
A(const A& aa)
:_a(aa._a)
{
cout << "A(const A& aa)" << endl;
}
private:
int _a;
};
int main()
{
A aa1(1);
//拷贝构造
A aa2 = aa1;
A aa3 = 3;
const A& raa = 4;
return 0;
}
5. 单参数和多参数构造函数的隐式类型转换
多参数构造函数的隐式类型转换的过程与第2点中解释的单参数类似。
c
class A
{
public:
//单参数构造函数
//explicit A(int a)
A(int a)
:_a(a)
{
cout << "A(int a)" << endl;
}
//多参数构造函数
A (int a1,int a2)
:_a(0)
,_a1(a1)
,_a2(a2)
{}
//拷贝构造
A(const A& aa)
:_a(aa._a)
{
cout << "A(const A& aa)" << endl;
}
private:
int _a;
int _a1;
int _a2;
};
int main()
{
A aaa1(1, 2);
A aaa2 = { 1,2 };//传参时要用花括号
const A& aaa3 = { 3,2 };
return 0;
}
二,static成员
对象中只存成员变量,不存静态成员变量,静态成员变量在静态区,也不存函数,函数指针,它们在代码段。
1.静态成员变量
特性:
(1) 静态成员变量在静态区,不在对象中;
(2) 静态成员变量不能给缺省值,因为缺省值是给初始化列表用的,它在静态区,不在对象中,不走初始化列表;
(3) 静态成员变量的定义在全局,如果只有声明,没有定义,会报错!
当用sizeof计算对象的大小时,结果是:8
这就说明 aa1 对象中只有_a1,_a2,没有 _scount。
c
class A
{
public:
A()
{
cout << "A()" << endl;
}
A(const A& t)
{
cout << "A(const A& t)" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
//声明
int _a1;
int _a2;
public:
//在静态区,不在对象中
//不能给缺省值,因为缺省值是给初始化列表用的
//它在静态区,不在对象中,不走初始化列表
static int _scount;
};
//静态成员变量的定义(如果只有声明,没有定义,会报错!)
int A::_scount = 1;
int main()
{
A aa1;
cout << sizeof(aa1) << endl;//8
//如果它是公有的,就可以按如下访问
//aa1._scount++;
//cout << A::_scount << endl;
return 0;
}
静态成员变量的特点:它属于整个类,属于所有对象。
使用静态成员变量可以统计一共创建了多少个类对象:
因为所有的对象都要走构造或者拷贝构造:在它们之中++,统计累计创建了多少个类对象;
当走完析构函数:统计现在还有多少对象存活。
代码实现如下:
c
class A
{
public:
A()
{
++_scount;
}
A(const A& t)
{
++_scount;
}
~A()
{
--_scount;
}
private:
//声明
int _a1;
int _a2;
public:
static int _scount;
};
int A::_scount = 0;
int main()
{
A aa1;
//cout << sizeof(aa1) << endl;//8
A aa2;
A aa3;
cout << A::_scount << endl;
return 0;
}
2.静态成员函数
第1点中对静态变量的使用都是它在公有的前提下,那么它在私有时该如何访问呢?就要使用静态成员函数了。
特点:static修饰成员函数,没有this指针,意味着只能访问静态成员,不能访问其他的成员变量。
c
class A
{
public:
A()
{
++_scount;
}
A(const A& t)
{
//但是非静态的可以调用静态的
GetCount();//ok
++_scount;
}
~A()
{
--_scount;
}
//特点:static修饰成员函数,没有this指针,意味着只能访问静态成员
//不能访问其他的成员变量
static int GetCount()
{
return _scount;
}
private:
//声明
int _a1;
int _a2;
static int _scount;
};
int A::_scount = 0;
int main()
{
A aa1;
A aa2;
A aa3;
//调用方式
cout << A::GetCount() << endl;
return 0;
}
3. static 成员的应用
代码实现如下:
c
#include <regex>
class Sum
{
public:
Sum()
{
_ret += _i;
_i++;
}
//由于静态成员变量是私有的,要拿到它们的值,
//就要使用静态成员函数
static int GetRet()
{
return _ret;
}
private:
static int _i;
static int _ret;
};
//静态成员变量要在全局定义,要指定类域
int Sum::_i = 1;
int Sum::_ret = 0;
class Solution {
public:
int Sum_Solution(int n) {
//变长数组
//定义一个Sum类的数组,调用n次构造函数
Sum arr[n];
return Sum::GetRet();
}
};
三,友元
友元提供了一种突破封装 的方式,有时提供了便利。但是友元会增加耦合度,破坏了封装,所以友元不宜多用。
3.1 友元函数
问题:
现在尝试去重载operator<<,然后发现没办法将operator<<重载成成员函数。
原因:
- 因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了 。但是实际使用中cout需要是第一个形参对象,才能正常使用。所以要将operator<<重载成全局函数。但又会导致类外没办法访问成员,此时就需要友元来解决。operator>>同理。
c
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关键字。
c
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;
}
说明:
- 友元函数 可访问类的私有和保护成员,但不是类的成员函数;
- 友元函数不能用const修饰,因为const修饰this指针;
- 友元函数 可以在类定义的任何地方声明,不受类访问限定符限制;
- 一个函数可以是多个类的友元函数;
- 友元函数的调用与普通函数的调用原理相同
3.2 友元类
友元类的所有成员函数都可以是另一个类的友元函数,都可以访问另一个类中的非公有成员。
c
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;
}
private:
int _year;
int _month;
int _day;
Time _t;
};
特性:
- 友元关系是单向的,不具有交换性 ;
比如上述Time类和Date类,在Time类中声明Date类为其友元类,那么可以在Date类中直接
访问Time类的私有成员变量,但想在Time类中访问Date类中私有的成员变量则不行。- 友元关系不能传递 ;
如果C是B的友元, B是A的友元,则不能说明C时A的友元。- 友元关系不能继承,在继承位置再给大家详细介绍。
四,内部类
概念:如果一个类定义在另一个类的内部,这个内部类就叫做内部类。
内部类是一个独立的类,它不属于外部类,它仅仅是受到外部类域的限制,更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
注意:内部类就是外部类的友元类,参见友元类的定义,内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
c
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
}
};
};
int A::k = 1;
int main()
{
A::B b;
b.foo(A());
return 0;
}
特性:
- 内部类可以定义在外部类的public、protected、private都是可以的。
- 注意内部类可以直接访问外部类中的static成员,不需要外部类的对象/类名。
- sizeof(外部类)=外部类,和内部类没有任何关系。
五,匿名对象
匿名对象的生命周期只在当前这一行,即用即销毁。
c
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;
}
};
int main()
{
A aa1;
// 不能这么定义对象,因为编译器无法识别下面是一个函数声明,还是对象定义
//A aa1();
// 但是我们可以这么定义匿名对象,匿名对象的特点不用取名字,
// 但是他的生命周期只有这一行,我们可以看到下一行他就会自动调用析构函数
A();
A aa2(2);
// 匿名对象在这样场景下就很好用,当然还有一些其他使用场景,这个我们以后遇到了再说
Solution().Sum_Solution(10);
return 0;
}