c++前半部分总结

构造函数：与类同名的特殊成员函数，主要用来初始化对象的数据成员。定义形式如下：

class X{

· · · · · ·

X(· · ·);

}

特点没有返回值，可以重载，由系统自动调用，不允许在程序中显示调用。

例：

#include 

using namespace std;

class X

{

public:

X()

{

cout << "That's the start!" << endl;

}

};

void main()

{

X a;

system("PAUSE");

}

 

析构函数：与类同名的另一类特殊成员函数，作用有构造函数相反，用于在对象生存期结束时，完成对象的清理工作。如用delete删除对象分配的自由空间。定义形式：

class X{

· · · · · · 

Public:

~X();

· · · · · ·

}

特点：加“~”，没有返回类型，没有参数表，不能重载，一个类只能有一个析构函数，由系统自动调用，不能在程序中显示调用析构函数。

例：

#include 

using namespace std;

class X

{

private:

int i;

public:

X(int t)

{

i = t;

cout << "That's the start!" << i << endl;

}

~X(){ cout << "destructor:" << i << endl; }

};

void main()

{

X a1(1);

X a2(2);

X a3(3);

system("PAUSE");

}

 

 

向函数传递对象，传值、传引用、传指针

#include 

using namespace std;

class X

{

private:

int m;

public:

X(int i){ m = i; }

int getm(){ return m; }

void setm(int i){ m = i; }

};

 

void display(X ob){ cout << ob.getm() << endl; }

void change1(X ob){ ob.setm(50); }//传值

void change2(X &ob){ ob.setm(50); }//传引用

void change3(X *ob){ ob->setm(100); }//传指针

 

void main()

{

X a(10);

display(a);

change1(a);

display(a);

change2(a);

display(a);

change3(&a);

display(a);

system("PAUSE");

}

 

protected和继承

Protected可以用来设置类成员的访问权限，成为保护成员。主要用于继承，对于一个不被任何派生类继承的类而言，protected访问属性与private完全相同。而在继承结构中，基类的protected成员虽然不能被派生类外部函数访问，却能被其派生类直接访问。

#include 

using namespace std;

class B{

private:

int i;

protected:

int j;

public:

int k;

};

class D :public B{//表示D从B派生

public:

void f(){

i = 1;//错误

j = 2;//正确

k = 3;//正确

}

};

void main()

{

B b;

b.i = 1;//错误

b.j = 2;//错误

b.k = 3;//

}

 

继承方式

C++继承的形式

class 派生类名：[继承方式] 基类名{

派生类成员声明与定义;

}

继承方式可以是public，protected，private，如果省略继承方式，c++默认是private。派生类成员的定义与普通类定义方式相同，但它们可以访问基类的public和protected成员。

公有继承：继承方式为public，基类成员的访问权限在派生类中保持不变。

私有继承：继承方式为private，基类private仍是private，但基类public和protected变为private。

保护继承：继承方式protected，基类public变为protected，基类protected仍是protected，基类private仍是private。

例：

#include 

using namespace std;

class Base

{

int x;

public:

void setx(int n){ x = n; }

int getx(){ return x; }

void showx(){ cout << x << endl; }

};

class Derived :public Base

{

int y;

public:

void sety(int n){ y = n; }

void sety(){ y = getx(); }

void showy(){ cout << y << endl; }

};

void main()

{

Derived obj;

obj.setx(10);

obj.showx();

obj.sety(20);

obj.showy();

obj.sety();

obj.showx();

obj.showy();

system("PAUSE");

}

 

成员函数的重定义和名字隐藏

派生类不仅可以添加基类没有的成员，也可以对基类的成员函数进行重定义和重载。

#include 

using namespace std;

class Base

{

int x;

public:

void setx(int i){ x = i; }

void set(int n){ x = n; }

void print(){ cout << "Base class:x=" << x << endl; }

};

class Derived :public Base

{

int m, n;

public:

void set(int p, int k){ m = p; n = k; }//重载基类的成员函数set()

void set(int i, int j, int k){//重载成员函数set()

Base::set(i);//调用基类成员函数set()

m = j;    n = k;

}

void print(){

Base::print();

cout << "Derived class:m=" << m << endl;

cout << "Derived class:n=" << n << endl;

}

};

