【C/C++学院】0822-类型转换函数与构造转换函数/类的继承/类的继承以及区别/继承静态成员与静态函数//继承实现代码重用/单继承QT案例/多继承简介以及实战/Gpu编程

最新推荐文章于 2020-07-29 18:29:39 发布

吴英强

最新推荐文章于 2020-07-29 18:29:39 发布

阅读量1.8k

点赞数 2

分类专栏： C/C++学院 C/C++学院

本文链接：https://blog.csdn.net/waldmer/article/details/49464329

版权

C/C++学院同时被 2 个专栏收录

61 篇文章 1 订阅

订阅专栏

C/C++学院

60 篇文章 19 订阅

订阅专栏

类型转换函数与构造转换函数

#include<iostream>

class  fushu
{
public:
	explicit  fushu(int num)//避免隐式转换，引发歧义
	{
		x = num;
		y = num;
	}
	void print()
	{
		std::cout << x << "+" << y << "i" << std::endl;
	}
	operator int();
	//不支持友元，仅仅支持成员函数
	 operator double()
	{
		 return (double)(x + y);
	}	
protected:
private:
	int x;
	int y;
};
fushu::operator int()//类类之间的转换函数
{
	return x *y;
}
//转换有赋值，（）构造

void main3()
{
	int num(100.9);
	fushu fushu1(num);//构造函数
	fushu1.print();
	int data = (int)fushu1 + 10;//类型转换可以把一个自定义类型当作基本数据类型来计算
	std::cout << data << std::endl;

	std::cin.get();
}

void main2()
{
	int num ( 100.9);
	fushu fushu1(num);//构造函数
	fushu1.print();

	//int data (fushu1);//转换
	//int data = fushu1;
	//int data = (int)fushu1;
	//int data = int (fushu1);
	//int data ( int(fushu1));
	//std::cout << data << std::endl;
	std::cin.get();
}

void main1()
{
	 int num (10.8);//基本数据类型 
	//隐式转换与显式转换，是否带有类型转换符

	//fushu fushu1 = (fushu)10.8;
	//fushu fushu1 = static_cast<fushu>(10.8);

	fushu fushu1 =(fushu)10;//构造函数
	//int  numA = fushu1;
	fushu1.print();
	std::cin.get();
}

类与类之间的转换

#include <iostream>

class mianji
{
public:
	friend class fushu;
	mianji()
	{
		this->cx = 0;
		this->cy = 0;
	}
	void setxy(int a,int b)
	{
		this->cx = a;
		this->cy = b;
	}
protected:
private:
	int cx;
	int cy;
};

class fushu
{
public:
	friend class mianji;//友元可以访问私有变量
	fushu(mianji mianji1)
	{
		this->x = mianji1.cx;
		this->y = mianji1.cy;
	}
	void print()
	{
		std::cout << x << "+" << y << "i" << std::endl;
	}
	operator mianji()
	{
		mianji temp;
		temp.cx = x;
		temp.cy = y;
		return  temp;
	}

protected:
private:
	int x;
	int y;
};

void main()
{
	mianji  mianji1;
	//fushu fushu1 =(fushu) mianji1;
	fushu fushu1(mianji1);//构造函数
	//= static_cast<fushu>(mianji1);//构造函数进行转换
	mianji  mianji2;
	mianji2.setxy(10, 20);

	fushu1 = mianji2;
	fushu1.print();

	std::cin.get();
}

类的继承

类与类之间三种关系：包含，调用，继承。

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

#include<stdlib.h>

//第一种关系，某一个类作为某一个类的部件
class mywindow
{
public:
     MainWindow w;
};

class show
{
public:
    void showwindow(MainWindow & w )//部分的使用一个类，调用一个类
    {
        w.show();
    }
};

class newwindow:public MainWindow
{
public:
    void run(char *str)
    {
        system(str);
    }
};


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

    newwindow  new1;
    new1.show();
    new1.run("calc");

    return a.exec();
}

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

	mywindow my1;
     // my1.w.show();
      show show1;
      show1.showwindow(my1.w);

    return a.exec();
}

