大一·cpp期中复习

第五章 模板

• 数组的函数调用

  template <typename T>
  void Input(T a[]){
  }

 模板好难写啊 aaaa 特别是有重构还要我写模板。。。。服了

• 模板中退出

用  exit（1） //不用return

第一章  对象和类

• 构造函数（这样简便一点）

 不能被显式调用

class lin{
	private:
		int a;
		int b;
	public:
		lin():a(0),b(0){
		}
		lin(int x,int y) : a(x),b(y){
		}
		lin(const lin & x) : a(x.a),b(x.b){
		}//拷贝构造函数
};

• 成员函数的实现

用 #include "point.h"(保存的文件名是point.h)

• 指针状态下

    lin temp(1,2);
	lin *a;
	a = &temp;
	a->input();
	(*a).input();//显式调用

• 析构函数

据我所看 是析构指针的 

class lin{
	private:
		int a;
		int b;
		int *c;
	public:
		lin():a(0),b(0){
		}
		lin(int x,int y) : a(x),b(y){
		}
		lin(const lin & x) : a(x.a),b(x.b){
		}
		void input(); 
		~lin(){
			delete[] c;
		};
};

• 是char数组和string类时

  class ccchhh{
  	private:
  		char *name;
  	public:
  		ccchhh(const char *n){
  			name = new char[101];
  			strcpy(name,n);
  		}
  };

  要新建空间并且用strcpy拷贝

• 常成员函数

 是只读函数，不能修改数据成员的值，也不能调用该类中非常成员函数。

•  浅拷贝和深拷贝

就是要先开一个new空间来存储后再拷贝 指针类型的一定要用深拷贝 

第二章 继承与派生

派生类继承和吸收了基类的全部数据成员和 除了构造函数、析构函数之外 的全

部成员函数。（ 私有继承相当于中止了基类功能的继续派生！ ）

多重继承就

class up : public B1,public B2{
}

• 派生类构造函数

Circle(inta, intb, intc):Point(a,b) （需要负责调用基类的构造函数对基类成员进行初始化；派生类新增成员在自身的构造函数中进行初始化）

int main()
{
Circle c(10);//基类 
Cylinder cy(5,10);//继承类 
cout<<"圆的面积为："<<c.area()<<"\n";
cout<<"圆柱体的底面积为："<<cy.Circle::area()<<"\n";//调用同名覆盖前的 
cout<<"圆柱体的表面积为："<<cy.area()<<endl;
return 0;
}

• 虚基类（virtual）

虚基类 ：以此类的多个派生类为直接基类，通过多重继承产生的派生类只

继承一份该基类的成员，这样就避免了在派生类中访问这些成员时产生二

义性

#include <iostream>
using namespace std;
class B
{
protected:
int b;
public:
B(int bval)
{
cout<<"执行类B的构造函数\n";
b = bval;
}
};

class D1 : virtual public B
 {
 protected: 
 int d1;
 public:
 D1(int bval, int dval) : B(bval)
 { d1 = dval;
 cout<<"执行类D1的构造函数\n";
 }
 };
 class D2 : virtual public B
 {
 protected:
 int d2;
 public:
 D2(int bval, int dval) : B(bval)
 { d2 = dval;
 cout<<"执行类D2的构造函数\n";
 }
 };
class D3 : public D2, public D1
 {
 protected:
 int d3;
 public:
 D3(int bval, int dval1, int dval2, int dval3): D1(bval, dval1), D2(bval, dval2), B(bval)
 {
 d3 = dval3;
 cout<<"执行类Derive的构造函数\n";
 }
}

虚基类的构造函数只被调用 1 次

  把建立对象时所用的类称为 最终派生类 ， 虚基类的构造函数是由 最终派生类的

构造函数 调用的 。

构造函数的调用顺序：

• 所有虚基类的构造函数（按定义顺序）

• 所有直接基类的构造函数（按定义时的顺序执行）

• 所有对象成员的构造函数（按定义时的顺序执行）

• 派生类自己的构造函数

析构函数的调用执行顺序与构造函数相反

第三章 虚函数与多态性

