【C++】浅谈C++里面的类！！！

在C++里面类是一个面向对象的开始，同时也是C++的精髓之一。

其实在我个人理解的类就是一张盖房子的图纸，有了图纸就可以建造出来很多的大楼。C++里面也一样，有一个类类型，那么我们就可以用这个类创建出来很多的对象。

例如：

class Date
{
public:
	void SetDate();
	Date():
	~Date();
private:
	int _year;
	int _month;
	int _day;
};

在这个简单的类里面，含有三个私有成员_year、_month|、_day，同时含有一个构造函数Date（）和一个析构函数~Date（）。其实在哟个普通的类里面有三种访问限定符： public，private和protected，但是一个对象（除开友元）只能访问public里面的成员，所以在我们设计这个类的时候就需要在public里面吧我们所需的函数进行一一声明。

在C++里面的类里面，每个类含有六个默认的函数：

当我们创建一个类时候没有显式的定义这些函数的时候，如果程序需要这些函数编译器就会自己帮我们合成所需的函数。要了解C++那么首先来认识这些函数使我们必须的一步。

构造函数：

每个类创建的时候需要一个或者几个函数来为这个类初始化，这个函数就是构造函数。构造函数的任务就是初始化类对象的数据成员，无论何时只要类的对象被创建，就会执行构造函数。

特点：1、构造函数在类里面可以是一个也可以是多个，即构造函数可以重载。

   2、当我们没有显式的定义构造函数的时候，编译器会自己帮助我们创建一个构造函数。

   3、调用构造函数不用认为调用，编译器会自己执行。

例如：

Date::Date()
{
	_year = 2017;
	_month = 9;
	_day = 11;
}

Date::Date(int year = 2017,int month = 9,int day = 11)
:_year = year
,_month = month
,_day = day
{}

这里有两种构造函数，第一个直接不带参数的构造函数，第二个，构造函数自己带有 缺省值（可以没有），这个构造函数也可以写成：

Date::Date(int year,int month,int day)
{
	_year = year;
	_month = month;
	_day = day;
}

但是第一种用参数列表初始化更好一些，因为有的时候只能用函数参数列表的形式初始化。

只能用参数列表初始化的情况有：1、const修饰的成员 2、引用类型变量  3、类类型成员

拷贝构造函数：

拷贝构造函数是一个特殊的构造函数，当我们用一个同类型的对象去初始化另外一个对象的时候，就会调用拷贝构造函数。

使用场景：1、已创建对象初始化另外一个对象

  2、函数返回类型为类对象

例如： 

Date::Date(const Date& d)
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
}

注意：拷贝构造函数的参数只能是类对象的引用。

析构函数：

析构函数的作用和构造函数相反，析构函数是在对象销毁之前做一些清理工作，析构函数是在类名之前加上~符号，例如：~Date();

特点：1、一个类只有一个析构函数

   2、当没有显式定义析构函数的时候编译器会自己帮我们合成一个需要的析构函数，

   3、析构函数由系统自己调用

例如：

Date::~Date()
{
	cout<<"hehe"<<endl;
}

当这个对象销毁之前会输出“hehe”。

赋值操作符的重载：

在赋值操作符没有重载之前一个对象是不可以直接用=赋值的，但是直接使用=会使程序更加的直观简洁。

在赋值操作符重载之前，先要了解重载，重载操作符我认为就是将一个操作符的功能进行扩大。使其具备更多的功能。重载的关键字是operator，关键字后面直接跟上需要重载的操作符。

例如：

Date::operator=(const Date& d)
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
}

除了可以重载赋值操作符，还可以操作其他的操作符：

同时也存在不可以重载的操作符：

注：在重载操作符的时候应该不改变操作符原来的特性，例如：不可以承载+操作符作减法操作。这样会使程序变得可读性差，同时也不方便找出程序的错误。

常见的重载实例：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

