1.构造函数赋值和初始化列表
#include<iostream>
using namespace std;
class date
{
public:
date(int year = 1, int month = 1, int day = 1)
{
//函数体赋值
_year = year;
_month = month;
_day = day;
}
date(int year = 1, int month = 1, int day = 1)
:_year(year), _month(month), _day(day)
{
//初始化列表
}
private:
int _year;
int _month;
int _day;
};
int main()
{
return 0;
}
为什么要有初始化列表存在呢？
引用类成员
const类成员变量
自定义类型成员函数(该类没有默认成员函数)
必须放在初始化列表位置初始化
#include<iostream>
using namespace std;
class A
{
A(int a)
:_a(a)
{
}
private:
int _a;
};
class B
{
public:
B(int a, int ret)
:_aobj(a)
,_ret(ret)
,_n(10)
{
//初始化列表
}
private:
int& _ret;//引用
const int _n;//const
A _aobj;//没有默认构造函数
};
int main()
{
return 0;
}
引用、const修饰的必须在定义的时候初始化
而自定义类型 没有默认构造函数即不用传参就可以调用的函数 (没有给它赋值)
也就需要定义的时候初始化
例题
#include<iostream>
using namespace std;
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;
}
正常来说，结果应为 1 1，但是为什么变成 1 随机值？
成员变量在类中声明次序就是初始化列表的初始化顺序，与其初始化列表中的先后次序无关
_a2声明在前面
所以先初始化 _a2,先进行 _a2(_a1)，而此时的_a1为随机值，所以_a2为随机值
然后才进行 _a1(a)，_a1赋值成1
最终结果 为 1 随机值
隐式类型转换
#include<iostream>
using namespace std;
class date
{
public:
date(int year)
:_year(year)
{
}
private:
int _year;
};
int main()
{
date d1(1);//构造
date d2 = 2;// 用2构造了一个临时对象，将用临时对象拷贝构造d2
date d3(d1);//拷贝构造
return 0;
}
date d2=2，相当于 date tmp(2)，使用2构造一个临时对象tmp，
d2(tmp)，再使用 tmp拷贝构造d2
当我们改成引用后，发现不可以实现
其中包含临时对象tmp，临时对象具有常性，要加 const修饰
explicit的使用
#include<iostream>
using namespace std;
class date
{
public:
explicit date(int year)
:_year(year)
{
}
private:
int _year;
};
int main()
{
date d1(1);//构造
date d2 = 2;// 用2构造了一个临时对象，将用临时对象拷贝构造d2
date d3(d1);//拷贝构造
return 0;
}
若不想要隐式类型转换发生，加入关键字 explicit
static用法
例题
设计一个类A，可以计算这个类总计产生了多少对象？
自定义一定要调用 构造函数 或者 拷贝构造
方法1
设计一个全局变量n 用于统计
#include<iostream>
using namespace std;
int n = 0;//设计一个全局变量用于统计
class A
{
public:
A()//构造
{
++n;
}
A(const A& d)//拷贝构造
{
++n;
}
};
A f1(A a)
{
return a;
}
int main()
{
A a1;
A a2;
f1(a1);
f1(a2);
cout << n << endl;//6
return 0;
}
说明一共产生了6个对象
A a1 ,A a2 ,共产生 2个对象
f1(a1)时，将a1传值给 a ，属于值传递，发生了拷贝调用
由于 f1 函数 是 值返回 ，所以 会再次发生 拷贝调用，生成一个临时对象
所以 f1(a1)共产生 2个对象
同理 ， f1(a2)也产生 2个对象
共有 产生6个对象
方法2
为了防止n能随意修改
使用static修饰
#include<iostream>
using namespace std;
class A
{
public:
A()//构造
{
++n;
}
A(const A& d)//拷贝构造
{
++n;
}
static int getN()//使用static修饰后，没有默认this指针，函数中也不能访问非静态成员
{
return n;
}
private:
static int n;//声明，属于类的所有对象，存于静态区
};
int A::n = 0;//定义
A f1(A a)
{
return a;
}
int main()
{
A a1;
A a2;
f1(a1);
f1(a2);
cout << A::getN() << endl;//6
return 0;
}
使用static，将n放在静态区中，属于类中的所有对象
