【c++类的默认六个成员函数详解】

类的六个默认成员函数

1. 构造函数
2. 析构函数
3. 拷贝构造
4. 赋值运算符重载
5. 取地址运算符重载
6. const修饰的取地址运算符重载

为什么要有这些默认成员函数？

如果一个类，在初始化之前就调用了打印函数，则会导致输出的是一个随机值，为了避免这种情况，所以c++给了六种默认成员函数。并且任何一个类在不写的情况下都会自动生成6个默认成员函数。

一、构造函数
1、什么是构造函数？它的作用？

构造函数就是在创建类对象的时候，由编译器自动调用，为对象进行初始化的一个特殊成员函数。它的名称和类名相同，并且在对象的声明周期内只调用一次。

2、构造函数的特性

1）函数名与类名相同
2）无返回值
3）对象实例化时编译器自动调用对应的构造函数
4）构造函数可以重载
5）如果用户没有自己定义构造函数，那么编译器会自动生成一个无参的默认构造，若用户定义了，则编译器不再自动生成。
6）无参构造和全缺省的构造统称为“默认构造函数”，并且默认构造函数只能有一个。（无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认成员函数。若无参的和全缺省的同时存在，要构造一个无参对象时会出错）
无参构造和全缺省构造构成函数重载，但是不可以同时存在。

#include<iostream>
using namespace std;

class Date
{
public:
	Date()
	{
		_year = 1900;
		_month = 1;
		_day = 1;
	}
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
void Test()
{
	Date d1;
}

7）编译器生成无参默认构造，什么也没有实现，有什么用？
解：不仅是编译器生成的默认构造，还有自己写的无参默认构造，构造后打印其成员变量的值都为乱码。但是，因为C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语法已经定义好的类型：如int/char…，自定义类型就是我们使用class/struct/union自己定义的类型，**编译器会自动调用自定义类型成员的默认构造函数。**而不对内置类型做任何处理。

class Time
{
public:
	Time()
	{
		cout << "Time()" << endl;
		_hour = 0;
		_minute = 0;
		_second = 0;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
public:
	// 基本类型(内置类型)
	int _year;
	int _month;
	int _day;
	// 自定义类型
	Time _t;
public:
	Date()
	{
		cout << "Data()" << endl;
	}
};
int main()
{
	Date d;
	cout << d._year << d._month << d._day << endl;
	system("pause");
	return 0;
}

8）成员变量的命名规则
一般情况下，为了区分构造函数中，成员变量和传入参数的名字，会给成员变量的名字前加上前缀，或为_,或为m_,或者其他符号。

二、析构函数
1、什么是析构函数？

析构函数是一个对象在销毁时会自动调用析构函数，完成对象销毁前，类的一些资源清理工作。（不是完成对象的销毁，局部对象销毁工作是由编译器完成的）

2、析构函数的特性

1）析构函数，名是在类名前加上字符~。
2）无参数，无返回值
3）一个类只有一个析构函数，如果用户自己没有定义，则系统会自动生成一个。
4）对象生命周期结束时，C++编译系统会自动调用析构函数。
例：

typedef int DataType;
class SeqList
{
public :
SeqList (int capacity = 10)
{
_pData = (DataType*)malloc(capacity * sizeof(DataType));
assert(_pData);
_size = 0;
_capacity = capacity;
}
~SeqList()
{
if (_pData)
{
free(_pData ); // 释放堆上的空间
_pData = NULL; // 将指针置为空
_capacity = 0;
_size = 0;
}
}
private :
int* _pData ;
size_t _size;
size_t _capacity;
};

5）编译器自动生成的析构函数，会对自定义类型成员调用它的析构函数。
三、拷贝构造函数
1、什么是拷贝构造函数？

只有单个形参，并且该形参是对本类类型对象的引用（一般用const修饰），在用已存在类类型对象创建新对象时，编译器会自动调用。

2、拷贝构造函数的特性

1）拷贝构造只是构造函数的一个重载
2）拷贝构造的参数只有一个，且必须引用传参，使用传值方式会引发无穷递归调用。

3）若用户没有定义拷贝构造，编译器会自动生成默认拷贝构造，但是只是按对象字节序进行拷贝，是浅拷贝。

class String
{
public:
String(const char* str = "jack")
{
_str = (char*)malloc(strlen(str) + 1);
strcpy(_str, str);//浅拷贝
}
~String()
{
cout << "~String()" << endl;
free(_str);
}
private:
char* _str;
};
int main()
{
String s1("hello");
String s2(s1);
}

浅拷贝在拷贝指针的时候没有重新开辟一块空间将指针所指内存单元的内容拷贝到新空间里，再让拷贝的指针指向它。所以浅拷贝只做了表面功夫，**拷贝的指针仍然和之前的指针指向同一片空间，**所以一旦任何一个指针销毁，释放空间，那么另一个的指针也会出错。

四、赋值运算符重载

1、什么是运算符的重载？

运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名为：关键字operator后面接需要重载的符号
函数原型：返回值类型 operator操作符（参数列表）

//输入运算符重载
istream &operator>>(istream &in, Date &a)
{
	in >> "输入的内容1" >> "输入的内容2...";
	return in;
}

/*输入输出运算符重载的第一个参数为输入输出流对象的引用，第二个参数为需要输出类对象的引用
*/

//输出运算符重载
ostream &operator<<(ostream& out, const Date&a)
{
	out << "输出内容1" << "输出内容2...";
	return out;
}

2、赋值运算符的重载

a)一个类如果没有显式定义赋值运算符的重载，那么编译器会自动生成一个，完成对象按字节序的值拷贝（浅拷贝）
b)如果类里面有指针，若同样赋值运算符利用浅拷贝进行，那么程序会崩溃。