#pragma once

#include<iostream>
class coder
{
private:
	char *str;
public:
	coder();
	~coder();
	void girlfriend();
	void coding();
protected://不允许外部访问，允许子类内部访问
	int num;
};
#include "coder.h"

coder::coder()
{
	std::cout << "coder create" << std::endl;
	str = "锄禾日当午";
	num = 100;
}


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

void  coder::girlfriend()
{
	std::cout << "一般都会写代码，可以创建一个对象，可是没有对象" << std::endl;
}

void  coder::coding()
{
	std::cout << "加班加点熬夜" << std::endl;
}
#pragma once
#include "coder.h"


//父类的私有成员，不行

//父类的保护成员，公有成员内部可以访问
//保护成员，公有成员都会变成保护成员

class ccoder:protected coder
{
public:
	ccoder();
	~ccoder();
};
#include "ccoder.h"

ccoder::ccoder()
{
}
ccoder::~ccoder()
{
}
#pragma once
#include "coder.h"

//父类的私有成员，不行
//父类的保护成员，公有成员都可以
//公有继承，不影响保护成员，公有成员属性变化

class cppcoder :
	public coder
{
public:
	cppcoder();
	~cppcoder();
	void coding();

	void ui();
};
#include "cppcoder.h"


cppcoder::cppcoder()
{
	std::cout << "cpp coder create" << std::endl;
}

cppcoder::~cppcoder()
{
	std::cout << "  cpp  coder delete" << std::endl;
}

void  cppcoder::ui()
{
	std::cout << "QT真蛋疼" << std::endl;
	//子类的内部可以访问
	std::cout << (this->coder::num) << std::endl;
}

void  cppcoder::coding()
{
	std::cout << "CPP真蛋疼" << std::endl;
}
#pragma once
#include "coder.h"

//父类的私有成员，不行

//父类的保护成员，公有成员内部可以访问
//私有继承，公有成员，保护成员都变成私有成员

class javacoder :
	private coder
{
public:
	javacoder();
	~javacoder();
};
#include "javacoder.h"


javacoder::javacoder()
{
	this->num = 100;
}
javacoder::~javacoder()
{
}
//main.cpp
#include<iostream>
#include "coder.h"
#include "cppcoder.h"
#include "javacoder.h"

void main()
{
	javacoder *pjava = new javacoder;
	//pjava->num = 100;
}

void  main3()
{
	cppcoder *ptansheng = new cppcoder;
	coder *pcode = new coder;
	//protected不允许外部访问，允许子类内部访问
	ptansheng->ui();	

	std::cin.get();
}

void  main2()
{
	coder *pcode = new cppcoder;//父类的指针，接受子类指针的地址
	pcode->coding();

	cppcoder *pcppcoder = reinterpret_cast<cppcoder *>(pcode);
	pcppcoder->coding();
	std::cout << typeid(pcode).name() << std::endl;
	std::cout << typeid(pcppcoder).name() << std::endl;
	std::cin.get();
}


void main1()
{
	cppcoder *ptansheng = new cppcoder;
	ptansheng->girlfriend();
	ptansheng->ui();
	//子类与父类重名，覆盖父类
	ptansheng->coding();
	//每一个子类都会生成一个默认的父类对象
	//调用父类的同名方法
	ptansheng->coder::coding();
    //父类的私有无法使用

	delete ptansheng;

	std::cin.get();
}

类的继承以及区别

#include<iostream>

class father
{
public:	
	int num;
	void print()
	{
		std::cout << num << std::endl;
	}
	father()
	{
		num = 99;
	}
};

class son:public father
{
public:
	int num;
	
	void print()
	{
		std::cout << num << std::endl;
	}
	son()  //子类覆盖父类
	{
		num = 89;
	}
};

