- 博客(55)
- 收藏
- 关注
RSS订阅原创 嵌套类
#include using namespace std;class rectangle{ public:class point{public:void setx(int X){x=X;}void sety(int Y){y=Y;}int getx()const{return x;}int gety()const{return y;}private
2013-12-04 09:55:59
625
转载 友元类
=======================什么是友元类======================= 当一个类B成为了另外一个类A的“朋友”时，那么类A的私有和保护的数据成员就可以被类B访问。我们就把类B叫做类A的友元。=======================友元类能做什么======================= 友元类可以通过自
2013-12-04 09:55:13
541
原创 类成员函数指针
#include using namespace std;class human //抽象类human{ public: virtual void run()=0; //纯虚函数run virtual void eat()=0; //纯虚函数eat};class mother:public human //派生类mother从抽象类human继承{
2013-12-02 19:46:03
576
原创 函数指针作为函数参数
#include using namespace std;void square(int &x,int &y){ x=x*x; y=y*y;}void cube(int &x,int &y){ x=x*x*x; y=y*y*y;}void Swap(int &x,int &y){ int z; z=x; x
2013-12-02 19:14:12
622
原创 函数指针
数组名就是指向数组第一个元素的常量指针函数名也是指向函数第一条指令的常量指针正常情况下，程序在编译后，每个函数都有一个首地址，也就是函数第一条指令的地址我们用一个指针来保存这个地址，这个指针就是函数指针，该指针可看做是函数名，因此我们可以通过该指针调用函数
2013-11-29 16:27:27
646
原创 静态成员的使用
#include using namespace std;class aspl //将阿司匹林声明为一个aspl类，那么每箱阿司匹林就是该类的一个对象 { public: aspl(float p){price=p;TotalPrice=p+TotalPrice;} //在构造函数中实例化该对象的私有成员变量price，这样就得到了一箱阿
2013-11-29 14:18:25
825
原创 静态成员函数
/*#include using namespace std;class A{ public: void static show(){cout//定义静态成员函数show，输出私有静态成员变量n并将n自加 private: static int n; //声明私有静态成员变量n};int A::n=0; //定义私有静态成员变量nin
2013-11-29 10:53:48
907
原创 私有静态成员变量
#include using namespace std;class A {public:void func(){cout//定义公有成员函数func()，用该函数访问私有静态成员变量xprivate:static int x; //将静态成员变量x声明为私有};int A::x=1000; //定义并初始化静态成员变量int
2013-11-29 10:44:53
1162
原创 静态成员变量
1.静态成员变量是属于整个类的全局变量，它不单属于某个对象，普通成员变量是属于类中对象的变量。它不能被所有对象共享2.静态成员变量必须在全局进行定义，而成员变量由于是属于该类某个对象的，而不是属于整个类的，因此不用在全局进行定义。3.在使用静态成员变量时，可以不限定为某个具体的对象，只与类名连用即可如 A：：total 而不用 A a; a.total;4.静态成员在没有对
2013-11-29 10:36:42
999
原创 复杂的抽象类
#include using namespace std;class animal{ public: animal(int); virtual ~animal(){cout virtual int getage() {return itsage;} virtual void sleep()=0; //声明6个纯虚函数 virtual void eat
2013-11-28 20:17:01
528
原创 纯虚函数与抽象类
由于任何一个从抽象类派生的新类都会继承纯虚函数的特征--无任何功能因此要创建这个新类的对象必须为每一个纯虚函数赋予功能#include using namespace std;class shape{ public: virtual double area()=0;};class A:public shape{ protected: doub
2013-11-27 16:22:51
457
原创 模拟抽象类
抽象类为最高基类#include using namespace std;class shape{ public: shape(){} virtual ~shape(){} virtual float length(){return 0;} virtual float area(){return 0;} virtual void show(){}
2013-11-27 14:41:37
586
原创 多继承
#include using std::cout;using std::cin;using std::endl;class father{ public: father(){cout virtual ~father(){cout virtual void smart()const{cout};class mother{ public:
2013-11-27 14:27:21
475
原创 在派生类中增加函数
#includeusing namespace std;class father{ public: virtual void smart(){cout //父类的smart()函数};class son:public father{ public: virtual void beautiful(){cout //子类的beautiful函数
2013-11-27 14:25:09
693
原创 多继承
#include "iostream"using namespace std;class father{public: void smart(){cout //父类的smart()函数 virtual void beautiful(){} //该虚函数只是给son类做个接口，没有什么实际功能 virtual ~father(){cout
2013-11-27 14:06:53
569
原创 虚构造函数和析构函数
#include "iostream"using namespace std;class A{ public: A(){cout virtual void func(){cout virtual ~A(){cout};class B:public A{ public: B(){cout void func(){cout ~B(
2013-11-27 11:00:43
605
原创 在虚函数中使用成员名限定可以强行解除动态联编
#include "iostream"using namespace std;class A{ public: virtual int get(){return 0;}};class B:public A{ public: int get(){return 1;}};void main(){ B b; A*p=&b;
2013-11-27 10:37:18
603
原创 虚函数的系统调用
每个对象创建虚函数时，对象都得记录这个虚函数 ，因此编译器简历 了一个叫做T表的虚函数表，每个对象都有一个指向该表的指针，叫做虚表指针，该指针用来指向虚函数表。相反虚函数表也有一个指针指向该对象，当创建派生类对象的基类部分时，该对象的指针就自动初始化为指向虚函数表的正确部分。当调用派生类对象的构造函数时，这个对象就会添加到虚函数表中去，并且将指针指向该对象的重载函数。当使用指向基类的指
2013-11-27 10:35:54
383
原创 三种调用虚函数的方式比较
#include using namespace std;class father{ public: virtual void run()const{cout};class son:public father{ public: void run()const{cout};class daughter:public father{
2013-11-27 09:45:40
563
原创 动态联编的应用
#includeusing namespace std;class A{ public: virtual int get(){return 1;}};class B:public A{ public: int get(){return 2;}};void main(){ while (1) { cou
2013-11-27 09:28:20
590
原创 运行时静态联编
//在运行时的静态联编的例程如下：#includeusing namespace std;class A{ public: int get(){return 1;}};class B:public A{ public: int get(){return 2;}};void main(){ while (1) {
2013-11-27 09:15:13
441
原创 编译时的静态联编
#includeusing namespace std;class A{ public: int get(){return 1;}};class B:public A{ public: int get(){return 2;}};void main(){ A a; int one=a.get(); cout
2013-11-26 16:15:29
471
原创 静态联编和动态联编
联编是指一个计算机程序自身彼此关联（使一个源程序经过编译、连接，成为一个可执行程序）的过程，在这个联编过程中，需要确定程序中的操作调用(函数调用)与执行该操作(函数)的代码段之间的映射关系，按照联编所进行的阶段不同，可分为静态联编和动态联编。静态联编：调用函数和被调函数在程序编译时，他们在内存中的地址和映射关系已经确定好，动态联编：内存和地址映射关系不确定，加virtual 为动态联编，自
2013-11-26 16:07:54
432
原创 虚函数在动态联编中的应用
#include using namespace std; class poser{ public: virtual void beat()const{cout protected: int age;};class Ali:public poser{ public: void beat()const{cout};class Le
2013-11-26 15:55:11
461
原创 虚函数
#include using namespace std; class father{ public: father():age(54){cout ~father(){cout void jump()const {cout virtual void run()const{cout protected: int age;};class
2013-11-22 18:02:19
554
原创 指向对象的指针
在堆中创建的对象都是匿名的，因此创建的时候必须用类名来创建，而且要访问它们必须用指针，对的概念在数组里还有详细的讲解father*pfather = new son;解释：该段语句是在堆上创建一个新的son对象，并且返回指向该对象的指针，而赋值操作符=又将该指针赋值给指向father的指针。这样的好处是son对象可以直接访问father的数据和函数
2013-11-21 16:27:06
655
原创 虚基类不会产生两义性
#includeusing namespace std;class human{ public: void stand(){cout};class father: virtual public human{ public:};class mother: virtual public human{ public:};
2013-11-21 16:18:16
559
原创 两义性的归属
#includeusing namespace std;class human{ public: void stand(){cout};class father:public human{};class mother:public human{};class son:public mother,public father{};
2013-11-21 16:15:15
716
原创 继承中的重载
#includeusing namespace std;class A{ public: void hello(){cout void hello(int i) { cout cout }};class B:public A{ public: void hello(){
2013-11-21 15:46:18
650
原创 多重继承容易产生两义性
//产生两义性问题的例程如下：/*#includeusing namespace std;class A{ public: void hello(){cout};class B{ public: void hello(){cout };class C:public A,public B{ public: vo
2013-11-21 15:34:19
585
原创 向基类构造函数传递参数
在创建派生类的构造函数时，有两种方法对数据进行初始化第一种：在派生类中创建一个构造函数，然后初始化所有数据（从基类哪里继承来的数据和子类的数据）这种方法显然是多余的，因为基类已经有了恰当的构造函数，为何还要重复构造呢，况且在派生类中对基类进行初始化这种做法也是不可取的第二种：在派生类中创建一个构造函数，用该构造函数调用基类的构造函数并且向构造函数传递初始值显然第二种做法效率要高
2013-11-21 14:44:09
1311
原创 多继承的构造与析构
//多重继承的构造与析构顺序#includeusing namespace std;class a{ public: a(){cout ~a(){cout};class b{ public: b(){cout ~b(){cout};class c{ public: c(){cou
2013-11-21 14:27:59
648
原创 派生中的构造与析构的执行顺序
/*#includeusing namespace std;class father{ private: int a; public: father(int i){a=i;cout ~father(){cout};class son:public father{ private: int b;
2013-11-21 12:14:34
642
原创 多继承
#includeusing namespace std;#includeclass Father{public :void setA(int a){tall=a;};void print1(){coutprivate:int tall;};class mother{public: //不写public 默认是privatevoid
2013-11-21 11:59:22
561
原创 私有派生
1.以私有方式派生出的子类，父类的公有和保护成员在子类中是私有的，而私有成员则是不可访问的。2.由于私有派生不利于继续派生，所以在实际中用的不多3.不管以公有还是私有的形式继承，基类的私有成员在派生类都是不可以访问的
2013-11-21 11:44:01
1071
原创 继承的赋值
不能讲父类的对象赋值给子类对象因为对象的赋值操作调用了一个函数 operator=()函数，该函数会将运算符右边的这个对象的成员赋给左边的对象 operator=()函数是左边对象调用的，所以赋值操作以左边对象为准
2013-11-20 18:21:32
998
原创 公有，保护，私有 派生的成员属性
1.公有派生的前提下，基类的公有成员在派生类中仍然是公有的2.公有派生的前提下，派生类将基类的保护成员也原封不动地继承过来了3.公有派生的前提下，基类的私有成员在派生类中不可访问，只能通过父类的public函数借口来访问私有成员
2013-11-20 18:18:15
1054
原创 保护成员
//保护成员#includeclass father{ protected: //保护成员只能在类内或者派生类访问，其他类不能访问 int Ft,Fh; public: void SFtall(int Ftall){Ft=Ftall;} void SFweight(int Fweight){Fh=Fweight;} void
2013-11-20 18:04:44
717
原创 继承与派生
派生是继承后，又修改某些属性或者增加某些功能#includeclass father{ private: int Ft,Fh; public: void SFtall(int Ftall){Ft=Ftall;} //设置父亲身高 void SFweight(int Fweight){ Fh=Fweight; } //设置体重 void coutF()
2013-11-20 17:46:23
667
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人