滴水-day29-构造-析构-继承

#include <iostream>

using namespace std;

void Test()
{
	DateInfo dateInfo;
	TimeInfo timeInfo;

	DateInfo* p = &timeInfo;
	printf("%d\\\\n",p->day);

	// 错误，无法通过父类直接访问子类成员
	//printf("%d", p->hour);

	// 子类指向自己，可以正常访问
	TimeInfo* pTime = &timeInfo;
	cout <<  pTime->day << endl;;
	cout <<  pTime->hour << endl;

	// 因为继承了DateInfo，所以可以访问父类的成员变量和成员方法
	cout << pTime->GetDay() << endl;

}

struct MyString
{

	char* myString;

	MyString(char* myString)
	{
		this->myString = (char*)malloc(1024);
		strcpy_s(this->myString, 1024, myString);
	}

	MyString()
	{
		myString = (char*)malloc(1024);
	}

	// 析构函数
	~MyString()
	{
		free(myString);
		cout << "析构函数执行" << endl;
	}

	void SetString(char* myString)
	{
		strcpy_s(this->myString, 1024, myString);
	}
	void printString()
	{
		cout << myString << endl;
	}
	void AddendString(char* myString)
	{
		strcat_s(this->myString, 1024, myString);
	}

	int GetSize()
	{
		return strlen(myString);
	}
};

void Test_two()
{
	MyString mystring;
	mystring.SetString((char*)"ABCD");
	mystring.printString();
	mystring.AddendString((char*)"EF");
	mystring.printString();

	cout << mystring.GetSize() << endl;
}

int main()
{
	//Test();
	Test_two();
	return 0;
}

构造函数

1.构造函数与类(结构体)同名

2.构造函数可有可无

3.有参构造函数在实例化对象的时候必须传递参数

4.无参构造函数可以在实例化对象的时候不传递参数

5.无参构造函数可对成员变量做初始化操作

析构函数

在特殊情况下，需要对成员变量进行空间分配的时候，这个空间需要自己关闭，但是关闭的时机不好把握，关闭早了无法再次使用这个空间，关闭晚了就会照成内存泄漏。

析构函数的特点就是当这个对象的所调用的函数执行完毕后再次执行析构函数，可以理解为对该类做一个清理的工作，所以在这里对动态空间进行关闭是再合适不过的了。

析构函数是编译器主动调用的，不需要开发者主动调用

语法：

~类名()
{
	// Code
}

1.析构函数无法重载，因为重载后编译器不知道调用哪个了。

2.析构函数没有参数，没有返回值。

继承

struct DateInfo
{
	int year;
	int moth;
	int day;

	DateInfo(int year, int moth, int day)
	{
		this->year = year;
		this->moth = moth;
		this->day = day;
	}
	DateInfo()
	{
		this->year = 2015;
		this->moth = 4;
		this->day = 2;
	}

	void SetDay(int day)
	{
		this->day = day;
	}
	int GetDay()
	{
		return this->day;
	}
	void SetYear(int year)
	{
		this->year = year;
	}
	int Getyear()
	{
		return this->year;
	}
	void SetMoth(int moth)
	{
		this->moth = moth;
	}
	int GetMoth()
	{
		return this->moth;
	}

};

struct TimeInfo:DateInfo
{
	int hour;
	int Miunte;
	int Second;

	TimeInfo(int hour, int Miunte, int Second)
	{
		this->hour = hour;
		this->Miunte = Miunte;
		this->Second = Second;
	}
	TimeInfo()
	{
		this->hour = 14;
		this->Miunte = 2;
		this->Second = 33;
	}
	int Gethour()
	{
		return this->hour;
	}
	int GetMiunte()
	{
		return this->Miunte;
	}
	int GetSecond()
	{
		return this->Second;
	}
};

继承语法

TimeInfo:DateInfo
void Test()
{
	DateInfo dateInfo;
	TimeInfo timeInfo;

	DateInfo* p = &timeInfo;
	printf("%d\\\\n",p->day);

	// 错误，无法通过父类直接访问子类成员
	//printf("%d", p->hour);

	// 子类指向自己，可以正常访问
	TimeInfo* pTime = &timeInfo;
	cout <<  pTime->day << endl;;
	cout <<  pTime->hour << endl;

	// 因为继承了DateInfo，所以可以访问父类的成员变量和成员方法
	cout << pTime->GetDay() << endl;
}

1.被继承的类称为父类或基类，继承的类称为子类或派生类。

2.继承父类的成员变量和成员方法，构造函数和析构函数不会继承。

3.继承可以理解为就是数据的复制，复制父类的数据到子类一份。

4.timeInfo/dateInfo是对象/实例

多层继承

struct X
{
	int a;
	int b;
};
struct Y :X
{
	int c;
	int d;
};
struct Z :Y
{
	int e;
	int f;
};

void Test_3()
{
	Z z;

	z.a = 1;
	z.b = 2;
	z.c = 3;
	z.d = 4;
	z.e = 5;
	z.f = 6;

	printf("%d\\\\n", sizeof(z));
}

多重继承，多重复制，Z为子类，Y为父类，X为父父类。

这种继承方式是微软推荐的，因为继承关系明确清晰，不易出错。

多重继承

struct X
{
	int a;
	int b;
};
struct Y
{
	int c;
	int d;
};
struct Z:X,Y
{
	int e;
	int f;
};

Z z;

z.a = 1;
z.b = 2;
z.c = 3;
z.d = 4;
z.e = 5;
z.f = 6;

printf("%d\\\\n",sizeof(z));

一个子类可以有多个父类，但是这种继承方式容易出错，微软也不推荐这种方式，

确实需要多重继承可以转为多层继承的方式。

day28-this指针