码迷,mamicode.com
首页 > 其他好文 > 详细

静态联编,动态联编,类指针之间的关系,虚函数与多态性,纯虚函数,虚析构函数

时间:2014-08-27 14:48:28      阅读:212      评论:0      收藏:0      [点我收藏+]

标签:style   blog   http   color   os   使用   io   ar   数据   

1.静态联编,是程序的匹配,连接在编译阶段实现,也称为早期匹配。重载函数使用静态联编。

2.动态联编是指程序联编推迟到运行时进行,所以又称为晚期联编。switch语句和if语句是动态联编的例子。

#include<iostream>

void go(int num)
{
}

void go(char *str)
{
}

//class
//::在一个类中
class A
{
public:
	void go(int num)
	{	
	}
	void go(char *str)
	{
	}
};

void main()
{
	//auto p = go;在编译的阶段就能判断好的,静态联编
	void(*p1)(char *str) = go;//指针函数
	void(*p2)(int num) = go;  //在编译的时候就确定了的叫静态联编

	std::cin.get();
}

//动态联编
void main1()
{
	int num;
	std::cin >> num;
	if (num > 10)
	{
		system("calc");
	}
	else 
	{
		system("notepad");
	}
}

3.静态联编

   普通成员函数重载可表达为两种形式

   在一个类说明中重载

   基类的成员函数在派生类重载。有3中编译区分方法:

   1):根据参数的特征加以区分

   2):使用”::”加以区分

          例如:A::Show();

          有别于B::show()

    (3):根据类对象加以区分

        例如:Aobj.show();  调用  A::Show();

                               Bobj.show();  调用  B::Show();

案例:


#include <iostream>
//父类与之类之间的重载,同名函数会覆盖
//即使参数类型不一样,不能直接调用,必须调用父类默认生成的对象来调用
class A
{
public:
	void go()
	{
		std::cout << "A---go";
	}

	void go(int num)
	{
		std::cout << "A---go" << num;
	}
	void go(char *str)
	{
		std::cout << "A---go" << str << "str";
	}
	void goA(char *str)
	{
		std::cout << "A---go" << str << "str";
	}
};

class B :public A
{
public:
	//const  函数重载一般适用于常量对象
	//非const一般适用于变量对象
	void go()
	{
		std::cout << "B---go";
	}
	void go() const
	{
		std::cout << "B---go const";
	}
};

void main2()
{
	B *pb = new B;
	//pb->go(NULL);

	pb->goA("1");

	//当父类和子类中出现了重名的函数的时候,即使参数类型不一样,
	//不能直接调用,必须调用父类默认生成的对象来调用。
	//pb->go("1");  

	//C语言中的NULL可以打印,但是C++中的空指针式不可以打印的
	pb->A::go(NULL);  //当调用
	pb->A::go("123");
	//pb->A::go(nullptr);//C++空指针不能打印

	std::cin.get();
	//运行结果是:A---go1strA---go0A---go123str
}

void main()
{
	B *p = new B;
	p->go();

	const B *pb = new B;
	pb->go();

	std::cin.get();
}

4.类指针的关系

   基类指针和派生类指针与基类对象和派生类对象4种可能匹配。

      A:直接用基类指针引用基类对象。

      B:直接用派生类指针引用派生类对象。

      C:用基类指针引用一个派生类对象。

      D:用派生类指针引用一个基类对象。


5.类与指针之间的关系

      Adynamic适用于虚函数

      B类而言,数据是私有,代码是公有的

      C指针为空,指向一个类,可以直接调用方法

      D涉及内部成员会崩溃,不涉及可以执行

      E父类指针引用父类对象,完全正常引用

      F子类指针引用子类对象,覆盖父类的同名函数

      G父类指针引用子类对象,只能引用父类中的函数

      H子类指针,引用父类对象,子类不涉及内部数据的函数会调用成功

      I涉及到内部数据的会调用成功,执行失败

     J子类指针可以引用父类的不重名的函数

     K子类指针(不是pzi->fu::print();方法)无法引用父类的同名方法

案例如下:

fu.h

#pragma once
#include <iostream>

class fu
{
public:
	fu();
	~fu();
	char * strfu;
	void print();
	void fufu();
};
zi.h
#pragma once
#include "fu.h"
class zi :
	public fu
{
public:
	zi();
	~zi();
	char *strzi;
	char ch[900000000];
	void print();
	void zizi();
};
fu.cpp
#include "fu.h"


fu::fu()
{
	this->strfu = "父亲";
	std::cout << "fu create" << std::endl;
}


fu::~fu()
{
	std::cout << "fu delete" << std::endl;
}

void fu::print()
{
	std::cout << this->strfu << "\n";
}

void fu::fufu()
{
	std::cout << "我是你爹" << "\n";
}
zi.cpp
#include "fu.h"


fu::fu()
{
	this->strfu = "父亲";
	std::cout << "fu create" << std::endl;
}


fu::~fu()
{
	std::cout << "fu delete" << std::endl;
}

