第十章 深入函数 简单

/*
//1 函数的重载 普通函数的重载
#include <iostream>
using namespace std;
void func(int);
void func(long);
void func(float);
void func(double);
int main()
{
    int a = 1;
	long b = 100000;
	float c = 2.1;
	double d = 2.1415926;
	func(a);
	func(b);
	func(c);
	func(d);
	return 0;
}
void func(int a){
    cout<<"int: a="<<a<<endl;
}
void func(long a){
    cout<<"long: a="<<a<<endl;
}
void func(float a){
    cout<<"float: a="<<a<<endl;
}
void func(double a){
    cout<<"double: a="<<a<<endl;
}
*/


/*
//2 函数的缺省参数
#include <iostream>
using namespace std;
//void func(int a=0, int b=0)
//{
//    cout<<"a:"<<a<<endl;
//	cout<<"b:"<<b<<endl;
//};

class A{
public:
	void set(int = 30, int = 5);
	void count(bool = false);
private:
	int w;
	int h;
};

void A::set(int width, int height)
{
     w = width;
	 h = height;
}

void A::count(bool val)
{
	if(val == true){
	   cout<<"val的值为真时:"<<w*h<<endl;
	}else{
	   cout<<"val的值为假时:"<<w*h/2;
	}
}

int main()
{
	//func();
	A a;
	a.set();
	a.count();
    return 0;
}
*/

/*
//重载构造函数
#include <iostream>
using namespace std;
class rectangle
{
public:
	rectangle(){cout<<"构造一个长方形"<<endl;}
	rectangle(int l, int w){ lenght = l, width=w; cout<<"长方形的b的面积为:"<<lenght*width<<endl;}
	rectangle(int l, int w, int h){lenght=l, width=w, height=h; cout<<"长方体体职为:"<<lenght*width*height<<endl;}

	int area(){ 
	    cout<<"length:"<<lenght<<endl;
		cout<<""<<width<<endl;	

		return lenght * width;
	
	}
private:
	int lenght;
	int width;
	int height;
};

int main()
{
	rectangle a;
	rectangle b(11,22);
	rectangle c(11,22,33);
	//cout<<"a的面积为:"<<a.area()<<endl;
	//cout<<"b的面积为:"<<b.area()<<endl;
	//cout<<"c的面积为:"<<c.area()<<endl;

    return 0;
}
*/

/*
// 4 成员变量的初始化
#include <iostream>
using namespace std;
class rectangle
{
public:
	//rectangle(){cout<<"构造一个长方形"<<endl;}
	//rectangle(int l, int w){ lenght = l, width=w; cout<<"长方形的b的面积为:"<<lenght*width<<endl;}
	//rectangle(int l, int w, int h){lenght=l, width=w, height=h; cout<<"长方体体职为:"<<lenght*width*height<<endl;}
	
	//而在文件头是为函数参数进行初始化
	rectangle():lenght(1),width(2){ cout<<"长方形的面积为:"<<lenght*width;}
	//rectangle(){ lenght=3, width=4;} //这种方法是为成员函数进行赋值


	int area(){ 
	    cout<<"length:"<<lenght<<endl;
		cout<<""<<width<<endl;	

		return lenght * width;
	
	}
private:
	//int lenght;
	const int lenght;
	int width;
	int height;
};

int main()
{
	rectangle a;
	//rectangle b(11,22);
	//rectangle c(11,22,33);
	//cout<<"a的面积为:"<<a.area()<<endl;
	//cout<<"b的面积为:"<<b.area()<<endl;
	//cout<<"c的面积为:"<<c.area()<<endl;

    return 0;
}*/

/*
// 5 成员变量的初始化与构造函数
#include <iostream>
using namespace std;

class demo
{
public:
	demo(){cout<<"demo构造函数"<<endl;}
	demo(int i){ x = i; cout<<"demo构造带一个参数"<<endl;}
	int get(){ return x;}
private:
	int x;
};

class rectangle
{
public:
	rectangle():x(100){ cout<<"rectangle构造函数"<<x<<endl;}
	rectangle(int _x, int w, int h):x(_x),width(w),height(h)
	{
		cout<<"rectangle带三个参数构造函数:面符号为:"<<width.get()*height.get()<<endl;
	}
	
	~rectangle(){ cout<<"析构函数"<<endl;}
    int area(){ return height.get()*width.get();}

private:
	int x;
	demo width;
	demo height;
};


int main()
{
	rectangle(100,200,300);
    return 0;
}


#include <iostream>
using namespace std;
class A
{
public:
	//A(int a, int b)
	//{
	    //number = a;
		//total = b;
	//}
	//这里就需要在头来实现参数的初始化
	A(int a, int b):number(a),total(b)
	{
	
	}
    
	void set(int i, int y=11, int x=11){
		cout<<"i:"<<i<<", y:"<<y<<", x:"<<x<<endl;
	
	}
private:
	//int number;
	//int total;
	//如果number是一个const，total是一个引用,那么上面的赋值构造函数就不行
	const int number;
	int &total;
};

int main()
{
	A a(22,33);
	a.set(22);
    return 0;
}
*/