void main()
{
	son *pson = new son;
	pson->print();
	pson->father::print();

	father *p = reinterpret_cast<father *>( pson);
	p->print();

	std::cin.get();
}

继承静态成员与静态函数

#include<iostream>

class myclass
{
public:
	int data;
	static int num;//声明静态变量存在
	myclass()
	{
		num++;//共享,统计对象的数目
	}
	static void print()
	{
		//this->data;//静态函数无法使用this指针
		//data = 10;
		std::cout << num << std::endl;
	}
};

int myclass::num = 0;//静态变量初始化

//private私有继承，无法传承到下一代
class ziclass:protected myclass
{
	void run()
	{
		this->print();
		this->num;
	}
};

class sunclass :protected  ziclass
{
	void goandrun()
	{
		this->ziclass::myclass::print();
	}
};

void main()
{
	ziclass *p = new ziclass;
	ziclass z1;
	sunclass *ps = new sunclass;
	//int a;
	//p->num;
	//p->print();
	p->myclass::num;
	p->myclass::print();
	//ps->print();
	//ps->ziclass::myclass::print();

	std::cin.get();
}

继承实现代码重用

基类的初始化

#include<iostream>

class myclass
{
public:
	myclass() :x(0)
	{
		//x = 0;
		std::cout << "myclass  init without num" << std::endl;
	}
	myclass(int num) :x(num)
	{
		//x = num;
		std::cout << "myclass init with num" << std::endl;
	}
protected:
private:
	int x;
};

class myziclass:public myclass
{
public:
	myziclass()
	{
		std::cout << "myziclass  init without num" << std::endl;
    }
	myziclass(int num) :myclass(num), x(num + 1), y(num+2)
	{
		std::cout << "myziclass  init with num" << std::endl;
	}
	int x;
	int y;
};

void main()
{
	//指定构造函数
	myziclass  *p = new myziclass(10);

	std::cin.get();
}

立方体

#include <iostream>
#include<math.h>

class dian
{
public:
	friend class xian;
	dian(int a, int b, int c) :x(a), y(b), z(c)
	{
          
	}
	void print()
	{
		std::cout << "x=" << x << ",y=" << y << ",z=" << z << std::endl;
	}
private:
	int x;
	int y;
	int z;
};
//继承没有意义,包含
class xian 
{
public:
	xian(dian dianx, dian diany) :dian1(dianx), dian2(diany)
	{

	}
	double getlength()
	{
		double length = 0;
		length = sqrt((dian1.x - dian2.x)*(dian1.x - dian2.x) + (dian1.y - dian2.y)*(dian1.y - dian2.y) + (dian1.z - dian2.z)*(dian1.z - dian2.z));

		return length;
	}
	dian dian1;
	dian dian2;
protected:
private:

};

class yuan :public xian
{
public:
	yuan(dian dianx, dian diany) :xian(dianx,diany)
	{
		
	}

	double getmianji()
	{
		return 3.1415926* (this->getlength())*(this->getlength());
	}

	double zhouchang()
	{
		return 3.1415926* 2*(this->getlength());
	}
};


class qiu :public yuan
{
public:
	qiu(dian dian1,dian dian2) :yuan(dian1,dian2)
	{

	}
	double getmianji()
	{
		return 3.1415926* (this->getlength())*(this->getlength()) * 4;
	}

	double gettiji()
	{
		return 4 / 3.0*3.1415926* (this->getlength())* (this->getlength())* (this->getlength());
	}
};

void main()
{
	dian dian1(0, 0, 1);
	dian dian2(0, 0, 6);
	dian1.print();
	dian2.print();
	xian xian1(dian1, dian2);
	std::cout << xian1.getlength() << std::endl;
	yuan yuan1(dian1, dian2);
	std::cout << yuan1.getmianji() << std::endl;
	std::cout << yuan1.zhouchang() << std::endl;
	qiu qiu1(dian1, dian2);
	
	std::cout << qiu1.gettiji() << std::endl;
	std::cout << qiu1.getmianji() << std::endl;

	std::cin.get();
}