void fu::print()
{
	std::cout << this->strfu << "\n";
}

void fu::fufu()
{
	std::cout << "我是你爹" << "\n";
}
main.cpp
#include <iostream>

#include"fu.h"
#include "zi.h"

//dynamic适用于虚函数

//类而言,数据是私有,代码是公有的
//指针为空,指向一个类,可以直接调用方法
//涉及内部成员会崩溃,不涉及可以执行

//父类指针引用父类对象,完全正常引用
//子类指针引用子类对象,覆盖父类的同名函数
//父类指针引用子类对象,只能引用父类中的函数
//子类指针,引用父类对象,子类不涉及内部数据的函数会调用成功
//涉及到内部数据的会调用成功,执行失败
//子类指针可以引用父类的不重名的函数
//子类指针(不是pzi->fu::print();方法)无法引用父类
//的同名方法
void main1()
{
	{
		//fu *pfu = new fu;
		//delete pfu;
	}
	{
		//前后一致的不会出现问题
	    zi *pzi = new zi;
	    delete pzi;
    }
	{
		//fu *pfu = new zi;
		//内存泄漏,理解:后面的空间大,前面的空间小,释放前面,出现内存泄露
		//delete pfu;
	}
	{
		//fu *pfu = new fu;
		zi *pzi = static_cast<zi *>(new fu);
		delete pzi;//内存越界,超过界限释放内存,有时出错,有时无错
	}

	std::cin.get();
}

void main2()
{
	zi *pzi(nullptr);
	//会调用自己的函数
	pzi->zizi();//结果是:我是你儿子

	std::cin.get();
}

void main()
{
	fu *pfu = new fu;
	zi *pzi = static_cast<zi *>(pfu);
	pzi->fufu();//我是你爹

	pzi->zizi();//我是你儿子
	pzi->fu::print();//父亲

	//pzi->print();

	//std::cout << pzi->strzi << std::endl;

	//pzi->print();
	std::cin.get();
}

6.冠以关键字virtual的成员函数称为虚函数。

实现运行时多态的关键首先是要说明虚函数,另外,必须用基类指针调用派生类的不同实现版本。

7.  对于虚函数的总结:

   A对于继承的情况,如果自来实现了父类的同名函数,

   B当指针调用的时候会一直调用父类的函数,当成员函数加了virtual

   C关键字修饰之后,子类才会调用自己的函数。

案例:

#include<iostream>

//总结:对于继承的情况,如果实现了父类的同名函数
//当指针调用的时候会一直调用父类的函数,当成员函数加了virtual关键字后,子类才会调用自己的函数。
class fu
{
public:
	virtual void name() //虚函数有4个字节,32位的,实际上是一个函数指针,自动调用子类的函数覆盖虚函数
	{
		std::cout << "父类";
		std::cout << "x=" << x << "\n";
	}
	int x;
	fu(int a) :x(a)
	{
	}
};

class zi :public fu
{
public:
	void name()
	{
		std::cout << "子类";
		std::cout << "x=" << x << ",y=" << y << "\n";
	}
	int y;
	zi(int a, int b) :fu(a), y(b)
	{
		
	}
};

class sun :public zi
{
public:
	void name()
	{
		std::cout << "孙类";
		std::cout << "x=" << x << ",y=" << y << ",z=" << z << "\n";
	}
	int z;
	sun(int a, int b, int c) :zi(a, b), z(c)
	{
	}
};

int main(int argc, char *argv[])
{
	//下面的结果为8,说明虚函数的大小为4字节
	std::cout << sizeof(fu) << std::endl;
	fu fu1(1);
	zi zi1(2, 3);
	sun sun1(4, 5, 6);
	fu *pfu;
	pfu = &fu1;
	pfu->name();//打印出:父类x=1

	pfu = &zi1;
	pfu->name();//父类加了virtual之后,此处打印出:子类x=2,y=3

	pfu = &sun1;
	pfu->name();//父类加了virtual之后,此处打印出:孙类x=4,y=5

	std::cin.get();
}

8:纯虚函数

bubuko.com,布布扣

#include <iostream>

using namespace std;

//因为base其中有纯虚函数,所以不能实例化了。
class base
{
public:

    int num;
    void goA()
    {
    }
    //下面是一个纯虚函数
    virtual void show()=0; //带了纯虚函数就是抽象类
     //可以有实现,也可以没有实现,可以放在内部外部
};

class run:public base
{
public:
    void show()
    {
        std::cout << "run show();" << std::endl;
    }
};

int main()
{
    cout << "Hello World!" << endl;
    //base base1;抽象类无法实例化
    run runInstance;
    runInstance.show();
    return 0;
}
运行结果:
bubuko.com,布布扣

案例2


#include<iostream>

class base
{
public:
	//纯虚函数,有无定义都可以
	//有一个纯虚函数,都是抽象类,无法实例化
	virtual void run() = 0 //限定一个类不能实例化,作为专门的接口,QT里面不可以在内部定义。
	{
		std::cout << "base run\n";
	}
	virtual ~base()
	{
	}
};