void main()

{

Derived d;

d.set(1, 3);

d.print();

d.set(5, 6, 7);

d.print();

d.Base::print();

d.setx(8);

system("PAUSE");

}

 

派生类的构造函数除了要负责本类成员的额初始化外，还要调用基类和对象成员的构造函数，并向它们传递参数，以完成基类子对象和对象成员的建立和初始化。

例：

#include 

using namespace std;

class Base

{

int x;

public:

Base(int a)

{

x = a;

cout << "constructing Base:x=" << x << endl;

}

~Base(){ cout << "destructing Base:x=" << x << endl; }

};

class Derived :public Base

{

int z;

public:

 

Derived(int i, int j, int k) :Base(i), b(j)

{

z = k;

cout << "constructing Derived:z=" << z << endl;

}

~Derived(){ cout << "destructing Derived:z=" << z << endl; }

    Base b;

};

void main()

{

Derived d(1, 2, 3);

system("PAUSE");

}

 

关于虚函数virtual，基类A，由A派生出B，再由B派生出C。如果不用虚函数，类型为派生类的指针不能访问基类的内容，类型为基类的指针在指向派生类时，不会访问派生类，只会访问到基类的内容；当使用虚函数virtual后，类型为派生类的指针照样不能访问基类，而类型为基类的指针在指向派生类时，不会再去访问基类的内容，而是去访问该派生类的内容。

#include 

#include 

using namespace std;

class A{

public:

void f(int i){ cout << "...A" << endl; }

};

class B :public A

{

public:

virtual void f(int i){ cout << "...B" << endl; }

};

class C :public B

{

public:

void f(int i){ cout << "...C" << endl; }

};

void main()

{

A *pA, a;

B *pB, b;

C c;

pB = &b;

pB->f(1);

pB = &c;

pB->f(1);

system("PAUSE");

}

派生类中的虚函数要保持其虚特性，必须与基类虚函数的函数原型完全相同，所带的参数个数，参数类型都必须相同，否则就不是虚函数，而是函数重载。

 

 

虚析构函数，构造函数和析构函数与所在类的名字相同，按理不符合虚函数，但是存在虚析构函数（不存在虚构造函数）。可以通过基类类型的指针访问派生类的析构函数，使析构彻底。

#include 

using namespace std;

class A

{

public:

virtual ~A(){ cout << "call A::~A()" << endl; }

};

class B :public A

{

char *buf;

public:

B(int i){ buf = new char[i]; }

~B()

{

delete[] buf;

cout << "call B::~()" << endl;

}

};

void main()

{

A* a = new B(10);

delete a;

system("PAUSE");

}

 

纯虚函数和抽象类

有时候定义一个类不是为了建立对象，而是把它作为派生其他类的基类，通过此基类访问派生类对象。纯虚函数的形式：

class X{

......

Virtual return_type(返回类型) fun_name(函数名)(parameter(参数))=0;

}

纯虚函数在基类中声明，但它基类中没有具体的函数实现代码，要求继承它的派生类为纯虚函数提供实现代码，该基类不能建立对象，称为抽象类。C++对抽象类的限定:

1.抽象类中有虚函数，没有实现代码，不能建立对象。

2.抽象类只能作为其他类的基类，可以通过指针和引用访问它的派生类对象。

3.如果一个派生类只是继承了抽象类的纯虚函数，而没有重新定义基类的纯虚函数，则派生类也是一个抽象类。

#include 

using namespace std;

class Figure

{

protected:

double x, y;

public:

void set(double i, double j){ x = i; y = j; }

virtual void area() = 0;

};

class Triangle :public Figure

{

public:

void area(){ cout << "三角形面积:" << x*y*0.5 << endl; }

};

class Rectangle :public Figure

{

public:

void area(int i){ cout << "这是矩形，它的面积是:" << x*y << endl; }

};

void main()

{

Figure *pF;

Triangle t;

t.set(10, 20);

pF = &t;

pF->area();

Figure &rF = t;

rF.set(20, 20);

rF.area();

system("pause");

}