构造函数
构造函数体赋值
在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值
class Date
{
public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
构造函数的作用是赋初值，并不是初始化。
初始化的概念是只能初始化一次，而构造函数体内可以多次赋值
初始化列表
相比于整体定义是对象实例化
初始化列表是对对象中每个成员定义
初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个成员变量后面跟一个放在括号中的初始值或表达式
用途：对对象中每个成员定义初始化
每个成员变量都会走初始化列表，即使不实现初始化列表，也会走
如果实现了初始化列表，就使用
如果没有实现初始化列表，则对于内置类型，自定义类型处理分别如下
内置类型：存在缺省值便使用，不存在便使用随机值
自定义类型：调用其默认的构造函数，如果没有默认的构造函数则报错
class Date
{
public:
Date(int year, int month, int day)
:_year(year)
,_month(month)
,_day(day)
{
}
private:
int _year;
int _month;
int _day;
};
- 每个成员变量在初始化列表中只能出现一次（初始化只能初始化一次）
- 类中包含以下成员，必须放在初始化列表位置进行初始化
引用成员变量
const成员变量
若不使用初始化列表结果是如何呢？
class M
{
public:
M()
{
}
private:
const int _n;
int& _m;
};
int main()
{
M m;
return 0;
}
报错是无疑的
不论是在类中，还是在局部函数中，由const修饰的变量在定义时都是必须进行初始化的；引用也是如此在定义时必须进行初始化
自定义类型成员（该类中没有默认的构造函数）
-
尽量使用初始化列表初始化，因为不管是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化
-
成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关
class M
{
public:
M(int m)
:_m2(m)
,_m1(_m1)
{
}
void Print()
{
cout << _m1 << " " << _m2 << endl;
}
private:
int _m1;
int _m2;
};
int main()
{
M m(1);
m.Print();
return 0;
}
explicit关键字
构造函数不仅可以构造和初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转化的作用
class Date
{
public:
Date(int year)
:_year(year)
{
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2022);
Date d2 = 2022;
}
explicit修饰构造函数，禁止类型转换
class Date
{
public:
explicit Date(int year, int month = 1, int day = 1)
:_year(year)
,_month(month)
,_day(day)
{
}
Date& operator=(const Date& d)
{
if (this != &d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
return *this;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2022);
Date d2 = 2022;
}
用explicit修饰构造函数，将会禁止构造函数的隐式转换
static成员
概念
声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。
静态成员变量一定要在类外进行初始化
静态成员变量
class M
{
public:
//构造函数
M(int a = 0)
:_a(a)
{
N++;
}
//拷贝构造
M(const M& m)
:_a(m._a)
{
N++;
}
int GetN()
{
return N;
}
private:
int _a;
static int N;
};
int M::N = 0;
int main()
{
M m1 = 1;
cout << m1.GetN() << endl;
return 0;
}
由于静态成员变量是类的私有成员，所以通过函数GetN()获得静态成员变量的数值；这里也进行隐式类型转换，但是运行结果却与预期有些差别，为什么呢？后面将会介绍编译器的优化，可以解决此处的疑惑
静态成员函数
class M
{
public:
//构造函数
M(int a = 0)
:_a(a)
{
N++;
}
//拷贝构造
M(const M& m)
:_a(m._a)
{
N++;
}
static int GetN()
{
return N;
}
private:
int _a;
static int N;
};
int M::N = 0;
int main()
{
M m1 = 1;
cout << m1.GetN() << endl;
cout << M::GetN() << endl;
return 0;
}
使用静态成员函数，只能对静态成员变量进行访问，因为静态成员函数没有this指针，对于静态成员变量访问的方式上面两种都可以：
1.实例化对象，通过对象进行访问
2.直接通过域限定符访问
特性
- 静态成员是所有类对象所共享的，不属于某个具体的对象，存放在静态区
- 静态成员变量必须在类外定义，定义时不添加
static关键字，类中只是声明 - 类静态成员可用类名：：静态成员或者对象.静态成员进行访问
- 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
- 静态成员也是类的成员，受访问限定符的限制
友元
友元提供了一种突破封装的方式，提供了便利。不过友元增加耦合度，破坏了封装，所以友元不宜多用
友元分为：友元函数，友元类
友元函数
先引入一中情景，重载operator<<，由于隐含的this指针默认是第一个参数，而cout的输出流对象就只能作为第二参数，但是在操作台中输出流对象作为第一个参数才能正常使用，所以需要将operator<<重载为全局函数，但是如此操作就会造成类外不能访问私有成员变量，友元便可以解决这个问题
class Date
{
public:
Date(int year, int month, int day)
:_year(year)
,_month(month)
,_day(day)
{
}
//成员函数第一个参数是隐藏的this指针，就会变成 d1<<cout
ostream& operator<<(ostream& _cout)
{
_cout << _year << " " << _month << " " << _day << endl;
return _cout;
}
private:
int _year;
int _month;
int _day;
};
d1<<cout
与常规相反，而且使用起来也不方便，所以需要将其重载为全局函数
友元函数可以直接访问类的私有成员，友元函数是定义在类外的普通函数，不属于任何类，但需要在类的内部声明，声明时加上 friend
代表朋友
改进如下
class Date
{
friend ostream& operator<<(ostream& _cout, const Date& d);
public:
Date(int year, int month, int day)
:_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 << endl;
return _cout;
}
友元类
友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员
- 友元关系是单向的，不具有交换性
- 友元关系不能传递
- 友元关系不能继承
class 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 = 2022, int month = 12, int day = 25)
:_year(year)
,_month(month)
,_day(day)
{
}
void Settmieofday(int hour, int minute, int second)
{
//可以直接访问时间类的私有成员变量
_t._hour = hour;
_t._minute = minute;
_t._second = second;
}
private:
int _year;
int _month;
int _day;
Time _t;
};
friend class Date;
声明日期类为时间的友元类，在日期类中可以直接访问Time类中的私有成员变量
内部类
概念：如果一个类定义在另一个类的内部，这个内部类就称作内部类。
内部类是一个独立的类，不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限
内部类就是外部类的友元，内部类可以通过外部类的对象参数来访问外部类中的所有成员，但是外部类不是内部类的友元
class A
{
public:
class B
{
int _b;
void f(const A& a)
{
cout << N << endl;
cout << a._a << endl;
}
};
private:
int _a;
static int N;
};
int A::N = 0;
int main()
{
cout << sizeof(A) << endl;
A a;
A::B b;
return 0;
}
由结果可知，在计算类大小时，内部类是不参与的
B类的实例化也需要在A类的访问限定符下进行
相当于两个单独的类，B类是A类的友元
B类的访问受A的类域和访问限定符的限制
特性：
- 内部类可以定义在外部类的
public,private中 - 内部类可以直接访问外部类中的
static成员，不需要外部类的对象/类名 sizeof(外部类）=外部类，和内部类没有任何关系
匿名对象
class M
{
public:
M(int m = 0)
:_m(m)
{
cout << "M(int m = 0)" << endl;
}
~M()
{
cout << "~M()" << endl;
}
private:
int _m;
};
int main()
{
M m1;
M();
return 0;
}
上面两种是实例化对象的方式都可以，不过也存在些区别
1.第一种方式，也称作实名对象，生命周期与主函数一致
2.第二种方式，匿名对象，生命周期仅限于这一行，运行到下一行，便会自动调用析构函数
拷贝对象时的一些编译器优化
优化1
class M
{
public:
M(int m = 0)
:_m(m)
{
cout << "M(int m)" << endl;
}
M(const M& m)
:_m(m._m)
{
cout << "M(const M& m)" << endl;
}
M& operator=(const M& m)
{
cout << "M& operator=(const M& m)" << endl;
if (this != &m)
{
_m = m._m;
}
return *this;
}
~M()
{
cout << "~M()" << endl;
}
private:
int _m;
};
int main()
{
M m1 = 1;
return 0;
}
优化过程
M m1 = 1;
优化
M tmp(1) + M m1(tmp);
优化2
void f1(M m)
{
}
int main()
{
f1(M(1));
return 0;
}
优化3
M f2()
{
M m;
return m;
}
int main()
{
M ret = f2();
return 0;
}
