1.深入构造函数
(1)我们要了解一件事情:
构造函数调用之后,对象中已经有了一个初始值,但是不能将其称为对对象中成员变量
的初始化,构造函数体中的语句只能将其称为赋初值,而不能称作初始化。因为初始化只能初始
化一次,而构造函数体内可以多次赋值。
(2)初始化列表
初始化列表:以一个冒号开始,接着是一个以逗号分隔的数据成员列表,每个"成员变量"后面跟
一个放在括号中的初始值或表达式。
位置就在构造函数的函数上面
class Date
{
public:
Date(int year, int month, int day,int& rr)
: _year(year)
, _month(month)
, _day(day)
,arr((int*)malloc(sizeof)*10)
,ret(rr)
, i(1)
{
}
private:
int _year;
int _month;
int _day;
int *arr;
int& ret;
const int i
};
【注意】
1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2. 类中包含以下成员,必须放在初始化列表位置进行初始化:
引用成员变量 const成员变量(两者只有在定义时有一次机会初始化)
自定义类型成员(且该类没有默认构造函数时)
3.成员变量在类中声明次序就是其在初始化列表中的初始化顺序,与其在初始化列表中的先后
次序无关
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();
}
请问此时的输出是什么 答案是 1 和随机值 ,按照上面说的,先开始_a2的初始化,所以是随机值
class A
{
public:
A(int n)
:a(n)
{
}
private:
int a;
}
int main()
{
//调用有参的构造函数
A aa1(1);
//拷贝函数
A aa2 = aa1;
A aa3 = 3;
const A& aa4(4);//移
return 0;
}
此时我们看一下对类A的一些操作,前两个没什么好说的,第三个我们看,直接把3给A了,int给自定义类型,这是什么情况,其实这是隐式类型的转换。也就是说3先进行了调构造函数,接着再拷贝给aa3,但是我们在这里值得一提的是 系统做了优化 直接调用构造函数,因为这是隐式类型转化 有单参数函数在,可以直接调用,当然多参函数也可以,这里是单参函数
第四个是因为,隐式类型转换的时候具有常性(类型转换就有临时对象的产生,比如double转int),所以引用的时候,权限不可以放大,要加const
2 static 成员
问题:想求一个程序中有多少个A类
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;
A a2;
A a3(a1);
cout << A::GetACount() << endl;
}
int main()
{
TestA();
return 0;
}
当 _scount是静态区的成员时,不在类的里面,当我们每个类的创建时候都会进行调用构造函数或者拷贝构造函数,所以我们只要知道_scount的值就会知道有多个类
在这个问题中,如果_scount是public那么可以直接访问它的值,但这样不好
(2)特性:
1. 静态成员为所有类对象所共享,不属于某个具体的对象,存放在静态区
2. 静态成员变量必须在类外定义,定义时不添加static关键字,类中只是声明
3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
4. 静态成员函数没有隐藏的this指针,不能访问任何非静态成员
5. 静态成员也是类的成员,受public、protected、private 访问限定符的限制
3.友元类
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;
};
在谁里面写frined 类,就是可以读谁,Time里面写了class Date,就是Date可以访问到Time 的成员
!:
友元函数可访问类的私有和保护成员,但不是类的成员函数
友元函数不能用const修饰
友元函数可以在类定义的任何地方声明,不受类访问限定符限制
一个函数可以是多个类的友元函数
友元函数的调用与普通函数的调用原理相同
!:
友元关系是单向的,不具有交换性。
比如上述Time类和Date类,在Time类中声明Date类为其友元类,那么可以在Date类中直接
访问Time类的私有成员变量,但想在Time类中访问Date类中私有的成员变量则不行。
友元关系不能传递
如果C是B的友元, B是A的友元,则不能说明C时A的友元。