递归汉诺塔 双层递归

#include <iostream>

void han(int n, char A, char B, char C)
{
	static int  num = 1;
	std::cout << "第" << num << "次";
	num++;
	if (n<1)
	{
		return;
	} 
	else
	{
		han(n - 1, A, C, B);
		std::cout << A << "->" << C << std::endl;
		han(n - 1, B, A, C);
	}
}

//  f(n)=2*f(n-1)+1 //f(n)=2^n-1
//2^64- 1
void main()
{
	int n;
	std::cin >> n;
	std::cout << "n=" << n << std::endl;
	han(n, 'A', 'B', 'C');
	std::cin.get();
	std::cin.get();
}

CPP结构体 

#include<iostream>

struct lstruct
{
	int num;
};

struct MyStruct
{
	int num;
	double db=10.8;//默认的值
	//MyStruct sx;//拒绝内部定义自己
	MyStruct *pnext;
	MyStruct *phead;
	lstruct  l1;
	void boss()
	{

	}
};

struct MyStructA
{
	int num;
	double db = 10.8;//默认的值
	//MyStruct sx;//拒绝内部定义自己
	MyStruct *pnext;
	MyStruct *phead;
	lstruct  l1;
	void boss()
	{

	}
};

struct 
{
	int num;
	double db ;//默认的值
	MyStruct boss1;
}sx,sy;//匿名结构体不允许初始化

void main()
{
	MyStruct s1;//自动管理
	MyStruct *pnew = new MyStruct;//手动
	s1.l1.num;
	//pnew->l1.num;
	(*pnew).l1.num;
	//类型相同可以整体赋值
	//结构体C++风格初始化方式
	MyStruct s2(s1);
	MyStruct *pnew2(new MyStruct);
	MyStructA sa1;
	//MyStruct s3(sa1);C++强类型，必须类型匹配
}

void main1()
{
	MyStruct  s1;
	std::cout << s1.db << std::endl;
	sx.boss1.num;//结构体嵌套就是...
	std::cin.get();
}

面向过程与面向对象的编程模式

C管理进程

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
#include<windows.h>

//面向过程的模式
//代码重用主要靠函数
//权限，

void open(const char *path,const int mode)
{
	ShellExecuteA(0, "open", path, 0, 0, mode);
}

void all()
{
	system("tasklist");
}

void closebyname(const char *name)
{
	char cmdstr[100] = { 0 };
	sprintf(cmdstr, "taskkill /f /im %s", name);
	system(cmdstr);
}

void closebypid(const int num)
{
	char cmdstr[100] = { 0 };
	sprintf(cmdstr, "taskkill /pid %d", num);
	system(cmdstr);
}


void main1()
{
	all();
	open("notepad", 1);
	all();
	Sleep(2000);
	int  num;
	scanf("%d", &num);
	closebypid(num);
	//closebyname("notepad.exe");
	system("pause");
}
//复数a+bi
struct fu
{
	int a;
	int b;
};

//a+ bi,
struct fu  add(struct fu  fu1, struct fu  fu2)
{
	struct fu  fu3;
	fu3.a = fu1.a + fu2.a;
	fu3.b = fu1.b + fu2.b;
	return fu3;
}

void   main3()
{
	//数据可以随便被别人，可以随便被修改
	struct fu  fu1 = { 3, 4 };
	struct fu  fu2 = { 13, 4 };
	fu1.a += 3;
	struct fu  fu3 = add(fu1, fu2);
	printf("%d+%di", fu3.a, fu3.b);
	getchar();
}

面向对象管理进程

#define  _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
#include <windows.h>

//C++类的继承实现代码重用， C重用   函数
//类的封装实现权限，封装，数据与代码合为一体。C封装主要是函数
//封装可以锁定代码的权限，锁定的数据的权限，避免被随意修改
//类的多态，一个接口根据实际需求完成很多不同的功能