单继承QT案例

#include <QApplication>
#include<QLabel>
#include<stdlib.h>

class mylable:public QLabel
{
public:
    mylable( char *str):QLabel(str)
    {

    }
    void run (char *str)
    {
        system(str);
    }
};

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

   // QLabel *plabel =new QLabel("ABCDEF");
   // plabel->show();
    mylable my1("12345ABC");
    my1.show();
    my1.run("notepad");


    return a.exec();
}

多继承简介以及实战

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

class zajiao :public MainWindow,public QLabel,public QPushButton
{
public:
    zajiao(char *str):QLabel(str),QPushButton(str)
    {
       this->MainWindow::setWindowTitle(str);
    }
    ~zajiao()
    {
    }
};

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

     zajiao  zajiao1("ABCDEF12345");

     zajiao1.QPushButton::show();
     zajiao1.QPushButton::move(0,0);
     zajiao1.QLabel::show();


     zajiao1.MainWindow::show();

    return a.exec();
}

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

    //MainWindow w;
    //w.show();
   // w.setWindowTitle("ABCD");

   // QPushButton *p1=new QPushButton("ABC");
  //  p1->show();

    return a.exec();
}

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

class A
{

};

class B
{

};

class myclass1
{
public:
	void run(char *str)
	{
		system(str);
	}
	myclass1()
	{
		std::cout << "myclass1 is create" << std::endl;
	}
	~myclass1()
	{
		std::cout << "myclass1 is delete" << std::endl;
	}
};

class myclass2
{
public:
	int add(int a, int b)
	{
		return a + b;
	}
	myclass2()
	{
		std::cout << "myclass2 is create" << std::endl;
	}
	~myclass2()
	{
		std::cout << "myclass2 is delete" << std::endl;
	}
};

class myclass:public myclass1,public myclass2,public A,public B
{
public:
	void print(char *str)
	{
		std::cout << str << std::endl;
	}
	myclass()
	{
		std::cout << "myclass is create" << std::endl;
	}
	~myclass()
	{
		std::cout << "myclass is delete" << std::endl;
	}
};

void main2()
{
	myclass *pmy1 = new myclass;
	delete pmy1;

	std::cin.get();
}

void main1()
{
	myclass my1;
	my1.run("tasklist");
	my1.myclass1::run("ipconfig");
	std::cout << my1.add(10, 20) << std::endl;
	std::cout << my1.myclass2::add(19,20) << std::endl;
	my1.print("12345");
	
	std::cin.get();
}

虚基类

虚基类的作用

当一个基类被声明为虚基类后，即使它成为了多继承链路上的公共基类，最后的派生类中也只有它的一个备份。

#include <iostream>


class obj
{
public:
	int num;
	obj(int data) :num(data)
	{		
		std::cout << "obj  create\n";
	}

	obj()
	{
		num = 0;
		std::cout << "obj  create\n";
	}
	~obj()
	{
		std::cout << "obj  delete\n";
	}
};

class  Aobj : virtual  public obj
{
public:
	Aobj(int data) :obj(data)
	{
		std::cout << "Aobj  create\n";
	}
	~Aobj()
	{
		std::cout << "Aobj  delete\n";
	}
};

class  Bobj :  virtual public obj
{
public:
	Bobj(int data) :obj(data)
	{
		std::cout << "Bobj  create\n";
	}
	~Bobj()
	{
		std::cout << "Bobj  delete\n";
	}
};

class ABobj :public Aobj, public Bobj
{
public:
	ABobj(int x, int y) :Aobj(x), Bobj(y)
	{
		std::cout << "ABobj  create\n";
	}

	ABobj(int z) :Aobj(z), Bobj(z)
	{
		std::cout << "ABobj  create\n";
	}

	~ABobj()
	{
		std::cout << "ABobj  delete\n";
	}
};


