class person {public:
		int *p;
	public:
		person(int t) {	p = new int(t);
		}
		person(const person &o) {//重写拷贝函数
			p = new int(*o.p);
		}
		~person() {//析构函数释放申请空间
			if(p) {		delete p;
				p = NULL;
			}
			cout<< "success"<< endl;
		}
		person& operator=(person &o) {//重载=，注意返回当前对象，链式法则
			if(p) {		delete p;
				p = NULL;
			}
			p = new int(*o.p);
			return *this;
		}
};

void test() {person p1(10);
	person p2(0);
	person p3(0);
	person p4 = p3;	//这里不是=运算符重载，而是调用拷贝函数，因此依旧是浅拷贝，需要自定义拷贝函数，改成深拷贝 
	p3 = p2 = p1;
	cout<< p1.p<< " "<< p2.p<< " "<< p3.p<< " "<< p4.p<< endl;	//查看申请的内存地址
}

class person {public:
		string name;
		int age;
	public:
		person(string name, int age) {	this->name = name;
			this->age = age;
		}
//		bool operator==(person o) {//			if(name == o.name && age == o.age) return true;
//			return false;
//		}
		bool operator<(person o) {	if(age< o.age) return true;
			return false;
		}
		bool operator>(person o) {	if(age >o.age) return true;
			return false;
		}
};
bool operator==(person a, person b) {if(a.name == b.name && a.age == b.age) return true;
	return false;
}
void test() {person p1("tom", 16);
	person p2("tom", 15);
	if(p1 == p2) cout<< "same"<< endl;
	else if(p1 >p2) cout<< "bigger"<< endl;
	else cout<< "smaller"<< endl;
	
}

class person {public:
		string name;
		int age;
	public:
		person(string name, int age) {	this->name = name;
			this->age = age;
		}
		void operator()() {//重载（）运算符
			cout<< name<< endl;
		}
};

void test() {person p1("tom", 16);	
	p1();	//由于写法类似函数，又名仿函数
}

考虑以下情况：
狗是一个类，但狗又可以细分为很多品种，例如边牧、二哈、柯基等，这些细分的品种有狗的共性，但也有自己的特性，这时就体现出继承。
继承方式有三种：(子类会继承所有父类属性，但父类private的属性子类无法访问)
public：
不改变从父类继承过来的属性访问权限
protected：
把所有父类非private的属性访问权限设为protected
private：
把所有父类非private的属性访问权限设为private

class basicClass {//父类，公共内容
	public:
		void header() {	cout<< "公共头部"<< endl;
		}
		void footer() {	cout<< "公共底部"<< endl;
		}
		void left() {	cout<< "公共左部"<< endl;
		}
};
class JAVA : public basicClass {//继承父类的子类
	public:
		void content() {	cout<< "JAVA课程"<< endl; 
		}
};
class CPP : public basicClass {public:
		void content() {	cout<< "CPP课程"<< endl; 
		}
};
class Python : public basicClass {public:
		void content() {	cout<< "Python课程"<< endl; 
		}
};
void test() {JAVA a;
	Python b;
	CPP c;
	a.header(); a.content(); a.footer(); a.left(); 
	cout<< "----------------------------------------"<< endl;
	b.header(); b.content(); b.footer(); b.left();
	cout<< "----------------------------------------"<< endl;
	c.header(); c.content(); c.footer(); c.left();
}

如果子类和父类有同名变量或者同名函数，则子类会隐藏父类的同名变量和同名函数，想要访问到父类的同名变量或者函数，则必须加上父类的作用域，另外，即使子类和父类的同名函数参数不同，但是子类仍然会隐藏父类的函数

class basicClass {public:
		int a;
		void out() {	cout<< "basicClass"<< endl;
		}
		void out(int k) {	cout<< "basicClass "<< k<< endl;
		}
};
class JAVA : public basicClass {public:
		JAVA() {	a = 100;
		}
		int a;
		void out() {	cout<< "JAVA"<< endl; 
		}
};
void test() {JAVA a;
	cout<< a.a<< endl;
	a.out();
	cout<< a.basicClass::a<< endl;
	a.basicClass::out();
	a.basicClass::out(2);	//即使子类同名函数和父类同名函数参数不同，仍然会隐藏父类同名函数 
}

子类可以继承多个父类，如果多个父类拥有同名变量或者函数，也需要通过作用域来区分

