【C/C++学院】0823-静态联合编译与动态联合编译/父类指针子类指针释放/虚函数/纯虚函数概念以及虚析构函数/抽象类与纯虚函数以及应用/虚函数原理/虚函数分层以及异质链表/类模板的概念以及应用

静态联合编译与动态联合编译

#include <iostream>
#include <stdlib.h>

//散列
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;

	go(NULL);
	go(nullptr);//编译器编译的时候决定就叫静态联编
}

void main1()
{
	int num;
	std::cin >> num;//执行的阶段
	if (num > 10)
	{
		system("calc");
	}
	else
	{
		system("notepad");
	}
	std::cin.get();
}

#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 main()
{

	B *p = new B;
	p->go();
	//p->go(1);

	const B *pb = new B;
	pb->go();
	
	std::cin.get();
}

void main1()
{
	B *pb = new B;
  //  pb->go(NULL);
	pb->goA("1");
	//pb->go("1");
	

	pb->A::go(NULL);
	pb->A::go("123");
	//pb->A::go(nullptr);//C++空指针不能打印

	std::cin.get();
}

父类指针子类指针释放

#pragma once
#include <iostream>

class fu
{
public:
	fu();
	~fu();
	char * strfu;
	void print();
	void fufu();
};
#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";
}
#pragma once
#include "fu.h"
class zi :
	public fu
{
public:
	zi();
	~zi();
	char *strzi;
	char ch[ 900000000];
	void print();
	void zizi();
};
#include "zi.h"

zi::zi()
{
	this->strzi = "儿子";
	std::cout << "zi create" << std::endl;
}

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

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

void zi::zizi()
{
//	std::cout << this->strzi << "\n";
	std::cout << "我是你儿子" << "\n";
}
#include <iostream>

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

//dynamic适用于虚函数

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


//父类指针引用父类对象，完全正常引用
//子类指针引用子类对象，覆盖父类的同名函数
//父类指针引用子类对象，只能引用父类中的函数
//子类指针，引用父类对象，子类不涉及内部数据的函数会调用成功
//涉及到内部数据的会调用成功，执行失败
//子类指针可以引用父类的不重名的函数
//子类指针（不是pzi->fu::print();方法）无法引用父类
//的同名方法

void main()
{
	{
		//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 main3()
{
	zi *pzi(nullptr);
	pzi->zizi();

	std::cin.get();
}

void main4()
{
	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();
}

void main2()
{
	fu *pfu = new zi;
	pfu->print();
	pfu->fufu();
	
	std::cin.get();
}

void main1()
{
	fu *pfu = new fu;
	pfu->print();
	pfu->fufu();

	zi *pzi = new zi;
	pzi->print();//子类覆盖父类
	pzi->zizi();
	pzi->fufu();

	/*
	fu fu1;
	fu1.print();
	fu1.fufu();
	*/

	std::cin.get();
}

虚函数

#include<iostream>

//没有virtual,会一直调用基类的方法
//virtual的

//虚函数现代编译器会直接分配一个指针存储虚函数表的位置，

class fu
{
public:
	virtual   void name() 
	{
		std::cout << "父类";
		std::cout << "x=" << x << "\n";
	}
	int x;
	fu(int a) :x(a)
	{

	}
protected:
private:
};

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)
	{

	}
protected:
private:
};

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)
	{

	}
protected:
private:
};


void main()
{

	std::cout << sizeof(fu) << std::endl;
	fu fu1(1);
	zi zi1(2,3);
	sun sun1(4,5,6);
	fu *pfu;
	pfu = &fu1;
	pfu->name();//1

	pfu = &zi1;
	pfu->name();//2

	pfu = &sun1;
	pfu->name();//4
	
	//((zi*)pfu)->name();
	//((sun*)pfu)->name();

	std::cin.get();
}

void main1()
{
	/*
	fu *pfu = new fu;
	pfu->name();
	zi *pzi = new zi;
	pzi->name();
	sun *psun = new sun;
	psun->name();

	zi *pzifu = static_cast<zi *>(pfu);
	pzifu->name();

	sun *psunfu = static_cast<sun *>(pfu);
	psunfu->name();


	std::cin.get();
	*/
}

#include "mainwindow.h"
#include <QApplication>
#include<QDebug>
#include<QPushButton>

class base
{
public:
    virtual  void show()//基类，接口
    {
        qDebug()<<"show";
    }
};

class mywindow: public base
{
 public:
    MainWindow *p;
    mywindow()
    {
        p=new MainWindow;
    }
   void  show()
    {
        this->p->show();
      // return 0;
    }
};

class mybutton:  public base
{
public:
    QPushButton *p;
    mybutton()
    {
        p= new QPushButton("1234");
    }
    void show(int num)
    {
        this->p->show();
    }
};


int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    base  base1;
    mywindow  mywindow1;
    mybutton mybutton1;

    base *p=&base1;//基类

    p->show();
    p= &mywindow1;
    p->show();
    p=&mybutton1;
    p->show();

    return a.exec();
}