class cmduse
{
private:
	char cmduser[100];//用户名
	char cmd[100];//存储指令
public:
	void setuser(const char * name)
	{
		strcpy(cmduser, name);
	}
	char * getuser()
	{
		return this->cmduser;//返回用户名
	}
	void open(const char *path, const int mode)
	{
		ShellExecuteA(0, "open", path, 0, 0, mode);
	}
	void all()
	{
		system("tasklist");
	}
	void closebyname(const char *name)
	{
		memset(this->cmd, 0, 100);//清空字符串
		sprintf(this->cmd, "taskkill /f /im %s", name);
		system(this->cmd);
	}
	void closebypid(const int num)
	{
		memset(this->cmd, 0, 100);//清空字符串
		sprintf(this->cmd, "taskkill /pid %d", num);
		system(this->cmd);
	}
};

void main2()
{
	cmduse cmduse1;
	cmduse1.setuser("yincheng");
	std::cout << cmduse1.getuser() << std::endl;
	cmduse1.open("calc",1);
	cmduse1.open("notepad",0);
	Sleep(2000);
	cmduse1.all();
	cmduse1.closebyname("calc");
	int pid;
	std::cin >> pid;
	cmduse1.closebypid(pid);//根据编号关闭

	std::cin.get();
	std::cin.get();
	//closebypid(100);

}

//封装可以实现代码权限，不可以随便调用
class 
{
public:
	void seta(int a)
	{
		//接口
		this->a = a;
	}
	int geta()
	{
		return this->a;
	}
	void setb(int b)
	{
		//接口
		this->b = b;
	}
	int getb()
	{
		return this->b;
	}

protected:

private:
	int a;
	int b;
	char password[100];
}myab;

void main()
{

//	myab.geta = 3;
	myab.seta(10);
	//封装解决的问题
	//类的，代码与数据，一体化
    //代码的封装，限定代码谁可以执行谁不可以执行的权限
	//数据的封装，防止数据被意外修改
}

类的常识共用体实现一个类的特征

#include<iostream>

//union  本质也是一个类，可以内部有函数，
//union,内部数据是共享，不同对象之间是独立的，代码是共享
//union,也具备结构体所有功能
//某些节约内存的类需要用到共用体
union MyUnion
{
	int num;
	double db;
	void go()
	{

	}
};
//内部数据是共享内存，不可以继承
union MyUnionA 
{
	int num;
	double db;
	void go()
	{

	}
};

void main()
{
	std::cout << sizeof(MyUnion) << std::endl;
	MyUnion union1;
//	union1.db = 10;
	union1.num = 20;
	std::cout << union1.num << std::endl;
	union1.db = 10.9;//时时刻刻共用体仅有一个变量存在

	std::cout << union1.num << std::endl;
	std::cin.get();	
}

QT应用于类以及类的常识

空类

#include<iostream>

//空类占一个字节，表明类存在
//空类有int,占4个，
//
class kong
{
public:
	//int num;

	void go(int  num)
	{
		std::cout << "锄禾日当午";
     }
};

void main()
{
	std::cout << sizeof(kong) << std::endl;
//	std::cout << &kong << std::endl;
	kong  kong1;
	//kong1.num = 10;
	std::cout << &kong1 << std::endl;

	std::cin.get();
}

Qtobj

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

class bigsmall
{
    Dialog  *p;
public:
    void setp(Dialog  *p)
    {
        this->p=p;
    }
    void set(int x,int y)
    {
        this->p->resize(x,y);//设置大小

    }
    void big()
    {
        for(int i=0;i<600;i++)
        {
             this->p->resize(i,i);
        }
    }
    void small()
    {
        for(int i=600;i>=0;i--)
        {
             this->p->resize(i,i);
        }
    }
};

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

//    Dialog  mydialog1,mydialog2;

   // mydialog1.show();
   // mydialog2.show();

   Dialog  *pd1,*pd2;
   pd1=new Dialog;
   pd2=new Dialog;
  // pd1->show();
  // pd2->show();
   pd1->resize(800,600);

   pd2->resize(600,800);

   (*pd1).show();
   (*pd2).show();

   bigsmall  bigsmall1;
   bigsmall1.setp(pd1);
   bigsmall1.big();
   bigsmall1.small();

   bigsmall  bigsmall2;
   bigsmall2.setp(pd2);
   bigsmall2.big();
   bigsmall2.small();

   //delete pd1;
  // delete pd2;

    return a.exec();
}