C++类二篇

#include <iostream>
#include <cstdlib>
#include <string>
#include <vector>
#include "project3.hpp"
#include "project2.h"

using namespace std;

//一个临时的小类-创建对象作为Time类的一个成员属性
class TemClass
{
public:
	TemClass()
	{
		cout << "TemClass的构造函数" << endl;
	}

	TemClass(TemClass&tem_class)
	{
		cout << "TemClass的拷贝构造函数" << endl;
	}
};


class Time
{
private:
	int Hour;
	int Minute;
	int Second;
public:
	//TemClass tem_class;
	
public:
	explicit Time(int Hour, int Minute, int Second);
	Time() = default;
	
public:
	//拷贝构造函数
	Time(Time&myTime, int TemHour = 10, int Teminute=10, int TemSecond=10);

};

Time::Time(int TemHour, int Teminute, int TemSecond) :Hour(TemHour), Minute(Teminute), Second(TemSecond)//把形式参数赋值给成员属性
{
}

//拷贝构造函数
Time::Time(Time& mytime, int temhour, int teminute, int temsecond):Hour(12),Minute(12),Second(12)
{
	cout << "这是time类的拷贝构造函数" << endl;
	//this->hour = mytime.hour;	//ok
}

void myFunciton01(Time Te)
{
	;
}

Time myFunction02()
{
	Time t;
	return t;
}
int main(void)
{
	//二、拷贝构造函数
	// Time myTime01 = Time(12,12,12); // 因为和拷贝构造函数冲突，
	/*Time(12,12,12)调用重载的有参构造函数， = Time(12,12,12);调用拷贝构造函数。因为自定义了拷贝构造函数，所以使得默认的拷贝构造函数失效，
	  导致类对象的拷贝无法每个成员变量逐个拷贝。因此出错。
	*/
	Time myTime;  // 调用无参的构造函数
	Time myTime04(12,12,12); //调用有参的构造函数
	Time myTime2 = myTime; //拷贝构造函数--类对象的拷贝， 有隐式转换， 若在拷贝构造函数加上explicit，则出错。
	Time myTime03(myTime);  //拷贝构造函数
	Time myTime04{ myTime };  //拷贝构造函数
	Time myTime05={ myTime };  //拷贝构造函数 //有隐式转换

	Time myTime06 = myTime;	//调用了拷贝构造函数， 有隐式转换 
    // 拷贝构造函数，用在定义时，用于初始化。而拷贝赋值运算符，是用于赋值。

	//四、还有一些情况会调用拷贝构造函数的调用
	//四-(1)
	myFunciton01(myTime06);   // 调用拷贝构造函数
	//四-(2)
	// Time t = myFunction02();
	return 0;
}

#include <iostream>
#include <cstdlib>
#include <string>
#include <vector>
#include "project3.hpp"
#include "project2.h"

using namespace std;

class Time
{
private:
	int Hour;
	int Minute;
	int Second;
public:
	explicit Time(int Hour, int Minute, int Second);
	Time(Time&TemTime);
	Time(int Hour);
	Time();
	~Time();
};

Time::~Time()
{
	cout << "析构函数" << endl;
}

Time::Time(int TemHour, int TemMinute, int TemSecond) :Hour(TemHour), Minute(TemMinute), Second(TemSecond)//把形式参数赋值给成员属性
{
}
Time::Time(int Hour)
{
	this->Hour = Hour;
}
//拷贝构造函数
Time::Time(Time& TemTime)
{
	this->Hour = TemTime.Hour;
	this->Minute = TemTime.Minute;
	this->Second = TemTime.Second;
}
Time::Time()
{
	;
}

int main(void)
{
	Time myTime01(12, 12, 12);
	Time myTime02 = myTime01;	//初始化--调用拷贝构造函数
	Time myTime03;

	myTime03 = myTime01;	//这个是赋值运算符，系统默认重载

	//使用new创建对象, 返回的是创建对象的指针（地址）
	Time *Ti = new Time;//调用无带参数的构造函数
	Time*Ti2 = new Time();//调用无带参数的构造函数 ----两个区别不研究

	//new出来的对象必须自己手动释放
	delete Ti;	//调用析构函数
	delete Ti2;
	return 0;
}

#include <iostream>
#include <cstdlib>
#include <string>
#include <vector>
#include "project3.hpp"
#include "project2.h"

using namespace std;

class Time
{
private:
	int Hour;
	int Minute;
	int Second;
public:
	explicit Time(int Hour, int Minute, int Second);
	Time(Time&TemTime); //自定义拷贝构造函数
	Time(int Hour);
	Time() = default; // 使用编译器默认无参构造函数

public:
	//重载赋值运算符
	Time& operator=(const Time&TemTime);
};