/*
// 复制构造函数
#include <iostream>
using namespace std;
class A
{
public:
	A(){}
	A(A &a){ this->n=a.n; this->m = a.m;}
	A(int i, int j){ n=i, m=j;}
	void print()
	{
	   cout<<"m:"<<m<<",n:"<<n<<endl;
	}
private:
	int n;
	int m;
};

int main()
{
	A a(2,4);
	a.print();
	A b = a;
	b.print();

    return 0;
}
*/

/*
// 7 构造函数和NEW运算符
#include <iostream>
using namespace std;

class A
{
public:
	A(){ cout<<"构造函数执行"<<endl;}
	void set(int a, int b)
	{
	   i = a;
	   j = b;
	}
	void parint()
	{
	   cout<<"i:"<<i<<", j:"<<j<<endl;
	}
private:
	int i;
	int j;
};
int main()
{
	//A a;
	//a.set(2,3);
	
	A *a = new A();
	a->set(2,3);
	a->parint();
    return 0;
}
*/

/*
// 8 再谈默认构造函数
#include <iostream>
using namespace std;
class A
{
public:
	A(){}
	A(int i){ x=i;}
private:
	int x;
};
int main()
{
    A a;
	A b(2);
    return 0;
}
// 每个对像在创建时都要调用构造函数来为自已初始化，假如你没提供一个构造函数，那么编译器就会自动创建立一个默认的构造函数
//假如你创建一个构造函数，不管你创建的是默认构造函数还是带参数的构造函数
//编译器都不再为你提供任何默认构造函数，假如你还想要一个带参数的构造函数，那么你就必须自已再创建一个
*/

/*
// 9 析构函数和delete运算符
#include <iostream>
using namespace std;
class A
{
public:
    A(){ cout<<"构造函数执行"<<endl;}
	~A(){ cout<<"析构函数执行"<<endl;}
};
int main()
{
	A *p = new A();
	delete p;
    return 0;
}
*/

/*
// 10 默认析构函数
#include <iostream>
using namespace std;
class A
{
public:
    A(){ cout<<"构造函数执行"<<endl;}
	//~A(){ cout<<"析构函数执行"<<endl;}
	//这里将调用默认的析构函数
};
int main()
{
	A *p = new A();
	delete p;
    return 0;
}
*/

/*
// 11 调用构造函数进行类型转换
#include <iostream>
using namespace std;
class A
{
public:
	//explicit关键字关闭隐式转换
	//这里将不能进行隐式转换
	explicit A(int x){ i = x; cout<<"构造函数执行"<<i<<endl;}
	~A(){ cout<<"析构造函数执行"<<i<<endl;}
	void get(){ cout<<i<<endl;}
private:
	int i;
};
int main()
{
	A a(199);
	a.get();

	//隐式转换
	//a = 1000; //类型转换，相当于 a = A(1000);
	
	//显示转换
	a = A(1000); //转换类型, 将1000强制转换为a 中的i参数
	


    return 0;
}
*/

/*
//12  浅层复制构造函数
#include <iostream>
using namespace std;
class A
{
public:
	A(){ x = new int; *x = 5;}
	~A(){ delete x; x = NULL; cout<<"析构函数执行";}
	A(const A &a)
	{
	     cout<<"复制构造函数执行..."<<endl;
		 x = a.x;
	}
	void print(){ cout<<*x<<endl;}
	void set(int i){ *x = i;}
private:
	int *x;
};
int main()
{
	A *a = new A();
	cout<<"a:";
	a->print();
	cout<<"a的地址是:"<<a<<endl;

	A b = (*a); //复制函数
	b.print();  // 5 
	cout<<"b的地址是:"<<&b<<endl;
	
	a->set(33); 
	cout<<"b:";
	b.print(); //33,这里的复制，但是对像类的参数地址都是在一个地方
	cout<<endl;
	
	
	//delete a; //浅层复制会有秘途指针的问题,但这里还是没有了解秘途指针是在那一步出现的

	

	//这里的复制

	return 0;
}
*/

//13 深层复制构造函数
//为了解决浅层复制导致的迷途指针问题，我们必须创建自己的复制构造函数
//并且在函数里为我们的成员变量分配内存，这样，在分配完内存后，旧对像的成员变量就可以复制到新的内存区域中，
//两个对象的成员变量都各自拥有自己的内存区域，一个对象在析构后不再会影响到另一个，我们把这种复制方式叫做深层复制
#include <iostream>
using namespace std;
class A
{
public:
	A(){ x =  new int; *x = 9;}
	~A(){ delete x; x = NULL; cout<<"析构函数执行"<<endl;}
	A(const A &a){
	    cout<<"复制构造函数执行...."<<endl;
		x =  new int;
		*x = *(a.x); //重新为x审请一块内存空间
	}
	void print()const{ cout<<*x<<endl; }
	void set(int i){ *x  = i;}
private:
	int *x;
};

int main()
{
	A *a = new A();
	cout<<"a:";
	a->print();
	cout<<endl;

    A b = (*a);
	cout<<"b:";
	b.print();
	cout<<endl;

	a->set(55);
	cout<<"a:";
	a->print();
	cout<<endl;
	cout<<"b:";
	b.print();
	cout<<endl;


	b.set(66);
	cout<<"a:";
	a->print();
	cout<<endl;
	cout<<"b:";
	b.print();
	cout<<endl;

	delete a;
	b.print();



	return 0;
}