//抽象类不可以用于函数的参数以及返回值类型
//抽象类指针是可以
base * test(base *p)
{
	base *pbase(nullptr);
	return pbase;
}

class boy :public base
{
public:
	void run()
	{
		std::cout << "男孩奔跑\n";
	}
};

class girl :public base
{
public:
	void run()
	{
		std::cout << "女孩奔跑\n";
	}
};

void main()
{
	//抽象类无法实例化对象,可以实话指针
	//纯虚函数与抽象类与虚函数起到接口的作用
	//用同一个接口完成不同的功能
	//纯虚函数完全就是为了接口的存在,有了纯虚函数的类无法实例化
	//虚函数占4个字节,就是指针,函数指针
	boy boy1;
	girl girl1;
	base *p(nullptr);
	p = &boy1;
	p->run();
	p = &girl1;
	p->run();

	std::cin.get();
}

9.虚析构函数,在析构函数的前面加上virtual

案例代码如下:

#include <iostream>

using namespace std;

class A
{
public:
    //构造函数不可以是虚函数,如果是了就不可以再构造,
    //没有办法创建子类中的父类对象
    A()
    {
        std::cout << "a create" << std::endl;
    }
    //虚析构函数,让父类指针正确的释放子类对象的内存
    virtual ~A()
    {
        std::cout << "a delete" << std::endl;
    }
};

class B:public A
{
public:
    B()//B创建自动调用A的构造函数
    {
        std::cout << "b create" << std::endl;
    }
    ~B()//B析构的时候会自动调用A的析构函数
    {
        std::cout << "b delete" << std::endl;
    }
};

int main()
{
    A *p = new B;
    delete p;
    return 0;
}

如果析构函数前没有加virtual,运行结果如下:

bubuko.com,布布扣

如果析构函数前加了virtual,运行结果如下:

bubuko.com,布布扣

10. 者多个虚函数,或者多个纯虚函数都占四个字节

案例如下:


#include <iostream>

using namespace std;

//抽象类也可以实现继承
//仅有一个指针指向虚函数表

//1个或者多个虚函数,或者多个纯虚函数都占四个字节
//一个指针存储了虚函数标的地址

class basebase
{
public:
    virtual void show() = 0;
    virtual void hide() = 0;
    virtual void run() = 0;
};

class base
{
public:
    virtual void show(){}
    virtual void hide(){}
    virtual void run(){}
};

int main()
{
    cout << sizeof(basebase) << endl;//结果是4
    cout << sizeof(base) << endl;//结果为4
    return 0;
}

11.子类只有都实现了基类中的纯虚函数之后才可以实例化

案例说明如下:

#include "mainwindow.h"
#include <QApplication>
#include<QPushButton>
#include<QLabel>
#include<iostream>

//抽象类也可以实现继承
class basebase
{
public:
    virtual void show()=0;
    virtual void hide()=0;
};

//接口,操作不同的类对象的方法
class base :public basebase
{
public:
    virtual void resize(int x,int y)=0;
    virtual void move (int cx,int cy)=0;
};

class myself: public base
{
public:
    //只要有一个接口的没有实现,抽象类
    //把所有就接口都实现了的类才可以实例化
    void show(){}
    void hide(){}
};

class mydialog: public base
{
public:
    MainWindow w;
    void show()
    {
        w.show();
    }

    void hide()
    {
        w.hide();
    }

    void resize(int x,int y)
    {
        w.resize(x,y);
    }

    void move (int cx,int cy)
    {
        w.move(cx,cy);
    }
};

class mybutton: public base
{
public:
    QPushButton w;
    void show()
    {
        w.show();
    }

    void hide()
    {
        w.hide();
    }

    void resize(int x,int y)
    {
        w.resize(x,y);
    }

    void move (int cx,int cy)
    {
        w.move(cx,cy);
    }
};

class mylabel: public base
{
public:
    QLabel w;
    void show()
    {
        w.show();
    }

    void hide()
    {
        w.hide();
    }

    void resize(int x,int y)
    {
        w.resize(x,y);
    }

    void move (int cx,int cy)
    {
        w.move(cx,cy);
    }
};


int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

    //myself  my1;
    return a.exec();
}

int main1(int argc, char *argv[])
{
    QApplication a(argc, argv);
    mydialog  dialog1;
    mybutton  button1;
    mylabel   label1;
    //只有在.pro中加上CONFIG += c++11后nullptr才可以使用,因为其是C++11特性
    base *pbase(nullptr);
    pbase =&dialog1;
    pbase->show();
    pbase->resize(100,200);
    pbase =&button1;
    pbase->show();
    pbase->resize(200,200);
    pbase=&label1;
    pbase->show();
    pbase->resize(300,200);

    return a.exec();
}






































静态联编,动态联编,类指针之间的关系,虚函数与多态性,纯虚函数,虚析构函数

标签:style   blog   http   color   os   使用   io   ar   数据   

原文地址:http://blog.csdn.net/tototuzuoquan/article/details/38868731

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!