class String
{
public:
String(const char* str = "jack")
{
_str = (char*)malloc(strlen(str) + 1);
strcpy(_str, str);
}
~String()
{
cout << "~String()" << endl;
free(_str);
}
private:
char* _str;
};
int main()
{
String s1("hello");
String s2("world");
s1 = s2;
}
class Date
{
public :
void Display ()
{
cout<<"Display ()" <<endl;
cout<<"year:" <<_year<< endl;
cout<<"month:" <<_month<< endl;
cout<<"day:" <<_day<< endl<<endl ;

因为strcpy是浅拷贝，所以程序运行会出错，将strcpy改为strcpy_s函数，则可以实现构造

#include<iostream>
using namespace std;
class String
{
private:
	char* _str;
public:
	String(const char* str = "jack")
	{
		_str = (char*)malloc(strlen(str) + 1);
		strcpy_s(_str, strlen(str) + 1, str);//深拷贝而strcpy是浅拷贝
	}
	
	~String()
	{
		cout << "~String()" << endl;
		free(_str);
	}

	friend ostream& operator<<(ostream& out, const String& s)
	{
		out << s._str;
		return out;
	}
};
int main()
{
	String s1("hello");
	String s2("world");
	cout << s1 << endl << s2;
	
	system("pause");
	return 0;
}

五、const成员
1、const 修饰的类成员函数

const修饰的类成员函数称为const成员函数，实际修饰的是该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。
故将const加在函数后面：

2、几个问题

1. const对象可以调用非const成员函数吗？
   解：不可以
2. 非const对象可以调用const成员函数吗？
   解：可以
3. const成员函数内可以调用其它的非const成员函数吗？
   解：不可以
4. 非const成员函数内可以调用其它的const成员函数吗？
   解：可以

六、取地址运算符重载及const取地址运算符重载

一般情况下不用重新定义，编译器会默认生成。只有特殊情况下（想让别人获取到指定内容时）会重新定义。

class Date
{
public :
Date* operator&()
{
return this ;
}
const Date* operator&()const
{
return this ;
}
private :
int _year ; // 年
int _month ; // 月
int _day ; // 日
};

附加：
1、mallo函数：
malloc（memory allocation）
中文名称：动态内存分配
用于申请一块连续的指定大小的内存块区域以void*类型返回分配的内存区域地址
2、用const修饰的变量

const常用的几种形式：
1）const修饰常量，表示其值无法修改
const int i=6; int const i=6;
2）const指向常量的指针
a)
int a=1; int b=2; const int *p1=&a; p1=&b;//可以修改指针的指向 //*p1=3不可以通过指针修改指针指向内存单元的值
指针p1不可修改它指向的内存单元的值，但是p1可修改其指向的内存单元。
b)
int a=1; int *const p1=&a;//初始化后不能指向其他内存单元，但是可以通过指针改变其指向内存单元的值
左定值，右定向
（*号在const的左边，则指针所指的内存单元的值不能通过指针改变，*号在const的右边，表示指针所指向的内存单元不可以改变。）
3）指向常量的指针常量
int a=1; int const * const p1 =&a; //指针指向的值和指向的内存单元都不可以改变
4）编译器会对常量进行优化，计算时会直接用常量代替变量，产生下述结果：

int main() 
{
	const int a = 6;
	int* p = (int*)&a;//把const int*强转成int*
	*p = 96;//修改指针指向内存单元的值
	cout << a << endl;//输出了6,为什么不是96呢？
	system("pause");
	return 0;
}

这个时候需要用volatile关键字进行修饰，使其返回正确的结果

int main() 
{
	const int volatile a = 3;//告诉编译器不要优化a变量
	int* p = (int*)&a;
	*p = 96;
	cout << a << endl;//输出了96，修改成功
	system("pause");
	return 0;
}

3、运算符重载的规则：

1. 并不是所有的运算符都可以重载，且 不可以通过连接其他符号来创造新的操作符。
   （长度运算符sizeof、条件运算符: ?、成员选择符.和域解析运算符::不能被重载。）
2. 重载不能改变运算符的优先级和结合性。
3. 重载不会改变运算符的用法比如原有有几个操作数、操作数在左边还是在右边
4. 运算符重载函数既可以作为类的成员函数，也可以作为全局函数。
   5） 箭头运算符->、下标运算符[ ]、函数调用运算符( )、赋值运算符=只能以成员函数的形式重载。

4、为什么输入输出运算符的重载只能作为类的友元函数而不是其成员函数？

因为按照运算符重载的写法，输出运算符重载可以写成 ostream& operator<<(ostream& out, const Date&a)
其第一个参数不是类的对象，所以一旦设为类的成员函数，第一个参数一般是隐含的由this指针指向的类对象。
因不符合上述要求，又想该类可以调用此函数，所以将其设为友元函数。

5、静态成员变量

1、静态成员变量不占用类空间，且不存在this指针。为所有类对象所共享，不属于某个具体的实例，类在它在。而一般成员是对象在它才在。所以静态成员可以他通过类名直接调用，而普通成员必须通过对象调用。
2、静态成员变量，所有对象共享，无论谁改了该变量，所有对象的一起改。它存储在安全区，不占用类空间，所以去sizeof的时候不算在内。赋初值只能在类外，赋值时不加static，用类型 类名：：变量名 = n 直接赋值。
3、静态成员函数内不可以调用非静态成员函数；非静态成员函数内可调用静态成员函数。