C++构造与重载详解-优快云博客

本文链接：https://blog.youkuaiyun.com/mlyhzt/article/details/110152415

①.构造函数的定义与使用

构造函数是特殊的共有成员函数

1.函数名与类名相同；
2.构造函数无函数返回类型说明。注意是没有而不是void,即什么也不写，也不可写void!实际上构造函数有返回值，返回的就是构造函数所创建的对象；
3.在程序运行时，当新的对象建立，该对象所属的类的构造函数自动被调用，在该对象生存期中也只调用这一次；
4.构造函数可以重载，严格的讲，说明中可以有多个构造函数，它们由不同的参数表区分，系统在自动调用时按一般函数重载的规则选一个执行；
5.构造函数可以在类中定义，也可以在类外定义；
6.如果类说明中没有给出构造函数，则C++编译器自动给出一个缺省的构造函数；类名（void）{} 但只要我们定义了一个构造函数，系统就不会自动生成缺省的构造函数；（只要构造函数是无参的或者只要各参数均有缺省值的，C++编译器都认为是缺省的构造函数，并且缺省的构造函数只能有一个）。
eg:

//商品类CGoods的构造函数
//可以是三个参数
CGoods(char* name,int amount,float price)
{
	strcpy(Name,name);
	Amount = amount;
	Price = price;
	Total_value = price*amount;
}
//也可以是两个参数
CGoods(char* name,float price)
{
	strcpy(Name,name);
	Price = price;
	Amount = 0;
	Total_value = 0.0;
}
//缺省的构造函数
CGoods()
{
	Name[0] = '\0';
	Price = 0.0;
	Amount = 0;
	Total_value = 0.0;
}
/*
//利用初始化列表的方式来构建构造函数
CGoods(int x= 0):value(x)
{
}
*/
int main()
{
	CGoods Car1("夏利2000"，30，98000.0);//调用第一个带三个参数的构造函数
	//等价于 CGoods Car1 = CGoods("夏利2000"，30，98000.0)；
	CGoods Car2("桑塔纳2000"，164000.0);调用第二个带有两个参数的构造函数
	CGoods Car3;//定义时调用不带参的缺省构造函数，定义对象时不能加括号
	
	return 0;
}

②析构函数的定义与使用

	当一个对象定义时，c++自动调用构造函数建立该对象并进行初始化，那么当一个对象的生命周期结束时，c++
也会自动地调用一个函数注销该对象并进行善后工作，这个特殊的成员函数就是析构函数。
	析构函数是成员函数的一种，它的名字与类名相同，但前面要加~，没有参数和返回值

一个类有且仅有一个析构函数，如果定义类时没写析构函数，则编译器生成默认析构函数；如果定义了析构函数，则编译器不生成默认析构函数。

	(1).析构函数与类名相同，但在前面加上字符‘~’，如~CGoods();
	(2).析构函数无函数返回类型，与构造函数在这方面是一样的，但析构函数不带任何参数。
	(3).一个类有一个也只有一个析构函数，这与构造函数不同；
	(4).对象注销时，系统自动地调用析构函数。

eg:

~CGoods()
{
	
}

对象如果在生存期间用new运算符动态分配了内存，则在各处写delete语句以确保程序的每条执行路径都能释放这片内存是比较麻烦的事情。有了析构函数，只要在析构函数中调用delete语句，就能确保对象运行中用new运算符分配的空间在对象消亡时被释放。
eg:

class String
{
private:
	char* p;
public:
	String(int n);
	~String();	
};
String::~String()
{
	delete[] p;
}
String::String(int n)
{
	p = new char[n];
}

String类的成员变量p指向动态分配的一片存储空间，用于存放字符串。动态内存分配在构造函数中进行，而空间的释放在析构函数~Sting（）中进行。这样，在其他地方就不用考虑释放空间的事情了。

③拷贝构造函数

（用一个已存在的对象生成相同类型的新对象）

同一个类的对象在内存中有完全相同的结构，如果作为一个整体进行复制或称拷贝是完全可行的，这个拷贝过程只需要拷贝数据成员，而函数成员是公用的。在建立对象时可用同一类的另一个对象来初始化该对象，这时所用的构造函数称为拷贝构造函数。

CGoods(const CGoods & cgd)
{
	Strcpy(name,cgdName);
	Price  = cgdprice;
	Amount = cgdamount;
	Total_value = cgd.Total_value;
}

//实例：
CGoods Car1("夏利2000"，30，98000.00)；
//调用三个参数的构造函数
CGoods Car2 = Car1;//调用拷贝构造函数
CGoods Car3(CAr1);//调用拷贝构造函数，Car1为实参

//这样三个对象的初始化结果完全一样

注意：拷贝构造函数的参数——采用引用（如果把一个真实的类对象作为参数传递到拷贝构造函数，会引起无穷递归）。
参数加上const ,是为了安全性，保护对象，防止通过别名让形参修改实参的值

浅拷贝和深拷贝
eg:

	//浅拷贝
	String(const String & s)
	{
		str = s.str;
	}
	//深拷贝
	String(const String & s)
	{
		int n = strlen(s.str)+1;
		str = new char[n];
		strcpy(str,s.str);
	}
	当用一个已存在的空对象去生成相同类型的新对
象时，strlen函数不能计算空指针的大小，所以用此
拷贝构造函数会出错。
修改函数：
String(const char *p = NULL)
{
	if(NULL == p)
	{
		str = new char[1];
		*str = '\0';
	}
	else
	{
		int n = strlen(p) + 1;
		str = new char[n];
		strcpy(str,p);
	}
}
String(const String & s)
{
	int n = strlen(s.str)+1;
	str = new char[n];
	strcpy(str,s.str);
}