Time::Time(int Hour, int Minute, int Second) :Hour(Hour), Minute(Minute), Second(Second)//把形式参数赋值给成员属性
{
	cout<<"调用explicit Time(int Hour, int Minute, int Second)"<<endl;
}
Time::Time(int Hour)
{
	this->Hour = Hour;
}
//拷贝构造函数
Time::Time(Time& TemTime)
{
	this->Hour = TemTime.Hour;
	this->Minute = TemTime.Minute;
	this->Second = TemTime.Second;
}

//重载赋值运算符
Time& Time::operator=(const Time& TemTime)	//建议写上const，常量属性
{
	this->Hour = TemTime.Hour;
	this->Minute = TemTime.Minute;
	this->Second = TemTime.Second;
	return *this;
}

int main(void)
{
	//一、拷贝赋值运算符
	// Time myTime01 = Time(12,12,12); // 因为和拷贝构造函数冲突，
	/*Time(12,12,12)调用重载的有参构造函数， = Time(12,12,12);调用拷贝构造函数。因为自定义了拷贝构造函数，所以使得默认的拷贝构造函数失效，
	  导致类对象的拷贝无法每个成员变量逐个拷贝。因此出错。
	*/
	Time myTime01;  //调用无参构造函数
	Time myTime04(12,12,12); //调用有参的构造函数
	Time myTime02 = myTime01;	//初始化--调用拷贝构造函数
	Time myTime03;  //调用无参构造函数
	
	myTime03 = myTime01;	//这个是赋值运算符，系统默认重载，没有调用拷贝构造函数
	//系统会调用一个拷贝赋值运算符,我们可以自己进行运算符的重载,重载后调用重载后的重载函数
	//myTime03就是赋值运算符重载返回的*this
	//等价于
    // 但是拷贝构造函数，用在定义时，用于初始化。而拷贝赋值运算符，是用于赋值。
    // 64行没有产生新的对象，因此是赋值，不是拷贝构造

	// 二、重载赋值运算符
	myTime03.operator=(myTime01);
	
	return 0;

}

// 类内重载
#include <iostream>
using namespace std;
class complex
{
public:
	complex() { real = 0; imag = 0; } //定义构造函数
	complex(double r, double i) { real = r; imag = i; }//构造函数重载
	complex operator +(complex& c2) //定义重载运算符+的函数
	{
		complex c;
		c.real = real + c2.real;
		c.imag = imag + c2.imag;
		return c;//返回局部对象
	}
	void display()//定义输出函数
	{
		cout << "(" << real << "," << imag<< "i)"<< endl;
	}
private:
	double real;
	double imag;
};
int main()
{
	complex c1(3, 4), c2(5, -10), c3;
	c3 = c1+c2;//c3=c1.operator(c2)
	c1.display();
	c2.display();
	c3.display();
	return 0;
}
————————————————————————————————
// 类外重载-友元函数
#include <iostream>
using namespace std;
class complex
{
public:
	friend complex operator +(complex& c1, complex& c2); //重载函数作为友元
	complex() { real = 0; imag = 0; }//定义构造函数
	complex(double r,double i) { real = r; imag = i; }//构造函数重载
	void display()//定义输出函数
	{
		cout << "(" << real << "," << imag<< "i)"<< endl;
	}
private:
	double real;
	double imag;
};
//定义运算符+重载函数
complex operator +(complex& c1, complex& c2)
{
	return complex(c1.real + c2.real, c1.imag + c2.imag);
}
int main()
{
	complex c1(3, 4), c2(5, -10), c3;
	c3 = c1+c2;//c3=operator(c1,c2)
	c1.display();
	c2.display();
	c3.display();
	return 0;
}

#include <iostream>
#include <cstdlib>
#include <string>
#include <vector>
#include "project3.hpp"
#include "project2.h"

using namespace std;

class Time
{
private:
	int Hour;
	int Minute;
	int Second;
public:
	explicit Time(int Hour, int Minute, int Second);
	Time(Time&TemTime);
	Time(int Hour);
	Time() = default;
public:
	~Time()
	{
		cout << "析构函数执行" << endl;
	}
};