纯虚函数概念以及虚析构函数

#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;

   // cout << "Hello World!" << endl;
    return 0;
}

抽象类与纯虚函数以及应用

#include<iostream>

class base
{
public:
	//纯虚函数，有无定义都可以
	//有一个纯虚函数，都是抽象类，无法实例化
	virtual void  run()=0 //限定一个类不能实例化，专门的接口
	{
		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();
}

纯虚函数：virtual void run()=0;等于0，限定一个类不能实例化，只是一个专门的接口

虚函数：virtual void run();

#include "dialog.h"
#include <QApplication>
#include<QPushButton>
#include<QLabel>

//抽象类也可以实现继承
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:
    Dialog 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);
   // Dialog w;
   // w.show();
    mydialog  dialog1;
    mybutton  button1;
    mylabel   label1;
    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();
}

虚函数原理

cl /d1 reportSingleClassLayoutxxx yyy.cpp 

进行编译，可以查看虚函数表

#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()
    {

    }
};

class china
{
    int  num;
};


int main()
{
    cout<<sizeof(basebase)<<endl;
    cout<<sizeof(base)<<endl;

    return 0;
}

虚函数分层以及异质链表

程序中，用基类类型指针，可以生成一个连接不同派生类对象的动态链表，即每个节点节点指针可以指向类层次中不同的派生类对象。这种节点类型不相同的链表称为异质链表。

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

class base
{
public:
    virtual  void  show()=0;
};

class node
{
 public:
      base *p;       //数据域
      node *pNext;//指针域
};

void showall(node *phead)
{
    while(phead!=NULL)
    {

       phead->p->show();
       phead= phead->pNext;
    }
}

node * add(node *phead, base *p)//改变一个指针需要二级指针，否则需要返回值并赋值
{
    if(phead==NULL)
    {
        //phead=p;
        node *px= new node;//开辟节点
        px->pNext=NULL;//最后一个节点为空
        px->p=p;//存储传过来的指针

        phead =px;//连接

        return phead;
    }
    else
    {
        node *pbak=phead;//保存头结点地址
        while(phead->pNext!=NULL)//遍历到最后一个节点
        {
           phead=phead->pNext;
        }
        node *px= new node;//开辟就诶点
        px->pNext=NULL;//最后一个节点为空
        px->p=p;//存储传过来的指针

        phead->pNext=px;//连接这个就诶点

        return pbak;
    }
}

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

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

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


int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    node *phead=NULL;//指针必须初四化
    button b1,b2,b3;
    window w1,w2,w3;
    label l1,l2,l3;

    phead=add(phead,&b1);
    phead=add(phead,&w1);
    phead=add(phead,&l1);

    showall(phead);

    return a.exec();
}

int main2(int argc, char *argv[])
{
    QApplication a(argc, argv);
    node *phead;
    button b1,b2,b3;
    window w1,w2,w3;
    label l1,l2,l3;

    node node1,node2,node3,node4;
    phead=&node1;
    node1.pNext=&node2;
    node2.pNext=&node3;
    node3.pNext=&node4;
    node4.pNext=NULL;//串联起来
    node1.p=&b1;
    node2.p=&w1;
    node3.p=&l1;
    node4.p=&b2;

    showall(phead);

    return a.exec();
}

类模板的概念以及应用

#include<iostream>

int add(int a, int b)
{
	std::cout << "add int\n";
	return a + b;
}

double  add(double a, double b)
{
	std::cout << "add double\n";
	return a + b;
}

template <class T>
T  add(T a, T b)
{
	std::cout << "add T\n";
	return a + b;
}

class  com1
{
public:
	int a;
	int b;
	int  add()
	{
		return a + b;
	}
};

class  com2
{
public:
	double a;
	double b;
	double  add()
	{
		return a + b;
	}
};

template  <class T>
class  com
{
public:
	T a;
	T b;
	T add()
	{
		std::cout << typeid(T).name() << std::endl;
		return a + b;
	}
};

void main()
{
	com<double> comx;
	comx.a = 19;
	comx.b = 29.8;
	std::cout << comx.add();

	std::cin.get();
}

void main2()
{
	com2 com21;
	com21.a = 10;
	com21.b = 20.9;
	std::cout<<com21.add()<<std::endl;

	std::cin.get();
}

void main1()
{
	//add<int>(1, 2);
	//std::cout<<add<int>(2.0, 3.4)<<std::endl;

	std::cin.get();
}

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

template<class T>
class run
{
   public:
    T w;
    void show()
    {
        w.show();
    }
    void settext()
    {
        w.setText("A");
    }
};


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

    run<QPushButton> run1;
    run1.show();
    run1.settext();

    return a.exec();
}

std::vetcor<int> myx;//STL, boost本质上都是类模板库。

类模块的作用：通用的类，不同的数据类型，相同的操作，使用的时候，只需要指明类型就可以了。通过不同的类型就给出该模板的实例化。

函数模板的作用：通用的函数，一个函数通吃所有参数不同的情况。