class Complex
{
public:
	Complex(const double dReal, const double dImage);
	void Display();
	Complex(const Complex& complex);
	~Complex();
	Complex& operator=(const Complex& complex);
	Complex operator+(const Complex& complex);
	Complex operator-(const Complex& complex);
	Complex operator*(const Complex& complex);
	Complex operator/(const Complex& complex);
	Complex& operator+=(const Complex& complex);
	Complex& operator-=(const Complex& complex);
	Complex& operator*=(const Complex& complex);
	Complex& operator/=(const Complex& complex);
	bool operator >(const Complex& complex);
	bool operator >=(const Complex& complex);
	bool operator <(const Complex& complex);
	bool operator <=(const Complex& complex);
	bool operator ==(const Complex& complex);
	bool operator !=(const Complex& complex);
private:
	double _dReal;
	double _dImage;
};

Complex::~Complex()
{
	cout<<"OK"<<endl;
}
void Complex::Display()
{
	cout<<_dReal<<"/"<<_dImage<<endl;
}

Complex::Complex(const double dReal,const double dImage )
{
	_dReal = dReal;
	_dImage = dImage;
}
Complex::Complex(const Complex &complex)
{
	_dReal = complex._dReal;
	_dImage = complex._dImage;
}
Complex& Complex::operator=(const Complex& complex)
{
	if (this != &complex)
	{
		_dReal = complex._dReal;
	}
		return *this;
}
Complex& Complex::operator+=(const Complex& complex)
{
	_dReal += complex._dReal;
	_dImage += complex._dImage;
	return *this;
}
Complex& Complex::operator-=(const Complex& complex)
{
	_dReal-=complex._dReal;
	_dImage -= complex._dImage;
	return *this;
}
Complex& Complex::operator*=(const Complex& complex)
{
	_dReal*=complex._dReal;
	_dImage *= complex._dImage;
	return *this;
}
Complex& Complex::operator/=(const Complex& complex)
{
	_dReal/=complex._dReal;
	_dImage /= complex._dImage;
	return *this;
}
Complex Complex::operator+(const Complex& complex)
{
	Complex tmp(0,0);
	tmp._dReal = tmp._dReal + complex._dReal;
	tmp._dImage = tmp._dImage+complex._dImage;
	return tmp;
}
Complex Complex::operator-(const Complex& complex)
{
	Complex tmp(0,0);
	tmp._dReal = tmp._dReal - complex._dReal;
	tmp._dImage = tmp._dImage - complex._dImage;
	return tmp;
}
Complex Complex::operator*(const Complex& complex)
{
	Complex tmp(0,0);
	tmp._dReal *= complex._dReal;
	tmp._dImage *= complex._dImage;
	return tmp;
}
Complex Complex::operator/(const Complex& complex)
{
	Complex tmp(0,0);
	tmp._dReal /= complex._dReal;
	tmp._dImage /= complex._dImage;
	return tmp;
}
bool Complex::operator >(const Complex& complex)
{
	if ((*this)._dReal>complex._dReal)
	{
		return true;
	}
	else if ((*this)._dImage>complex._dImage)
	{
		return true;
	}
	else
		return false;
}
bool Complex::operator >=(const Complex& complex)
{

	if ((*this)._dReal>=complex._dReal)
	{
		return true;
	}
	else if ((*this)._dImage>=complex._dImage)
	{
		return true;
	}
	else
		return false;
}
bool Complex::operator <(const Complex& complex)
{

	if ((*this)._dReal<complex._dReal)
	{
		return true;
	}
	else if ((*this)._dImage<complex._dImage)
	{
		return true;
	}
	else
		return false;
}
bool Complex::operator <=(const Complex& complex)
{

	if ((*this)._dReal<=complex._dReal)
	{
		return true;
	}
	else if ((*this)._dImage <= complex._dImage)
	{
		return true;
	}
	else
		return false;
}
bool Complex::operator ==(const Complex& complex)
{
	if (((*this)._dReal == complex._dReal)&&((*this)._dImage == complex._dImage))
	{
		return true;
	}
	else
		return false;
}
bool Complex::operator !=(const Complex& complex)
{
	if ((*this)._dReal != complex._dReal)
	{
		return true;
	}
	else if ((*this)._dImage != complex._dImage)
	{
		return true;
	}
	else
		return false;
}