C++：重载

一、重载
重载：重载函数是函数的一种特殊情况，为方便使用，C++允许在同一范围中声明几个功能类似的同名函数，但是这些同名函数的形式参数（指参数的个数、类型或者顺序）必须不同，也就是说用同一个函数完成不同的功能。重载函数常用来实现功能类似而所处理的数据类型不同的问题。不能只有函数返回值类型不同。

重载的作用：重载函数常用来实现功能类似而所处理的数据类型不同的问题。不能只有函数返回值类型不同。

二、实例
1.构造函数CMatrix的初始化：
第一种初始化方式：在给变量分配空间时赋值,初始化效率较高
第二种初始化方式：在分配空间之后再给变量赋值
注：初始化的顺序必须和定义时变量的顺序一致

CMatrix::CMatrix():m_nRow(0),m_nCol(0),m_pData(NULL)
{

}

//第二种初始化方式：在分配空间之后再给变量赋值
//{
//	m_nRow = 0;
//	m_nCol = 0;
//	m_pData = NULL;
//}

2.CMatrix的一个重载函数：当m_pData的空间不能容纳n_Row*n_Col时 m_pData=NULL

CMatrix::CMatrix(int nRow,int nCol,double * pData)
{
    m_pData = NULL;
    Create(nRow,nCol,pData);
//	m_nRow = nRow;
//	m_nCol = nCol;
//	m_pData = new double[nRow*nCol];
//	if(m_pData != NULL)//当m_pData的空间不能容纳n_Row*n_Col时 m_pData=NULL
//	{
//		if(pData != NULL)
//		{
//			memcpy(m_pData,pData,sizeof(double)*nRow*nCol);
//		}
//
//	}
}

3.析构函数：析构函数与构造函数相反，当对象结束其生命周期，如对象所在的函数已调用完毕时，系统自动执行析构函数。析构函数往往用来做“清理善后” 的工作（例如在建立对象时用new开辟了一片内存空间，delete会自动调用析构函数后释放内存）。

CMatrix::~CMatrix()
{
//	if(m_pData != NULL)
//	{
//		delete []m_pData;
//		m_pData = NULL;//可省略
//	}
//	m_nRow = m_nCol = 0;//可省略
    //代码行60行和62行可省略，写上的好处是当后面想要再次delete时，由于m_pData = NULL导致delete失败
    Release();
}

4.运算符的重载：用friend给函数声明为全局函数，使该函数可以在全局范围内访问变量

friend istream & operator>>(istream& is,CMatrix& m);//friend使得该函数为全局函数，可以在全局范围内访问变量
friend ostream & operator<<(ostream& os,const CMatrix& m);

istream & operator>>(istream& is,CMatrix& m)
{
    is>>m.m_nRow>>m.m_nCol;
    m.Create(m.m_nRow,m.m_nCol);
    for(int i = 0; i < m.m_nRow*m.m_nCol; i++)
    {
        is>>m.m_pData[i];
    }
    return is;
}

ostream & operator<<(ostream& os,const CMatrix& m)
{
    os<<m.m_nRow<<" "<<m.m_nCol;
    double * pData = m.m_pData;
    for(int i = 0; i < m.m_nRow; i++)
    {
        for(int j = 0;j < m.m_nCol; j++)
        {
            os<<*pData++<<" ";
//			os<<m.m_pData[i*m.m_nCol+j]<<" ";
        }
        os<<endl;//"\n"
    }
    return os;
}

5.释放内存函数：当前空间可能不足以存储当前数据，所以需要先释放空间，再重新分配空间。

void CMatrix::Release()
{
    if(m_pData != NULL)
    {
        delete []m_pData;
        m_pData = NULL;
    }
    m_nRow = m_nCol = 0;
}

6.给函数重新分配空间

bool CMatrix::Create(int nRow,int nCol,double *pData)
{
    Release();//创建前可能有空间，所以先清除空间
    m_nRow = nRow;
    m_nCol = nCol;
    m_pData = new double[nRow*nCol];
    if(m_pData != NULL)
    {
        if(pData != NULL)
        {
            memcpy(m_pData,pData,sizeof(double)*nRow*nCol);
        }
        return true;
    }
    else
    {
        return false;	//内存申请失败
    }
}

