Ｃ＋＋学习笔记１１ 构造函数与析构函数

构造函数：

Ｃ＋＋中的类可以定义与类名相同的特殊成员函数

这种与类名相同的成员函数叫做构造函数

构造函数在定义的时候可以有参数，但是没有任何返回类型的声明

class Test
{
	private:
		int i;
		int j;
		int k;
	public:
		
		Test() 
		{
			i = j = k =0;
		}
		Test(int v)
		{
			i = j = k = v;
		}
		
		void print()
		{
			printf("i = %d,j = %d, k = %d\n",i,j,k);
		}
		
		void print(int v)
		{
			printf("v = %d\n",v);
		}
};

构造函数的调用：

一般情况下Ｃ＋＋编译器会自动调用构造函数

在一些情况下则需要手工调用构造函数

int main(int argc, char** argv) {
	
	Test t1(4); //自动调用构造函数 
	Test t2 = 5;//自动调用构造函数 
	Test t3 = Test(8);//手动调用构造函数
	
	//Test tA[3] ; ERROR
	Test tA[3] = {Test(1),Test(2),Test(3)}; //手动调用构造函数 
	for(int i = 0; i< 3;i++)
	{
		tA[i].print();
	}
	
	t1.print();
	t2.print();
	t3.print();	
	
	
	getchar(); 
	return 0;
}

成员函数的重载：

类的成员函数与普通函数一样可以进行重载，并遵守相同的重载规则。

class Test
{
	private:
		int i;
		int j;
		int k;
	public:
		
		Test() 
		{
			i = j = k =0;
		}
		Test(int v)
		{
			i = j = k = v;
		}
		
		void print()
		{
			printf("i = %d,j = %d, k = %d\n",i,j,k);
		}
		
		void print(int v)
		{
			printf("v = %d\n",v);
		}
};

两个特殊的构造函数：

class Test
{
public:
	/*
	Test()
	{
		printf("Test()\n");
	}
	*/ 
	Test(const Test& obj)
	{
		printf("Tset(const Test& obj)");
	}
	
};

int main(int argc, char** argv) {
	
	Test t1;
	Test t2 = t1;

	getchar(); 
	return 0;
}

两个特殊的构造函数分别是：

无参构造函数：当类中没有定义任何一种构造函数的时候，编译器默认提供一个无参构造函数，并且它的函数体为空，不做任何处理，只是使得编译通过

拷贝构造函数：当类中没有定义拷贝构造函数的时候，编译器默认提供一个拷贝构造函数，简单的进行成员变量的值复制。

#include <iostream>
#include <stdio.h>
/* run this program using the console pauser or add your own getch, system("pause") or input loop */

/*
注意：
1：当类中没有定义任何一个构造函数，C++编译器会为我们提供无参构造函数和拷贝构造函数
2：当类中定义了任意的非拷贝构造函数时，C++编译器不会为我们提供无参构造函数 
3:当类中定义了一个拷贝构造函数时，编译器也不会提供无参构造函数 
*/
class Test
{
	
private:
	
	int i;
	int j;
	int k;
	 
public:
	void print()
	{
		printf("i = %d, j = %d , k = %d\n", i,j,k);
	}
	
};

int main(int argc, char** argv) {
	
	Test t1;//调用无参构造函数，函数体为空，不做任何事情，就是为了可以编译通过 
	Test t2 = t1; 
	//这里输出的值一样，说明系统提供的拷贝构造函数做了一些事情，就是成员变量的复制，这里就是把
	//t1的成员变量的值都赋值给t2的成员变量，所以两者输出的一样。 
	t1.print();
	t2.print();
	

	getchar(); 
	return 0;
}

上面代码，最重要的注意是：　ｔ１.ｐｒｉｎｔ（）与ｔ２.ｐｒｉｎｔ（）输出的值一样，因为　ｔ２　＝　ｔ１　这里调用了编译器自己提供的默认拷贝构造函数

它做的事情就是简单的成员变量的赋值，即：ｔ２.ｉ　＝　ｔ１．ｉ；ｔ２．ｊ　＝　ｔ１．ｊ；　ｔ２．ｋ　＝　ｔ１．ｋ；所以两者输出的值是一样的。

 

写一个数组类：

#include <iostream>
#include <stdio.h>
#include "Array.h"

int main(int argc, char** argv) {
	
	
	Array a1(10);
	
	for(int i = 0 ;i < a1.length(); i++)
	{
		 a1.setData(i,i);
	}
	for(int i = 0; i< a1.length(); i++)
	{
		printf("Element i = %d\n", a1.getData(i));
	}
	printf("**********************************\n");
	
	Array a2 = a1;
	for(int i = 0; i< a2.length(); i++)
	{
		printf("Element i = %d\n", a2.getData(i));
	}
	
	a1.destory();
	
	a2.destory();
	//如果这里才用系统提供的默认的拷贝构造函数，它只是进行单纯的复制工作，所以a1与a2中的mSpace指向的是
	//同一个空间，当执行a1.destory之后，这片空间已经释放，执行a2.destory就会出错 
	
	
	getchar(); 
	return 0;
}

 

#ifndef _ARRAY_H_ 
#define _ARRAY_H_

#endif
class Array
{
	private:
		int mLength;
		int *mSpace;
		
	public:
		Array(int length);
		Array(const Array& obj);
		int length();
		void setData(int index, int value);
		int getData(int index);
		void destory();
};

 

#include "Array.h"

Array::Array(int length)
{
	if(length < 0)
	length = 0;
	mLength = length;
	mSpace = new int[mLength];
}

Array::Array(const Array& obj)
{
	mLength = obj.mLength;
	mSpace = new int[mLength]; //自己申请一个新的空间出来，而系统提供的就是指向同一个空间。 
	for(int i = 0; i < mLength; i++)
	{
		mSpace[i] = obj.mSpace[i];
	}
}
int Array::length()
{
	return mLength;
} 

void Array::setData(int index , int value)
{
	mSpace[index] = value;
}

int Array::getData(int index)
{
	return mSpace[index];
}

void Array::destory()
{
	mLength = -1;
	delete[] mSpace;
}

总结：

构造函数是Ｃ＋＋中用于初始化对象状态的特殊函数

构造函数在对象创建的时候自动被调用

构造函数和普通成员函数都遵循重载规则

拷贝构造函数是对象正确初始化的重要保证

 

注意：
1：当类中没有定义任何一个构造函数，C++编译器会为我们提供无参构造函数和拷贝构造函数
2：当类中定义了任意的非拷贝构造函数时，C++编译器不会为我们提供无参构造函数，但是会提供默认的拷贝构造函数

class Test
{
public:
	
	Test()
	{
		printf("Test()\n");
	}
	/*
	Test(const Test& obj)
	{
		printf("Tset(const Test& obj)");
	}
	*/
	
};

int main(int argc, char** argv) {
	
	Test t1;
	Test t2 = t1;

	getchar(); 
	return 0;
}

上面代码只提供了一个非拷贝构造函数，但是Ｔｅｓｔ　ｔ２　＝　ｔ１　仍然编译通过，说明编译器为我们提供了默认的拷贝构造函数。

3:当类中定义了一个拷贝构造函数时，编译器也不会提供无参构造函数（总之只要有一个我们自己添加的构造函数，编译器就不会再提供无参构造函数）