类的六大默认方法

一.类的引入

c语言中，结构体只能定义变量，在C++中引入类，类中不仅能定义变量，我们称之为成员，也可以定义函数，成为成员函数。

#include<iostream>
using namespace std;
class Test
{
public:
void func()
{
cout<<Test::func()<<endl;
}
private:
	int m_data;
};

在这个类中，我们有成员，还有函数，其中我们发现了两个关键词，private和public。接下来我们就深入了解一下类的更多用处吧。

二.类的定义

class为定义类的关键字，上面的代码中Test为类名，{}为类的主体。
注意：类的定义后面有；
类中的元素我们称之为成员，上述定义的数据m_data为类的属性和成员变量，类中的函数为类的方法和成员函数。
类中的访问限定符
public(公有)，private(私有)，protected(保护)
c++中的成员默认为私有，但是结构体中默认为公有的。
public修饰的成员我们可以在类外直接访问，但是protected和 private修饰的成员不能在类外直接访问，但是我们也可以通过其他方式间接访问，在后面我们会提到。
类的作用域
类中的所有成员都在类的作用域中，在类体外定义成员，需要使用::作用域解析符。

class Test
{
public:
	void func();
private:
	int m_data;
};
void Test::func()
{
	cout<<m_data<<endl;
}

三.类的实例化

用类类型创建对象的过程称为实例化对象。

#include<iostream>
using namespace std;
class Test
{
public:
	int Getdata()
	{
		cout<<m_data<<endl;
	}
private:
	int m_data;
};
void main()
{
	Test t;//实例化对象
	Test t1(10);
}

我们实例化对象的过程中需要给这个对象分配内存空间，并为其赋初值，此后结束时还会释放空间，这与后面的类的默认方法有关，我们后面再了解。

四.类的六大默认函数

构造函数：

class Test
{
public:	
	//构造函数
	Test(int data=0)
	{
		m_data=data;
	}
private:
	int m_data;
};
void main()
{
	Test t1;//实例化对象
	cout<<t1.m_data<<endl;
	Test t2(10);//实例化对象
}

构造函数的作用主要是申请资源，对象初始化。
构造函数的特点：
1.函数名和类名相同，没有返回值。
2.如果没有自定义的构造函数，系统会产生默认的，默认的构造函数会产生随机值。
3.构造函数的调用顺序是根据其实例化的顺序依次进行，每产生一个对象，调动一次构造函数。
拷贝构造函数
拷贝构造函数也属于构造函数。

class Test
{
public:
	//构造函数
	Test(int data=0)
	{
		m_data=data;
	}
	//拷贝构造函数
	Test(const Test &t) //采用引用取别名，不用重新开辟空间让实参给形参赋值
	{
		//加const采用常引用防止内部改变参数对象的值
		m_data=t.m_data;
	}
private:
	int m_data;
};
void main()
{
	Test t1;
	Test t2=t1;//调用拷贝构造函数
}

当用对象进行初始化对象时，系统会自动调用拷贝构造函数。如果不写，系统也会产生默认的拷贝构造函数，并且最终结果与上面定义的相同。
除此之外，还有一种情况我们也会调动拷贝构造函数。

class Test
{
public:
	Test(int data=0)
	{
		m_data=data;
	}
public:
	int GetData()const
	{
		return m_data;
	}
private:
	int m_data;
};
	Test func(Test obj)
	{
		int value=obj.GetData();
		Test tmp(value);
		return tmp;//调动拷贝构造函数
	}
void main()
{
	Test t1;
	func(t1);//调动拷贝构造函数
}

函数的实参为实例化对象时我们将实参传给形参时，也是一种对象拷贝构造对象的过程，所以拷贝构造函数的实质就是通过对象实例化对象的过程。

除此之外，在上面代码中，我们的func函数内部返回临时值tmp时也需要调动拷贝构造函数,tmp是一个临时对象，函数结束后我们会释放这个空间，在此之前，我们需要将这个tmp拷贝到一个临时空间中保存，此时也是对象拷贝构造对象。

等号的重载

class Test
{
	friend ostream& operator<<(const osteam &out,const Test &t);
public:
	Test(int data=0)
	{
		m_data=data;
	}
	~Test()
	{}
	Test(const Test& t)
	{
		m_data=t.m_data;
	}
	Test& operator=(const Test& t)
	//切记返回对象时用引用要看返回值是否是临时对象
	{
		if(this!=&t)
		{
			m_data=t.m_data;//检查是否自己给自己赋值（防止多次引用）
		}
		return *this;
	}
private:
	int m_data;
};
ostream& operator<<(const osteam &out,const Test &t)
{
	out<<t.m_data;
	return out;
}
void main()
{
	Test t1;
	Test t2(10);
	t1=t2;//调用赋值语句
	cout<<t1<<endl;
	Test t3;
	t3=t2=t1;
	//t3.operator=(t2.operator=(t1));遇到连等的时候会需要返回值
	//因此等号的重载需要返回值
}

运算符重载真实意义：我们在进行对某种类型变量在进行运算时，我们希望可以直接的表达，而不是通过函数的调用完成运算，运算符的重载相当于给这个运算符赋予一个其他的含义。
在我们进行类成员的重载函数时，形参中感觉少一个参数，操作符中有一个默认的this，限定为一个形参。
赋值运算符主要四点：
1.参数类型（我们有时候为了提高程序效率，经常在函数形参，返回值中引用）
2.返回值
3.检查是否自己给自己赋值
4.一个类中如果没有显示定义赋值运算符的重载，编译器也会生成一个，完成对象的按字节拷贝。

const修饰类的成员函数

class Test 
{
public:
	void SetData(int data) 
	{
		m_data = data;
	}
	// int GetData(const Test *const this)
	int GetData()const//常方法（必须是定义在类内部的方法）
	{
		//常方法内部不允许对数据成员进行修改
		return m_data;
	}
	//int GetData(Test* const this)
	int GetData()
	{
		//与以上方法形成重载（二者参数类型不同）
		return m_data;
	}
	//两种形式可以同时存在，也可以只保留常方法
private:
	int m_data;
};
void main()
{   
	Test t1;
	t1.GetData();//常方法和普通方法同时存在时，普通对象首先选择普通方法
	const Test t2; //常对象不能调动普通方法
	cout << "t= " << t2.GetData() << endl;
	t2.GetData();//只能调动常方法
	cout << "t= " << t1.GetData() << endl;
}

将const修饰的类成员函数称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐藏的this指针，表明在该成员函数中不能对类的任何成员进行修改。
常方法内部不允许调用普通方法，普通方法内部可以调用常方法

友元

class Test
{
	friend class Date;
	friend void func(const Test& t);//只需要在类中声明这个方法即可
public:
	Test(int data = 0)
	{
		m_data = data;
	}
public:
	int GetData()
	{
		return m_data;
	}
private:
	int m_data;
};
class Date
{
public:
 	Data():m_year(2001),m_month(04),m_day(17)
 	{}
 	~Data()
 	{}
private:
	int m_year;
	int m_month;
	int m_day;
};
void func(const Test &t)
{
	int data = t.m_data;
	//由于m_data是类中私有成员,因此我们需要将此方法变为友元方法
}

友元类的所有成员函数都是另一个类的友元函数，都可以访问另一个类的公有成员。
1.友元关系是单向的，不具有传递性
比如在上述代码中，在Test类中声明Date类为其友元类，那么可以在Date类中直接访问Test类中私有成员变量，但是不能再Test类中访问Date类中的私有成员变量。
2.友元关系不能传递
如果B是A的友元，C是B的友元，也不能说明C是A的友元。