void main()
{
	ABobj *p = new ABobj(10);
	//std::cout << p->num;
	std::cout << p->Aobj::obj::num << "\n";
	std::cout << p->Bobj::obj::num << "\n";
	delete p;

	std::cin.get();
}

继承以及作业安排

#include <iostream> 
#include <amp.h> 
#include<thread>
#include<vector>
using namespace std;

using namespace std::this_thread;

using namespace concurrency;
void run()
{
	int v[11] = { 'G', 'd', 'k', 'k', 'n', 31, 'v', 'n', 'q', 'k', 'c' };

	array_view<int> av(11, v);
	parallel_for_each(av.extent, [=](index<1> idx) restrict(amp)
	{
		av[idx] += 1;
	});

	for (unsigned int i = 0; i < 11; i++)
		std::cout << static_cast<char>(av[i]);
	std::cin.get();
}

int main1()
{
	vector<thread*> threads;

	for (unsigned int i = 0; i < 5; i++) 
	{
		threads.push_back(new thread(run));
	}

	for (auto x : threads) 
	{
		x->join();
	}


	std::cin.get();
	return 0;
}

Gpu编程

#include <iostream>  
#include <amp.h>
#include <WinBase.h>

#define COUNT 10000

float nickName_GPU[COUNT];
float nickName_CPU[COUNT];

double rungpu(int num)restrict(amp)
{
	double temp = 0;
	for (int i = 0; i < num; i++)
	{
		temp += i;
	}
	return temp;
}

double runcpu(int num)restrict(cpu)
{
	double temp = 0;
	for (int i = 0; i < num; i++)
	{
		temp += i;
	}
	return temp;
}

double runcpugpu(int num) restrict(amp, cpu)
{
	double temp = 0;
	for (int i = 0; i < num; i++)
	{
		temp += i;
	}
	return temp;
}



int main(void)
{
	LARGE_INTEGER freq;
	LARGE_INTEGER strt;
	LARGE_INTEGER ed;
	QueryPerformanceFrequency(&freq);
	QueryPerformanceCounter(&strt);

	concurrency::array_view<float> myView(COUNT, nickName_GPU); //将数据打入显存  
	concurrency::parallel_for_each(myView.extent, [=](concurrency::index<1> idx) restrict(amp)
	{
		for (int i = 0; i < 100000; i++)
		{
			myView[idx] = (myView[idx] + 0.1f) / 2.3f;
		}
	});

	myView.synchronize();//显式等待GPU计算完成并将数据打回内存  

	QueryPerformanceCounter(&ed);
	printf("GPU耗时: %d 毫秒\r\n", (ed.QuadPart - strt.QuadPart) * 1000 / freq.QuadPart);
	QueryPerformanceCounter(&strt);
	
	for (int idx = 0; idx < COUNT; idx++)
	{
		for (int i = 0; i < 100000; i++)
		{
			nickName_CPU[idx] = (nickName_CPU[idx] + 0.1f) / 2.3f;
		}
	}
	QueryPerformanceCounter(&ed);
	printf("CPU耗时: %d 毫秒\r\n", (ed.QuadPart - strt.QuadPart) * 1000 / freq.QuadPart);
	for (int idx = 0; idx < COUNT; idx++)
	{
		if (nickName_CPU[idx] != nickName_GPU[idx])
		{
			puts("CPU和GPU的计算结果不相符！");
			getchar();
			return 0;
		}
	}
	puts("测试结束");


	getchar();
	return 0;
}

吴英强

关注

2
点赞
踩
4

收藏

觉得还不错? 一键收藏
2
评论
【C/C++学院】0822-类型转换函数与构造转换函数/类的继承/类的继承以及区别/继承静态成员与静态函数//继承实现代码重用/单继承QT案例/多继承简介以及实战/Gpu编程

类型转换函数与构造转换函数#includeclass fushu{public: explicit fushu(int num)//避免隐式转换，引发歧义 { x = num; y = num; } void print() { std::cout << x << "+" << y << "i" << std::endl; } operator int()
复制链接

扫一扫