文章目录
面向对象和面向过程初步认识
C语言是面向过程，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
C++是面向对象的，关注的是对象，将一个问题拆分成不同对象，通过对象之间的交互解决问题。
类的引入
我们先来看C语言中定义的是一个结构体，而结构体中有结构体成员，是一个新的类型比如我们创建一个栈
#incldue <stdio.h>
typedef int SDataType
struct Stack
{
int* SDataType* a;
int size;
int capacity;
}
void StackPush(struct Stack* ps, SDataType x);
函数方法： 数据和方法是分离的，重点关注的是过程->函数方法
类定义出新的类型，类由两部分构成：1.成员变量（属性）2.成员函数（行为），而C++中兼容C语言的语法所以C语言中的struct可以当成类，因为在语言中struct相当于从结构体被升级成了类。
struct实现的类：
#incldue <iostream>
typedef int SDataType
struct Stack
{
void StackPush(SDataType x)
{
a[size] = x;
size++;
}
void Init()
{
a = (SDataType*)malloc(sizeof(SDataType) * 4);
size = 0;
capacity = 4;
}
int* SDataType* a;
int size;
int capacity;
}；
在C++里面struct在定义的时候不用加，直接用类名就能定义一个类了，在C++里面变量都统称为对象。
不过在C++里面定义类都不会用struct而是用class,其实它两都一样不过默认不一样，这个问题等一会讲我们先来看看怎么class定义一个类.
类的定义：
class name
{
//类体
//类体里面的成员变量是声明不是定义，因为没有开空间
};//一定要跟分号
类的访问限定符和封装
C++提供三种访问限定符来更好的管理我们的类，公有限定符的作用就是字母意思，被这限定符作用的成员都是公有的可以任意使用，而保护和私有差不多，都是用来防止别人使用里面的成员。
我们都知道class和struct差不多，但是它们有一个区别，那就是没给限定符的时候，没给限定符的时候class默认是私有说明里面的内容不能被外面访问，而struct默认是共有的里面的内容可以任意访问。
访问限定符说明：
- public修饰的成员在类外可以直接被访问
- protected和private修饰的成员在类外不能直接被访问（此处protected和private是类似的）
- 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现为止
class的默认访问权限为private,struct为public(因为struct要兼容C)
类域
每个类创建都是一个新的域，如果想访问类域需要指定如：Stack :: Push，私有和保护针对的是类域外面的不能直接访问它们，只能通过公有给的成员函数来合法使用。
实例化
用类创建的对象叫做实例化对象，当这个类实例化时会占用实际的空间
访问限定符使用
#include <iostream>
using namespace std;
class Stack
{
public://公有
void Push(int size, int val)
{
//...
}
private://私有
{
int val;
int size;
int mainm()
{
Stack a;//类实例化对象
Stack::Push(2, 2);//指定类域访问改类里面的内容
return 0;
}
封装
面向对象的三大特性：封装、继承、多台。
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口进行交互。
封装本质上是一种管理： 我们如何管理兵马俑呢？比如如果什么都不管，兵马俑就被随意破坏了。那么我们首先建一座房子把兵马俑封装起来。但是我们的目的全封装起来，不让别人看。所以我们开放了售票通道，可以买票突破封装在合理的监管机制下进去参观。类也是一样，我们使用类数据和方法都封装一下。
不想给别人看的，我们使用
protected和private把成员封装起来，开放一些共有的成员函数对成员合理的访问，所以封装的本质是一种管理。
类的大小
我们知道C语言中结构体是占空间的，但是类占不占呢？如果占是如何计算的呢？我们知道C语言结构体会内存对齐。
经过测试，我发现以下三中情况，成员函数是不算空间大小的，而里面的基本类型会。
如下：
#include <iostream>
using namespace std;
class test1//空类
{
};
class test2//成员函数和成员变量构成的类
{
public:
void Push()
{
//...
}
private:
int val;
};
class test3//成员变量类
{
int val;
};
int main()
{
cout << "test1:" << sizeof(test1) << endl;
cout << "test2:" << sizeof(test2) << endl;
cout << "test3:" << sizeof(test3) << endl;
return 0;
}
我们可以看到，如果是空类他会用一个字节占位，而成员函数则不计算在内并且也有内存对齐。
内存对齐规则
-
第一个成员在与结构体偏移量为0的地址处。
-
其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。
VS中默认的对齐数为8
-
结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。
-
如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是
所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
this指针
我们先来看一段代码
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
class Date
{
public:
void Init(int year, int month, int day)
{
year = year;
month = month;
day = day;
}
private:
int year;
int month;
int day;
};
int main()
{
Date d1;
d1.Init(2021, 2, 3);
return 0;
}
首先我们运行发现，他并没有完成赋值，但是编译没问题啊，这其实涉及到一个问题那就是局部优先，它自己赋值给自己了，而不是把自己给了Date类中的成员变量，那么这种情况怎么解决了以下有三种解决方案。
- 指定域
class Date
{
public:
void Init(int year, int month, int day)
{
Date::year = year;
Date::month = month;
Date::day = day;
}
private:
int year;
int month;
int day;
};
int main()
{
Date d1;
d1.Init(2021, 2, 3);
return 0;
}
- 命名风格
#include <iostream>
using namespace std;
class Date
{
public:
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
d1.Init(2021, 2, 3);
return 0;
}
- this指针
class Date
{
public:
void Init(int year, int month, int day)
{
this->year = year;
this->month = month;
this->day = day;
}
private:
int year;
int month;
int day;
};
int main()
{
Date d1;
d1.Init(2021, 2, 3);
return 0;
}
我们可以看到这三种方案都成功赋值了，而如果我们有多个实例化对象那我们调用同一个函数它是怎么区分这些对象的呢？
首先每个函数其实都有一个隐含的this指针，你可能会说我没看到啊，因为是隐含的所以你才看不到，而我们使用的话就像上面的方法就能使用，而this指针是隐含是由编译器自动写入的，你不能手动写这样会报错的，我们每个对象传参编译器能分辨是因为这个this指针的地址就是这个对象的所以才能同一个函数多个对象却能正常赋值。
第二个方案和第三个方案其实都一样的，它们的本质都是加了this指针来区分的，对于我们来说只是一个显示了加了this和一个没显示加this的区别。因为你不加编译器会自动帮你加。
this指针是存在栈上的因为它是函数的参数，不同编译器不同，VS是使用ecx寄存器中存储，传参。
默认成员函数
构造函数
构造函数是特殊的成员函数，需要注意的是，构造函数的名称虽然叫构造，但是需要注意的是构造函数的主要任务并不是开空间创建对象，而是初始化对象。
其特征如下：
- 函数名与类名相同
- 无返回值
- 对象实例化时编译器自动调用对应的构造函数。
- 构造函数可以重载。
案列：
#include <iostream>
class Date
{
public:
Date(int year, int month, int day)//默认构造函数，也可以不写编译器会生成
{
_year = year;
_month = month;
_day = day;
}
Date()//重载
{
_year = 1;
_month = 1;
_day = 1;
}
private:
int year;
int month;
int day;
}
注意： 编译器自动生成的构造函数，它对内置类型什么都不做对自定义类型会调用它的构造函数初始化。很多人认为构造函数是编译器自动生成的才叫构造函数，其实这样理解是不全面的有些情况其实也叫默认构造函数不是编译器生成的也叫默认构造函数，这种情况有三种。
- 我们不写编译器默认生成的
- 我们自己写的无参的
- 我们写的全缺省的
总结：不用参数就可以调用构造函数的就是默认构造函数，建议写全缺省的构造函数。
析构函数
析构函数是特殊的成员函数
其特征如下：
- 析构函数名是在类名前加上字符
~.- 无参数无返回值
- 一个类有且只有一个析构函数。若未显示定义，系统会自动生成默认的析构函数。
- 对象生命周期结束时，C++编译器会自动调用析构函数。
案列：
#include <iostream>
class Date
{
public:
~Date()//析构函数
{
//...
}
private:
int year;
int month;
int day;
}
析构函数是一个对类的资源清理，想想在C语言的时候我们销毁一个栈是不是要写一个函数，专门用来销毁但是我们可能会忘记调用会导致内存泄露，而析构函数会自动调用不会出现内存泄露的问题。
我们来看一段代码：
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
class Stack
{
public:
Stack(int capacity = 4)
{
cout << this << "构造函数" << endl;
if (capacity <= 0)
{
_a = nullptr;
_size = _capacity = 0;
}
else
{
_a = (int*)malloc(sizeof(int) * capacity);
if (!_a)
{
exit(-1);
}
_capacity = capacity;
_size = 0;
}
}
~Stack()
{
cout << this << "析构函数" << endl;
free(_a);
_a = nullptr;
_size = 0;
_capacity = 0;
}
inline void Expansion(int size, int capacity)
{
if (size == capacity)
{
int* temp = (int*)realloc(_a ,sizeof(int*) * capacity * 2);
if (temp)
{
_a = temp;
}
_capacity = capacity * 2;
}
}
void Push(int val)
{
Expansion(_size, _capacity);
_a[_size] = val;
_size++;
}
void Printf()
{
int i = 0;
for (i = 0; i < _size; i++)
{
cout << _a[i] << endl;
}
}
private:
int* _a;
int _size;
int _capacity;
};
int main()
{
Stack s1;
s1.Push(1);
s1.Push(2);
s1.Push(3);
s1.Push(4);
s1.Push(5);
Stack s2;
s2.Push(1);
s2.Push(2);
s2.Push(3);
s2.Push(4);
s2.Push(5);
return 0;
}
请问s1和s2谁先析构的？
答：因为对象是定义在函数中，函数调用会建立栈帧，栈帧中的对象构造和析构也要符合先进后出。
s1先构造->s2后构造->s2先析构->s1后析构
其它的类也是一样的
面试题： 数据结构的栈、堆和我们讲的内存分段区域也有一个叫栈和堆，他们之间有什么区别和联系？
答：
- 他们之间没有绝对的联系，因为他们属于两个学科的各自的一些命名。一个是数据结构，一个是分段（一段内存的命名）<–区别
- 数据结构栈和系统分段栈（函数栈帧）中的对象都符合后进先出。<–联系
关于写和不写默认析构函数的区别
不写编译器会自动生成，写了它也啥都不干，但是真的啥都不干吗？其实它和构造一样，内置类型不处理，会调用自定义类型的析构。析构大部分情况是不写的，因为大部分的类是没有什么需要清理的编译器默认的就够用了，那什么情况才需要写呢？比如：像Stack这样的类就需要自己写。
运算符重载
C++为了增强代码的可读性引入了运算符重载，云素颜符重载是具有特殊函数名的函数， 也具有其返回值类型，函数名以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字
operator后面接需要重载的运算符符号。函数原型：返回值类型
operator操作符(参数列表）注意：
- 不能通过连接其它符号来创建新的操作符：比如operator@
- 重载操作福必须有一个类类型或者枚举类型的操作数
- 用于内置类型的操作符，其含义不能改变，列如：内置的整形+，不能改变其含义
- 作为类成员的重载函数时，其形参看起来比操作数目少一成员函数的操作符有一个默认的形参
this，限定为第一个形参。- .*、::、
sizeof、?:、.注意以上五个运算符不能重载，这个经常在笔试选择题中出现。内置类型，语言层面就支持运算符，而自定义类型默认不支持。因为不同类由不同情况它不知道怎么支持，但是也不是完全不支持，它给了个机会可以用运算符重载来支持某个运算符
运算符重载跟函数重载没有任何关联，它们都只是重载而已，函数重载是为了同名，而运算符重载是让自定义类型也能想内置类型一样能使用运算符。
比如说我写个日期类，需要比较它们的大小正常做法我们是不是写一个比较成员函数？
#include <iostream>
using namespace std;
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
bool Equel(const Date d)
{
return _year == d._year &&
_month == d._month &&
_day == d._day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
Date d2;
cout << d1.Equel(d2) << endl;
return 0;
}
但是这样写万一看这段代码的人英语或者编程底子不好呢？不就得一段一段读代码来判断这函数的作用，这样子可读性就很差了效率就低了，那么能不能有那种一目了然不管什么人看了都能明白的写法呢？答案是有的，运算符重载就解决了这个问题。
我们看这段代码：
#include <iostream>
using namespace std;
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
bool operator==(const Date d)//运算符重载
{
return _year == d._year &&
_month == d._month &&
_day == d._day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
Date d2;
cout << (d1 == d2) << endl;//可以样调用也可以这样调用operator==(d1, d2),但是可读性不强。为什么能直接用d1==d2和operator==(d1, d2)呢是因为编译器把你转换成了d1.operator==(&d1, d2)，如果是全局的operator==(d1, d2)
return 0;
}
这样子是不是一目了然代码可读性直接翻了个倍。
赋值运算符也是一个默认成员函数，也就是说我们不写编译器也会自动生成一个。
编译器默认生成赋值运算符跟拷贝构造的特性是一致的，针对内置类型会完成浅拷贝，也就是说像Date这样的类不需要我们自己写赋值运算符重载。
运算符重载传引用&引用作返回值
如果我们使用传值传参那么会引发一个问题就是它会调用一次拷贝构造和花费内存过多的问题所以最好传引用传参。
而如果写了一个赋值符运算符重载，按照我们使用内置类型的时候是可以连续赋值的。
我们这样写是不能实现连续赋值的:
#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(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
void operator=(Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
Date d2(2020, 5, 3);
d1 = d2;
return 0;
}
想要连续赋值得这样写引用作返回值：
#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(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
Date& operator=(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;
Date d2(2020, 5, 3);
Date d3;
d3 = d1 = d2;
return 0;
}
拷贝构造函数
特征：
拷贝构造函数也是特殊的成员函数，其特征如下：
- 拷贝构造函数是构造函数的一个重载形式。
- 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。
#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(const Date d)//拷贝构造无限递归拷贝 { _year = d._year; _month = d._month; _day = d._day; } Date(const Date& d)//拷贝构造这样才不会无限递归拷贝 { _year = d._year; _month = d._month; _day = d._day; } private: int _year; int _month; int _day; }; int main() { Date d1; Date d2(d1); return 0; }
为什么这样就不行了呢？因为把d1实参传给d是传值，是传值就会引发一个新的问题，这个d要调它的拷贝构造，调它拷贝构造的时候又是传值又需要调d的拷贝构造以此无限循环。
我们都知道默认成员函数如果不写都会自动生成，而拷贝构造自动生成的不仅对内置类型也会拷贝连自定义类型也会拷贝，不过是调用这个自定义类型的拷贝构造函数来完成的，这个拷贝我们通常叫浅拷贝或者值拷贝。
照这么说是不是就不需要手写拷贝构造了？其实不是的日期类不写没问题，但是如果是Stack类呢？它的类成员是管理资源的成员，如果它进行浅拷贝那么它的指针成员不就和上一个指针成员指向同一个空间了吗？
如果对copy进行扩容不就影响到了st吗？这不是我们想要的啊，我们只是想要他们的值一样而已而不是连指针都一样。
-
除了这个问题还有两个新问题，调用析构函数时，这块空间被
free了两次，还有人问你free的时候不是置空了吗？但是你这个置空起作用吗？按理来说谁先析构？是copy先置空，那么这是两个对象里的_a啊，你释放自己的会影响到别人吗？显然不会，然后st再释放一次，我们学过C语言都知道同一块空间是不能释放两次的。 -
其中一个对象插入删除数据，都会导致另一个对象也插入删除了数据。
这就是典型的浅拷贝问题，所以像Stack这样的类编译器自己生成的是不能满足我们的需求的，需要我们自己实现深拷贝。
const修饰的&
Date* operator&()
{
return this;
}
const Date* operator&()const
{
return this;
}
//如果不想让别人取类的地址就这样写
Date* operator&()
{
return nullptr;
}
const Date* operator&()const
{
return nullptr;
}
它们没有被实现的价值，这两个也是默认成员函数不过它们没什么用，%99的情况下默认的就够用了.
六个默认成员函数总结
- 我们不写编译器会自动生成，虽然会自动生成，但是很多时候需要我们自己写，因为它默认生成的不一定好用。
- 构造函数，用于完成初始化，大部分情况下需要我们自己写构造函数
- 析构函数，用于清理对象中的资源大部分情况下不需要写，除非是类似
Stack这种类需要释放内存要手动写，不是这类的大部分自动生成的就够用了。 - 拷贝构造函数，用于完成拷贝初始化，分为浅拷贝和深拷贝，默认生成的会对内置类型拷贝，也会调用自定义类型的拷贝构造函数。深浅拷贝问题。
- 赋值运算符重载，这也是拷贝行为，但是不一样的是，拷贝构造是创建一个对象时，拿同类对象初始化的拷贝，这里的复制拷贝时连个对象已经都存在了，都被初始化过了，现在想把一个对象，复制拷贝给另一个对象。
- 六个默认成员函数有两个是废的。
总结：
- 构造和析构的特性是类似的，我们不写编译器内置类型不处理，自定义类型调用它的构造和析构处理。
- 拷贝构造和赋值重载特性是类似的，内置类型会完成浅拷贝，自定义类型会调用它们的拷贝构造和赋值重载。
- 拷贝构造是让一个还未初始化的对象被一个已经初始化的对象完成拷贝，而负值重载则是两个已经存在的对象，让d2的值给d1.
友元
友元分为：友元函数和友元类
友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。
友元函数
问题：现在我们尝试去重载operator<<，然后发现我们没办法将operator<<重载成成员函数。因为cout的 输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是 实际使用中cout需要是第一个形参对象，才能正常使用。所以我们要将operator<<重载成全局函数。但是这 样的话，又会导致类外没办法访问成员，那么这里就需要友元来解决。operator>>同理
class Date
{
public:
Date(int year, int month, int day)
: _year(year)
, _month(month)
, _day(day)
{}
ostream& operator<<(ostream& _cout)
{
_cout<<d._year<<"-"<<d._month<<"-"<<d._day;
return _cout;
}
prvate:
int _year;
int _month;
int _day
};
int main()
{
Date d(2017, 12, 24);
d<<cout;
return 0;
}
友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声 明，声明时需要加friend关键字。
class Date
{
friend ostream& operator<<(ostream& _cout, const Date& d);
friend istream& operator>>(istream& _cin, 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;
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修饰 - 一个函数可以是多个类的友元函数
- 友元函数的调用与普通函数的调用和原理相同
友元类
友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
- 友元关系是单向的，不具有交换性。 比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time 类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
- 友元关系不能传递 如果B是A的友元，C是B的友元，则不能说明C时A的友元。
class Date; // 前置声明
class Time
{
friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成
员变量
public:
Time(int hour, int minute, int second)
: _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;
};
注意：友元是破坏封装的，如果不是万不得已能不用就不用。
初始化列表初始化
初始化列表是以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个“成员变量“后面跟一个放在括号中的初始值或表达式。
class Date
{
public:
Date(int year, int month, int day)
:_year(year)
,_month(month)
,_day(day)
{}
private:
int _year;
int _month;
int _day;
}
构造函数初始化可以用以前的方法也可以用初始化列表初始化，也可以都混着用。
注意：
- 每个成员变量在初始化列表只能出现一次初始化（初始化只能初始化一次）
- 类中包含以下成员，必须放在初始化列表位置进行初始化；
-
引用成员变量
-
const成员变量 -
自定义类型成员（该类没有默认构造函数）
内置类型用初始化列表初始化或者构造函数初始化都行，但是自定义类型必须用初始化列表。
初始化列表的初始化顺序跟初始化列表中的顺序无关，只和声明中的顺序有关。
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
class A1
{
public:
A1(int a)
:_a1(_a2)
,_a2(a)
{}
void Printf() const
{
cout << _a1 << "\n" << _a2 << endl;
}
private:
//此处是声明不是定义
int _a1;
int _a2;
};
int main()
{
A1 a(1);
a.Printf();
return 0;
}
单参数的构造函数
例子：
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
class A1
{
public:
A1(int a)
:_a1(_a2)
,_a2(a)
{}
void Printf() const
{
cout << _a1 << "\n" << _a2 << endl;
}
private:
//此处是声明不是定义
int _a1;
int _a2;
};
int main()
{
A1 a(1);
A1 b = 1;
return 0;
}
从语法意义上来讲，b是先构造再贝构造，但是早起的编译器是：先创建一个零时变量tmp把2的值拷到tmp再调用拷贝构造把tmp给b，现在的编译器做了优化，它是直接调用构造函数。
所以现在来讲a和b没有任何区别，但是如果你不想b这样构造你就在构造函数前面加个explicit这个关键字，这样的行为就发生不了，如果强制使用编译器是报错的。
匿名对象
匿名对象的声明周期是程序的本行，一旦到下一行就会执行析构进行清理资源。
匿名对象的创建：类名();
静态成员的初始化
静态成员不能再构造函数内初始化，只能在类外面初始化需指定。
如：
#include <iostream>
class A
{
public:
A ()
{
++_n;
}
A (const A& a)
{
++_n;
}
private:
//这里只是声明，不在构造函数初始化
static int _n;//n是存在静态区，属于整个类也属于类所有对象。
}
//静态成员变量的初始化,特列，不受访问限定符的限制，否则就没办法定义初始化
int A::_n = 0;
静态的成员函数
静态的成员函数和普通的成员函数的区别是：没有
this指针，不能访问非静态成员。静态成员不属于某个对象，可以突破类域访问。
特性总结：
- 静态成员为所有类对象所共享，不属于某个具体的实例
- 静态成员函数必须在类外定义，定义时不添加
static关键字 - 类静态成员即可用类名
::静态成员或者对象.静态成员来访问。 - 静态成员函数没有隐含的
this指针，不能访问任何非静态成员 - 静态成员和类的普通成员一样，也有
public、protected、private三种访问级别，也可以具有返回值