7.重载函数：this指向该函数对象本身

CMatrix::CMatrix(const char * strPath)
{
    m_pData = NULL;
    ifstream cin(strPath);
    cin>>*this;//本身对象地址
}

8.拷贝：三种方法

//第一种方法
CMatrix::CMatrix(const CMatrix & m)
{
    m_nRow = m.m_nRow;
    m_nCol = m.m_nCol;
    m_pData = NULL;
    Create(m_nRow,m_nCol,m_pData);

}
//第二种方法
CMatrix::CMatrix(const CMatrix & m)//:CMatrix(m.m_nRow,m.m_nCol,m.m_pData)
{
    
}
第三种方法
CMatrix::CMatrix(const CMatrix & m)
{
	m_pData = NULL;
	*this = m;
}

9.内联函数：内联函数（有时称作在线函数或编译时期展开函数）是一种编程语言结构，用来建议编译器对一些特殊函数进行内联扩展（有时称作在线扩展）。

void Set(int nRow,int nCol,double dVal);
//		void Set(int nRow,int nCol,double dVal)
//		{
//			m_pData[nRow*m_nCol+nCol] = dVal;
//		}//隐含的内联函数：在头文件中直接实现函数调用

//		显式的内联函数写法：写在外部
    inline void CMatrix::Set(int nRow,int nCol,double dVal)
    {
        m_pData[nRow*m_nCol+nCol] = dVal;
    }

10.测试1
主函数：

int main(int argc, char *argv[])
{
    CMatrix m;
        double data[10] = {1,2,3,4,5,6};
        CMatrix m1(2,5,data);
        {
            CMatrix m2(2,5);//m2的生命周期在反大括号截止
            //当对象的生命周期结束，对象所在函数已调用完毕时，系统自动调用析构函数
        }

        CMatrix m3(m1);//拷贝m1到m3
        CMatrix ms[3] = {CMatrix(),CMatrix(2,5,data),"d://1.txt"};

        CMatrix m4;
        m4 = m1;//m1和m4输出相同，因为他们的地址空间是相同的
        m1.Set(0,1,20);//内联函数执行时不是采用函数调用方式，而是直接拷贝函数内的代码段使用，可提高效率
        //	当函数内代码超过十行以上或代码为循环、递归等不建议使用内联函数
        cout<<"m1=\n"<<m1;
        cout<<"m4=\n"<<m4;
        return 0;
}

测试结果：m4与m1的输出相同；

11.测试2
主函数：

int main(int argc, char *argv[])
{
    CMatrix m;
        double data[10] = {1,2,3,4,5,6};
        CMatrix m1(2,5,data);
        {
            CMatrix m2(2,5);//m2的生命周期在反大括号截止
            //当对象的生命周期结束，对象所在函数已调用完毕时，系统自动调用析构函数
        }

        CMatrix m3(m1);//拷贝m1到m3
        CMatrix ms[3] = {CMatrix(),CMatrix(2,5,data),"d://1.txt"};

        CMatrix m4;
        m4 = m1;//m1和m4输出相同，因为他们的地址空间是相同的
        m1.Set(0,1,20);//内联函数执行时不是采用函数调用方式，而是直接拷贝函数内的代码段使用，可提高效率
        //	当函数内代码超过十行以上或代码为循环、递归等不建议使用内联函数
        cout<<"m1=\n"<<m1;
        cout<<"m4=\n"<<m4;
		m4 = m4;
		cout<<"after= m4=\n"<<m4;
		//cout<<"m4[1]"<<m4[1];
		return 0;
}

测试结果：输出如图

12.操作运算符

CMatrix & CMatrix::operator=(const CMatrix& m)
{
    if(this==&m)
    {
        return *this;
    }
    Create(m.m_nRow,m.m_nCol,m_pData);
    return *this;
}

CMatrix & CMatrix::operator+=(const CMatrix& m)
{
    return *this;
}

CMatrix operator+(const CMatrix& m1,const CMatrix & m2)
{
    CMatrix m(m1);//拷贝构造函数
    m+=m2;
    return m;
}

13.强制类型转换

CMatrix::operator double()
{
    double dSum = 0;
    for(int i = 0; i < m_nRow*m_nCol; i++)
    {
        dSum += m_pData[i];
    }
    return dSum;
}