• 抽象类和纯虚函数

好像就是可以分别调用覆盖的纯虚函数，可以直接调用不同层的（构建了一个抽象类的函数）

amazing。。。。。。。。。。。。

类体内声明了纯虚函数的类，称为 抽象类

抽象类的主要作用 ：以此类为基类建立的一个类族具有一组公共的接口（即公

有成员函数），将它们定义为纯虚函数，使它们能够更有效地发挥多态特性。

抽象类声明了一族派生类的共同接口，而接口的完整实现，即纯虚函数的函数

体，要由派生类自己定义。

抽象类只能用作基类来派生出新类 ， 不能声明抽象类的对象 ，但可以声明指向抽象类的指针

变量或引用变量。

/*纯虚函数和抽象类*/
class N{	//抽象类 
	public:
		virtual double area() = 0;//纯虚函数 
		virtual void tell() = 0;
		
};

class Point : public N{
	private:
		double x;
		double y;
	public:
		Point (double a,double b);
		double area();
		void tall();
		double getx(){
			return x;
		}
		double gety(){
			return y;
		}
};
Point::Point (double x,double y){
	this->x=x;
	this->y=y;
}
double Point::area()
{
	return 0;
}

void Point::tell(){
	cout << x << " " << y;
}

 
class cir : public Point{
	private:
		double r;
	public:
		cir(double x,double y,double r);
		double area();
		void tall();
};

cir::cir(double x,double y,double r):Point(x,y){
	this->r=r;
}

double cir::area(){
	return 3.14*r*r;
}

void cir::tall(){
	cout << getx() << " " << gety() << r;
}
void fun (N &rs){
	cout << rs.area();
	rs.tell();
}
int main(){
	N *s;
	Point p(10,20);
	cir c(5,6,10);
	
	fun(p);//用的是派生类 Point的 
	fun(c);//用的是派生类 cir的 
	s = &p;
	cout << s->area() << endl;//用的是Point的 
	s->tell();//用的是Point的
	
	
	s = &c;
	cout << s->area() << endl;//用的是cir的 
	s->tell();//用的是cir的
	
	
	
	return 0;
}

• 虚成员函数

基类指针（或引用）仅能访问派生类中的基类部分，因此不能实现真正的

多态，需要引入 虚函数 的概念。

只有类的 普通成员函数或析构函数才能声明为虚函数 。

基类中的虚函数可以在派生类中被重新定义，但重新定义时必须与基类中的函

数原型 完全相同（同名覆盖） ，且无论是否用 virtual 修饰，系统都将其视为虚函数

（建议加上 virtual ）

当一个类的公有成员函数声明为虚函数，且在其公有派生类中被同名覆盖时：

  当用基类指针（或引用）指向这个派生类对象，并用该指针调用该函数时，系统自动用派生类中

的同名函数。

  即：当用基类指针（或引用）指向派生类对象，并用该指针调用该函数时，系统会在程序运行中

根据所指向对象的不同，自动选择执行当前指向对象所属类的成员函数，从而实现了运行时的多

态性

构造函数不能是虚函数。

析构函数可以是虚函数，且 往往被声明为虚函数 。

--以上引用来来至课件，非原创，禁止转载--

#include <bits/stdc++.h>
using namespace std;
class Person{
	protected:
		string name;
	public:
		virtual void input();
		virtual void display();
		virtual ~Person();
};
class Student : public Person{
	private:
		string number;
	public:
		void input();
		void display();
		~Student();
};
void Person::input(){
	string a;
	cin >> a;
	name = a;
}
void Person::display(){
	cout << name << "yes"<< endl;
}
Person::~Person(){
	
}
void Student::input(){
	string a1,a2;
	cin >> a1 >> a2;
	name = a1;
	number = a2;
}
void Student::display(){
	cout << name << " " << number << endl;
}
Student::~Student(){
	
}
int main()
{
	Person *p;
	p = new Person;
	p->input();//调用的是基类的 
	p->display();
	delete p;
	p = new Student;
	p->input();//调用的是派生类的 
	p->display();
	delete p;
	return 0;
}