class basicClass {public:
		int a;
		basicClass() {	a = 100;
		}
};
class basicClass2 {public:
		int a;
		basicClass2() {	a = 200;
		}
};
class JAVA : public basicClass, public basicClass2 {};
void test() {JAVA a;
	cout<< a.basicClass::a<< " "<< a.basicClass2::a<< endl;
}

考虑下面情况：
有基类A，B继承于A，C继承于A，D继承于B和C，A中有一份数据，此时D就会同时继承两份一样的数据，要访问这份数据，还要加上作用域。如何解决呢？
虚继承可以解决此问题

class annimal {public:
		int age;
		annimal() {	age = 18;
		}
};
class sleep : virtual public annimal {};
class tuo : virtual public annimal {};
class sleepTuo : public sleep, public tuo {};
void test() {sleepTuo a;
	cout<< sizeof a<< endl;	//8->24消耗了内存
	cout<< a.age<< endl;
}

虚继承本质是存储一个指向虚基类的指针，指针指向虚基类表，表中存储一个偏移量，指针地址加上偏移量就是数据存放地址，因此此操作实质上增加了内存消耗，换来的是不用区分作用域。

详解

class annimal {public:
		virtual void speak() {//定义为虚函数
			cout<< "动物在说话"<< endl;
		}
};
class cat : public annimal {public:
		void speak() {//重写虚函数
			cout<< "猫在说话"<< endl;
		}
};
void test() {cat c;
	annimal &a = c;	//多态
	a.speak();
}

开发项目时最忌讳代码一整个一口气写完，一是可读性差，二是扩展性差
开闭原则即为扩展开放，修改封闭
多态即可实现这样的目标，下面计算器是一个实例，如果把计算器实现的所有操作都封装在一个类里面，会显得代码都集中在一块，没有体现模块化编程思想，以后想添加新的操作，就要修改计算器类的代码。
如果使用多态，就可以创造一个空实现的基类，要添加操作时，就可以创造一个新类继承此基类，重写虚函数，实现新功能，不需要更改旧代码，只需要添加新代码即可。

class calculator {public:
		int num1, num2;
		virtual int calc() {	return 0;
		}
};

class subCalculator : public calculator {public:
		int calc() {	return num1 + num2;
		}
};

void test() {calculator *c = new subCalculator;	//加法器 
	c->num1 = 1;
	c->num2 = 2;
	cout<< c->calc()<< endl;
}

以上案例中基类的虚函数函数体其实根本不会用到，写它只是为了过编译，这种情况就可以使用纯虚函数，纯虚函数可以不写函数体，拥有纯虚函数的类称为虚类，而让子类重写此函数，且子类必须重写纯虚函数，否则子类就也为虚类。

虚类无法实例化，即无法创建对象。

只能创建指针或者引用来实现多态。

class calculator {public:
		int num1, num2;
		virtual int calc() = 0;	//纯虚函数
};

template//将T作为一种数据类型
//template效果等价于上一句
void out(T &a) {cout<< a;
}

以上代码调用out函数时会根据传入的参数判断出T的类型，我们也可以在调用时直接指定出类型

out(s);	//直接指定T为string类型

以下是快速排序自写的一个模板

templatevoid sort(T a[], int l, int r) {if(l >= r) return ;
	T bas = a[l];
	int i = l, j = r;
	while(i< j) {while(i< j && a[j] >= bas) j --;
		while(i< j && a[i]<= bas) i ++;
		swap(a[i], a[j]);
	}
	swap(a[l], a[i]);
	sort(a, l, i-1);
	sort(a, i+1, r);
}

调用规则如下:

1. 如果函数模板和普通函数都可以实现，优先调用普通函数
2. 可以通过空模板参数列表来强制调用函数模板
3. 函数模板也可以发生重载
4. 如果函数模板可以产性更好的匹配,优先调用函数模板

template<>打头，且参数类型具体指名即为具体化模板

class person {public:
		int age;
		string name;
		person(int age, string name) {	this->age = age;
			this->name = name;
		}
};

templatebool compare(T &a, T &b) {if(a == b) return true;
	return false;
}
template<>bool compare(person &a, person &b) {//具体化模板
	if(a.age == b.age && a.name == b.name) return true;	//如果函数参数和具体化模板参数相同，则会优先调用具体化模板
	return false;
}
void test() {person p1(16, "tom");
	person p2(16, "tom");
	cout<< compare(p1, p2)<< endl;	//person类型编译器无法比较
}

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