类与对象

• 构造函数
• • 构造函数体赋值
  • 初始化列表
  • explicit关键字
• static成员
• • 概念
  • 特性
• 友元
• • 友元函数
  • 友元类
• 内部类
• 匿名对象
• 拷贝对象时的一些编译器优化

构造函数

构造函数体赋值

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值

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;
};

1. 每个成员变量在初始化列表中只能出现一次（初始化只能初始化一次）
2. 类中包含以下成员，必须放在初始化列表位置进行初始化

引用成员变量
const成员变量
若不使用初始化列表结果是如何呢？

class M
{
public:M(){}
private:const int _n;int& _m;
};
int main()
{M m;return 0;
}

报错是无疑的

不论是在类中，还是在局部函数中，由const修饰的变量在定义时都是必须进行初始化的；引用也是如此在定义时必须进行初始化

自定义类型成员（该类中没有默认的构造函数）

3. 尽量使用初始化列表初始化，因为不管是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化

4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

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.直接通过域限定符访问

特性

1. 静态成员是所有类对象所共享的，不属于某个具体的对象，存放在静态区
2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
3. 类静态成员可用类名：：静态成员或者对象.静态成员进行访问
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
5. 静态成员也是类的成员，受访问限定符的限制

友元

友元提供了一种突破封装的方式，提供了便利。不过友元增加耦合度，破坏了封装，所以友元不宜多用

友元分为：友元函数，友元类

友元函数

先引入一中情景，重载operator<<，由于隐含的this指针默认是第一个参数，而cout的输出流对象就只能作为第二参数，但是在操作台中输出流对象作为第一个参数才能正常使用，所以需要将operator<<重载为全局函数，但是如此操作就会造成类外不能访问私有成员变量，友元便可以解决这个问题

class Date
{
public:Date(int year, int month, int day):_year(year),_month(month),_day(day){}//成员函数第一个参数是隐藏的this指针，就会变成  d1<_cout << _year << " " << _month << " " << _day << endl;return _cout;}
private:int _year;int _month;int _day;
};

d1<

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;

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;
}

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;
}

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);

void f1(M m)
{}int main()
{f1(M(1));return 0;
}

M f2()
{M m;return m;
}int main()
{M ret = f2();return 0;
}