④运算符的重载函数

    运算符的重载实际是一种特殊的函数重载，必须定义一个函数，当遇到该重载的运算符时调用此函数，这个函数
叫做运算符重载函数，通常为类的成员函数。
定义运算符重载函数的格式：
返回值类型 类名：：operator重载的运算符（参数表）
{
	......
}
operator是关键字，它与重载的运算符一起构成函数名。

在类定义中如果没有显式给出赋值运算符重载函数，并不是不用赋值函数，而是由系统自动调用缺省的赋值函数

class Complex
{
private:
	double Real,Image;
public:
	Complex(double r = 0.0,double i = 0.0):Real(r),Image(i)
	{
		cout<<"Create Object: "<<this<<endl;
	}	
	Complex(const Complex Object& com):Real(com.Real),Image(com.Image)
	{
		cout<<"Copy Create Object: "<<this <<endl;
	}
	~Complex()
	{
		cout<<"Destroy Object: "<<this<<endl;
	}
	Object& operator=(const Object& obj)
	{
		if(this != &obj)
		{
			num = obj.num;
			ip = (int*)malloc(sizeof(int) * num);
			for(int i = 0; i < num; i++)
			{
				ip[i] = obj.ip[i];
			}
		}
		return *this;
	}
};

eg:

//加法运算符的重载
class Int
{
	//Int operator+(const Int* const this,const Int &x)
	Int operator+(const Int &x) const
	{
		int cal = this->value+x.value;
		return Int(val);
	}
	//Int operator+(const Int * const this,int x)
	Int operator+(int x) const
	{
		intval = this->value+x;
		return Int(val);
	}
};

Int operator+(int x,const Int &y)
{
	return y + x;
}

int main()
{
	Int a(10),b(20),c;
	int x = 100;
	c = a+b;
	//c = a.operator+(b);
	//c = operator+(&a,b);
	c = a+ x;
	c = a.operator+(x);
	//c = operator+(&a,x);

	c = x + a;
	c = operator+(x,a);
}

运算符重载函数的函数名必须为关键字operator加一个合法的运算符。在调用该函数时，将右操作数作为函数的实参。

前置++和后置++的运算符重载函数

前置“++”格式为：
	返回类型 类名：：operator++(){......}
后置“++”格式为：
	返回类型 类名::operator++(int){......}
	后置++中参数int仅用作区分，并无实际意义，可以给一个变量名，也可以
不给变量名。
Int & operator++()
{
	this->value += 1;
	return *this;
}

Int operator++(int)
{
	int val = this->value;
	this->value += 1;
	return Int(val);
}

赋值运算符的重载函数

	Object & operator=(const Object &obj)
	{
		if(this != &obj)
		{
			this->value = obj.value;
		]
		return *this;
	}

	int main()
	{
		Object a(10);
		Object b(a);
		Object c(0);
		
		c = a;
		c = a = b;
		c = a.operator=(b);
		//c = operator=(&a,b);
		return 0;
	]

以值的方式返回时，会创建临时对象；
如果以引用方式返回，将不会构建临时对象，生存期不受函数生存期的影响的对象可以以引用方式返回。

eg:

赋值运算符的重载函数
String & operator=(const String &s)
{
	if(this != &s)
	{
		delete []this->str;
		int n = strlen(s.str)+1;
		this->str = new char[n];
		strcpy(this->str,s.str);
	}
	return *this;
}

加号‘+’运算符的重载函数

class String()
{
private:
	char* str;	
public:
	//String & operator+(const String * const this,const String &s)
	String operator+(const String &s)const
	{
		int len = strlen(this->str)+strlen(s.str)+1;
		char *sp = new char[len];
		strcpy(sp,this->str);
		strcat(sp,s.str);
		return String(sp,0);
	}
	//String operator+(const String * const this,const char *sp);
	String operator+(const char *sp)
	{
		return *this + String(sp);
	}
};

String operator+(const char *sp,const String &s)
{
	return String(sp)+s;
}

int main()
{
	String s1("yhping");
	String s2("tulun");
	String s3;
	char *str = "hello";

	s3 = s1 + s2;
	s3 = s1.operator+(s2);
	s3.PrintString();
	s3 = s1 + str;
	s3 = s1.operator+(str);
	return 0;
}

注：普通对象可以调用普通方法，也可以调用常方法；但是常对象只能调用常方法，不可以调用普通方法。

//下标“[]”运算符的重载函数

char & operator[](int index)
{
	return str[index]; 
}

//优化版本的String类

class String
{
	struct StrNode
	{
		int ref;
		int size;
		int len;
		char data[];
	};
	private:
		StrNode *pstr;
	public:
		String(const char *str = NULL)//构造函数
		{
			if(str != NULL)
			{
				int n = strlen(str)+1;
				pstr = (StrNode*)malloc(sizeof(StrNode)+2*n);
				pstr->ref = 1;
				pstr->len = n;
				pstr->size = 2*n;
				strcpy(pstr->data,str);
			}
			else
			{
				pstr = NULL;
			}
		}
		String(const String &st):pstr(st.pstr)//拷贝构造函数
		{
			if(st.pstr != NULL)
			{
				st.pstr->ref += 1;
			}
		}
		~String()//析构函数
		{
			if(pstr  != NULL && --pstr->ref == 0)
			{
				free(pstr);
			}
			pstr = NULL;
		}
};
int main()
{
	String s1("yhping");
	String s2(s1);
	String s3(s1);
	
	return 0;
}