Time::Time(int TemHour, int TemMinute, int TemSecond) :Hour(TemHour), Minute(TemMinute), Second(TemSecond)//把形式参数赋值给成员属性
{
}
Time::Time(int Hour)
{
	this->Hour = Hour;
}
//拷贝构造函数
Time::Time(Time& TemTime)
{
	this->Hour = TemTime.Hour;
	this->Minute = TemTime.Minute;
	this->Second = TemTime.Second;
}
void playObj()
{
	Time myTime01(12, 12, 12);
	Time myTime02 = myTime01;	//初始化--调用拷贝构造函数
	Time myTime03;
	myTime03 = myTime01;	//这个是赋值运算符，系统默认重载
}

int main(void)
{
	playObj();
	return 0;
}

#include <iostream>
#include <cstdlib>
#include <string>
#include <vector>
#include "project3.hpp"
#include "project2.h"

using namespace std;

class Human
{
private:
	
public:
	//构造函数
	Human();
	Human(int m_i,string str,int myProtected,int myPrivate);

	//析构函数
	~Human();
	
public:
	int age;	//年龄
	string str;	//名字
	void myPubFunction() { ; }

public:	//父类的同名函数构成函数重载
	void myFunction();
	void myFunction(int tem);
protected:	//只能在子类的成员函数中调用
	int myProtected;	//本类和子类的成员函数可以访问
	void myProFunction() { ; }
private://子类都不能访问
	int myPrivate;
	void myPriFunction() { ; }
};

//构造函数
Human::Human()
{
	cout << "执行了Human默认构造函数" << endl;
}

Human::Human(int age, string str,int myWeath,int myPrivete)
{
	this->age = age;	
	this->str = str;
	this->myProtected = myWeath;
	this->myPrivate = myPrivete;
	cout << "执行了Human带参数的构造函数" << endl;
}

//析构函数
Human::~Human()
{
	cout << "执行了Human析构函数" << endl;
}

void Human::myFunction()
{
	cout << "myFunction" << endl;
}

void Human::myFunction(int tem)
{
	cout << "myFunction" << tem << endl;
}

class Man:public Human	//男人类继承自Human类
{
public:
	Man();
	void myFunction(int tem);
public:
	using Human::myFunction;	//vs2015对这个支持不太好
};

void Man::myFunction(int tem)
{
	Human::myFunction(3);
	Human::myFunction();
	cout << "myFunction man：" << tem << endl;
}

Man::Man()
{
	cout << "执行了man类的默认构造函数" << endl;
}

int main(void)
{
	Man m1;	//先调用父类的构造函数，然后调用子类的构造函数
	m1.age = 12;
	m1.str = "白乾龙";

	m1.myPubFunction();	//子类可以调用父类的public成员函数,

	//如果子类和父类有同名函数，那么子类对象只能调用子类的函数，不能调用父类的重载的函数
	m1.myFunction(123);
	/*如果确实想调用父类的成员函数，1.在子类的成员函数中，可以使用 父类名字：：同名函数名 强制调用父类函数
	 *2.using using namespace
	 *c++11中，让父类同名函数在子类中可见
	 *通过using这个关键字，让父类的同名函数在子类中可见，说白了就是让父类同名函数在子类中以重载的方式实现。
	 *
	 */
	m1.myFunction();	//会调用父类的myFunction函数

	return 0;
}

#include <iostream>
#include <cstdlib>
#include <string>
#include <vector>
#include "project3.hpp"
#include "project2.h"

using namespace std;

class  Human
{
public:
	int age;
	string name;
public:
	//构造函数
	Human();
	Human(int age, string name);
	//析构函数
	~Human()
	{
		cout << "Human析构函数" << endl;
	}
public:
	void myFunction();
	//virtual void eat() final;
	virtual void eat()//虚函数的实现	运行时动态识别
	{
		cout << "这是Human的eat函数" << endl;
	}
};

class Man:public Human
{
public:
	Man();
public:
	void myFunction();
	void eat() override;
};
void Man::eat()
{
	cout << "man中的eat（）函数执行" << endl;
}

class Woman:public Human
{
public:
	Woman();
public:
	void myFunction();
	void eat() override
	{
		cout << "woman中的eat()函数" << endl;
	}
};

void Human::myFunction()
{
	cout << "Human类中的函数执行" << endl;
}

void Man::myFunction()
{
	cout << "Man类中的myFunction函数执行" << endl;
}

Human::Human()
{
	cout << "Human默认构造函数" << endl;
}

Human::Human(int age, string name)
{
	this->age = age;
	this->name = name;
}

Woman::Woman()
{
	cout << "woman的构造函数" << endl;
}

void Woman::myFunction()
{
	cout << "Woman类中的myFunction函数" << endl;
}

Man::Man()
{
	cout << "Man类的默认构造函数" << endl;
}

int main(void)
{
	//一、基类指针，派生类指针
	Human*p_human = new Human;
	Man *p_man = new Man;   // 这里因为继承会先调用父类的构造函数，初始化父类的成员变量，然后调用子类的构造函数，初始化子类的成员变量。
	
	//先调用父类的构造函数，初始化父类的成员变量，然后调用子类的构造函数，初始化子类的成员变量。
	//子类是特殊的父类，父类指针可以new一个子类对象。
	Human*p_human2 = new Man;	//ok，使用子类对象初始化父类指针
	Human*p_human3 = new Woman;
	
	p_human2->myFunction();	//这里调用父类中的函数
	//但是父类指针实际上是指向子类的对象，如果想调用子类的函数？--->新需求
	//---父类指针指向父类对象还是子类对象就调用对应的函数--->多态
	p_human->eat();	//调用父类eat()
	p_human2->eat();//调用Man类eat()
	p_human3->eat();//调用Woman中的函数eat()
	p_human3->Human::eat();//显式调用父类的eat()函数

	delete p_human;
	delete p_human2;
	delete p_human3;
	/*
	 *都是调用Human的析构函数,若果想调用各个子类的析构函数应该怎么办？
	 *
	*/

	return 0;
}

#include<iostream>
#include<cstdlib>
#include<string>
#include<vector>
using namespace std;

class  Human
{
public:
	int age;
	string name;
public:
	//构造函数
	Human();
	Human(int age, string name);
	//析构函数
	~Human()
	{
		cout << "Human析构函数" << endl;
	}
public:
	virtual  void eat() = 0;
};

class Man :public Human
{
public:
	Man();
	virtual void eat() override;
public:

};

class Woman :public Human
{
public:
	Woman();
	virtual void eat() override;
public:

};

Woman::Woman()
{
	cout << "这是woman的构造函数" << endl;
}

Human::Human()
{
	cout << "Human默认构造函数" << endl;
}

Human::Human(int age, string name)
{
	this->age = age;
	this->name = name;

}

Man::Man()
{
	cout << "Man类的默认构造函数" << endl;
}

void Woman::eat()
{
	cout << "Woman类的eat()执行" << endl;
}
void Man::eat()
{
	cout << "Man类的eat()执行" << endl;
}

void playObject()
{
	Human *p_human01 = new Woman;
	p_human01->eat();//调用Woman的eat()函数

	Human*p_human02 = new Man;
	p_human02->eat();//调用Man的eat()函数
}

int main(void)
{
	playObject();
	return 0;

}

#include<iostream>
#include<cstdlib>
#include<string>
#include<vector>
using namespace std;

class  Human
{
public:
	int age;
	string name;
public:
	//构造函数
	Human();
	Human(int age, string name);
	//析构函数
	virtual ~Human()
	{
		cout << "Human析构函数" << endl;
	}
public:
	virtual  void eat() = 0;
};

class Man :public Human
{
public:
	Man();
	virtual void eat() override;
public:
	~Man()
	{
		cout << "执行了Man的析构函数" << endl;
	}

};

class Woman :public Human
{
public:
	Woman();
	virtual void eat() override;
public:
	~Woman()
	{
		cout << "执行了Woman的析构函数" << endl;
	}

};

Woman::Woman()
{
	cout << "这是woman的构造函数" << endl;
}

Human::Human()
{
	cout << "Human默认构造函数" << endl;
}

Human::Human(int age, string name)
{
	this->age = age;
	this->name = name;

}

Man::Man()
{
	cout << "Man类的默认构造函数" << endl;
}

void Woman::eat()
{
	cout << "Woman类的eat()执行" << endl;
}
void Man::eat()
{
	cout << "Man类的eat()执行" << endl;
}

void playObject()
{
	Human *p_human01 = new Woman;  // 这里因为继承会先调用父类的构造函数，初始化父类的成员变量，然后调用子类的构造函数，初始化子类的成员变量。
	p_human01->eat();//调用Woman的eat()函数

	Human*p_human02 = new Man;
	p_human02->eat();//调用Man的eat()函数

	//执行正确，会执行父类构造和子类构造，子类析构、父类析构。
	Woman *p_woman = new Woman;
	delete p_woman;    // 先调用子类析构函数，再调用父类析构函数。
	
	//都是只执行父类的析构函数，没有执行子类的析构函数
	cout << "-------------------------------------" << endl;
	delete p_human01;
	delete p_human02;
	/*
	执行了Woman的析构函数
	Human析构函数
	执行了Man的析构函数
	Human析构函数
	 */
}

int main(void)
{
	playObject();
	return 0;
}