20160126.CCPP体系详解(0005天)

程序片段(01):eatmem.c
内容概要:语句和逻辑结构

#include <stdio.h>
#include <stdlib.h>#include <Windows.h>//01.杂乱知识点:
//  1.内存分配函数malloc();
//      (1).分配单位:字节
//      (2).分配方式:
//          鲸吞+慢咽
//  2.内存分配注意事项:
//      32位的单个进程一口气对多开辟2G的内存
//  3.程序当中默认操作的数据最小单位
//      都是字节
//  4.软件存储单位访问特点:
//      硬访问:最小单位字节(byte)
//          访问硬件
//      软访问:最小单位二进制位(bit)
//          二进制位运算
//  5.常说的顺序分支循环结构
//      都是处于单线程的情况下
//  6.单线程与多线程的执行特点:
//      单线程,顺序执行
//      多线程,乱序执行
int main01(void)
{//malloc(1024 * 1024 * 2000);int num = 1 + 2 + 4 * 4;num += 4;while (1){malloc(1024*1024*50);//吃内存多少Sleep(2000);//线程休眠时间长短}system("pause");
}//02.空语句与代码块儿的含义:
//      空语句-->";"
//      代码块儿-->"{}"
int main02(void)
{;//空语句;{//代码块儿}system("pause");
}//03.错误说法:
//  在同一个函数当中不允许出现名称相同的变量
//  应该是在同一个代码块儿当中不允许出现名称相同的变量
//      同一个代码块儿-->意味着所处代码块儿层级一致-->平行特点
int main03(void)
{int a;//重定义,同一个语句{int a;{int a;}}system("pause");
}

程序片段(02):指令.c+QQ.c
内容概要:结构化程序设计

///指令.c
#include <stdio.h>
#include <stdlib.h>void tasklist()
{system("tasklist");//显示进程列表
}void tasklistwritetofile()
{system("tasklist >> D:\\1.txt");//将进程列表数据追加到D:\\1.txt文件当中
}//01.进程列表查询原理:
//  1.执行原理:exe <C:\\1.txt scanf("%s", str); if(strstr())
//  2.步骤分析:
//      (1).执行进程列表查询命令,将查询结果导入到硬盘上的文件中
//      (2).读取硬盘上的文件数据进内存
//      (3).遍历文件在内存中的二进制数据,进行字符串匹配
//02.进程数据与文件操作:
//  重写数据(">")
//  追加数据(">>")
//  读取数据("<")
int main01(void)
{//记录所有进程,写到文件write >> i.txt;-->以便于后期对数据进行操作//记录所有进程,显示出来-->无法对进程列表显示出来的数据进行操作//判断QQ存在与否,存在则关闭该进程,不存在则打开该进程//日志:隐含着对系统的任何操作,可以进行日志筛选和删除system("tasklist >> D:\\1.txt");system("ipconfig > D:\\1.txt");//>重写,>>追加system("pause");
}

///QQ.c
#define _CRT_SECURE_NO_WARNINGS#include <stdio.h>
#include <stdlib.h>
#include <string.h>//01.scanf();函数数据扫描特点:
//  1.使用输入字符串格式控制符的时候需要注意:
//      %XXXs控制符中间的XXX代表使用扫描多少个字符
//  2.先将硬盘上的文件数据导入到内存中,并且使用字符串
//      存储该二进制数据,然后再对内存中的字符数据进行
//      匹配检索,检索之后,判断该字符串是否存在于文件当中
int main01(void)
{char str[4096];//获取文件大小scanf("%4096s", str);char *p = strstr(str, "QQ.exe");//判断QQ.exe是否存在//strstr返回指向字符串开始字符的地址,NULLif (p != NULL){printf("存在! \n");}else{printf("不存在! \n");}system("pause");
}

程序片段(03):最小数.c
内容概要:输出最小的数

#define _CRT_SECURE_NO_WARNINGS#include <stdio.h>
#include <stdlib.h>//原理:两两进行比较,完全比较
int main01(void)
{int x, y, z;scanf("%d%d%d", &x, &y, &z);if (x > y){//x一定不是最小的if (y > z){printf("最小数是z = %d \n", z);}else{printf("最小数是y = %d \n", y);}}else{//y一定不是最小的if (x > z){printf("最小数是z = %d \n", z);}else{printf("最小数是x = %d \n", x);}}system("pause");
}int main02(void)
{int x, y, z;scanf("%d%d%d", &x, &y, &z);(x > y) ? ( (y > z) ? printf("最小数是z = %d \n", z) : printf("最小数是y = %d \n", y)):((x > z) ? printf("最小数是z = %d \n", z) : printf("最小数是x = %d \n", x)) ;system("pause");
}

程序片段(04):go.c
内容概要:顺序结构

#include <stdio.h>
#include <stdlib.h>int main01(void)
{printf("%d \n", 1);//顺序结构,从上往下执行,从main函数开始printf("%d \n", 11);printf("%d \n", 111);printf("%d \n", 1111);system("pause");
}void p1()
{printf("%d \n", 1);
}void p2()
{printf("%d \n", 11);
}void p3()
{printf("%d \n", 111);
}//01.所有函数的调用特点:
//  所有函数默认情况之下都是单线程调用的,
//  也就是说父函数的继续执行,必须等待子函数的执行完毕才行
//  一层嵌套一层的特点
int main02()
{p1();//函数调用,必须等待这个函数执行完毕之后,才会执行下一步p2();p3();system("pause");
}//02.异或的使用特点:
//  1.一个数据异或同一个数量两次,得到的数据是原始数据
//  2.原始数据和0进行异或,将会保持数据不变
int main03(void)
{int num = 10;num += 10;num -= 2;num ^= 1;num ^= 1;num ^= 0;printf("%d \n", num);system("pause");
}

程序片段(05):run.c
内容概要:if单分支

#define _CRT_SECURE_NO_WARNINGS#include <stdio.h>
#include <stdlib.h>int main01(void)
{if (-2 + 2)//只分辨0与非0的情况{system("msconfig");}}int main02(void)
{if (0)system("msconfig");//if不加括号的情况下,默认的控制范围为,其后的一条语句//一条语句:一个分号或者一个代码块儿system("notepad");system("pause");
}int main03(void)
{int a, b, c;scanf("%d%d%d", &a, &b, &c);if (a < b)//如果a<b,则互换数据实体,保证a是a和b中的数据实体较大变量{//int temp = a;//a = b;//b = temp;a = a ^ b;b = a ^ b;a = a ^ b;}if (a < c){a = a ^ b;b = a ^ b;a = a ^ b;}/*if (b < c){b = b ^ c;c = b ^ c;b = b ^ c;}*///简写形式:if (b < c) b = b ^c, c = b ^ c, b = b ^c;//限定顺序:a>b>cprintf("a = %d, b = %d, c = %d \n", a, b, c);system("pause");
}

代码片段(06):双分支.c
内容概要:if双分支

#define _CRT_SECURE_NO_WARNINGS#include <stdio.h>
#include <stdlib.h>int main01(void)
{if (-1)//这里只需要判定最终结果是0或者非0就行了{system("calc");}else{system("notepad");}system("pause");
}int main02(void)
{//单条语句,{}块儿语句标识符可以省略//最近的分号";"作为语句的结束if (1 - 1)system("calc");elsesystem("notepad");system("pause");return 1;
}int main03(void)
{int a, b;int abs, bbs;scanf("%d,%d", &a, &b);if (a > 0){abs = a;}else{//abs = -a;abs = a * (-1);}/*if (b > 0){bbs = b;}else{bbs = b * (-1);}*/bbs = ((b > 0) ? b : (b * (-1)));printf("%d \n", abs > bbs ? abs : bbs);system("pause");return 1;
}#define 编程能力 80
#define 周瑞富的编程能力 81int main04(void)
{if (周瑞富的编程能力 > 编程能力){printf("欢迎加入流氓集团! \n");}else{printf("回家等电话! \n");}system("pause");return 1;
}

程序片段(07):多分支.c
内容概要:if多分支

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>int main01(void)
{int num;scanf("%d", &num);if (0 == num){MessageBoxA(0, "", "", 0);system("shutdown -r -t 5");//重启命令}else if (1 == num){MessageBoxA(0, "", "", 0);while (1){system("你不爱上刘振全世界就会毁灭 >> C:\\1.exe");//导出并追加的命令}}else{MessageBoxA(0, "", "", 0);while (1){malloc(10 * 1024 * 1024);//内存分配函数}}system("pause");
}#define 企业要求编程能力 80
#define 刘振全的编程能力 39//01.if多分支语句的特点:
//  详情请看后解
int main02(void)
{if (刘振全的编程能力 > 80){printf("高薪! \n");}else if (刘振全的编程能力 < 80 && 刘振全的编程能力 > 60){printf("低薪! \n");}else{printf("回家等电话! \n");}system("pause");
}//02.如何判断同时判断:
//  数字,小写字母,大写字母
int main03(void)
{while (1){char ch = getchar();getchar();//吸收回车符if (ch >= '0' && ch <= '9'){printf("数字! \n");}else if (ch >= 'a' && ch <= 'z'){printf("小写字母1 \n");}else if (ch >= 'A' && ch <= 'Z'){printf("大写字母! \n");}else{printf("其它字符! \n");}}system("pause");
}

程序片段(08):一元二次方程.c
内容概要:分支嵌套

#define _CRT_SECURE_NO_WARNINGS#include <stdio.h>
#include <stdlib.h>
#include <math.h>//01.一元二次方程案例:
//  方程:a*x*x + b*x + c = 0;
//  解析:
//      a = 0;
//          bx + c = 0;
//              b = 0;
//                  c = 0
//                      x-->任意值
//                  c != 0
//                      x-->无解
//              b != 0;
//                  x-->-c/b;
//      a != 0;
//          b*b - 4*a*c = 0;
//          b*b - 4*a*c > 0;
//          b*b - 4*a*c < 0;
//02.对于实数类型的数据录入:
//  必需采用%lf这种输入格式控制符
//  不能使用%f这种输入格式控制符
int main01(void)
{double a, b, c;scanf("%lf%lf%lf", &a, &b, &c);if (a == 0){printf("一元一次方程! \n");if (b == 0){if (c == 0){printf("x可以为任意值! \n");}else{printf("x无解! \n");}}else{printf("x = %lf \n", (-1)*(c / b));}}else{printf("一元二次方程! \n");double db = b*b - 4 * a*c;if (db == 0){printf("x1 = x2 = %lf \n", (-1) *(b / (2 * a)));}else if (db > 0){//不能实根printf("x1 = %lf, x2 = %lf \n", (-b - sqrt(db)) / (2 * a), (-b + sqrt(db) / (2 * a)));}else{//虚根double p = (-b) / (2 * a);double q = sqrt(-db) / (2 * a);printf("x1 = %lf - %lf i, x2 = %lf + %lf i \n", p, q, p, q);}}system("pause");return 1;
}

程序片段(09):enum.c
内容概要:枚举类型

#include <stdio.h>
#include <stdlib.h>//01.C语言当中的枚举类型使用特点解析:
//  1.枚举类型的预置成员只能被赋予整数(char->int->long)
//      绝对不可以被赋予其它值
//  2.枚举类型的预置成员默认从0开始进行标号
//  3.枚举成员当中的任意一个预置成员被赋予了自定义的整数值
//      那么其后的预置成员整型数值依次递增1(从预置整数值开始)
//  4.枚举类型的变量用于有效的限定赋予有意义的值
//      能够限定赋值的范围,只能使用预置成员名称进行赋值
int main01(void)
{//0, 1, 2, 3, 4, 5, 6enum week { 星期1, 星期2, 星期3, 星期4, 星期5, 星期6, 星期7 };//从左往右逐渐递增1,默认从零开始进行递增enum week week1 = 星期5;//enum week-->表示自定义枚举类型 week1-->表示枚举变量if (星期5 == week1){printf("是%d \n", week1);}                                           printf("%d \n", 星期2);//enum只能被赋予整数,其他任意类型都不可以enum jun{司令 = 10,军长 = 9};enum jun j = 司令;printf("%d \n", 司令 > 军长);system("pause");return 1;
}

程序片段(10):switch.c
内容概要:switch多分支

#define _CRT_SECURE_NO_WARNINGS#include <stdio.h>
#include <stdlib.h>//01.if-else if-else内容总结:
//  1.用于多分支判断情况:
//      多个入口,单个出口
//  2.用于区间范围判断
//      判断情况模糊
//  3.作为区间判断的时候需要
//      注意区间范围必须有序
//  4.没有任何返回值
int main01(void)
{                 int num = 9;//if-else if-else-->很容易混淆,不匹配情况//switch-->不容易混淆,绝对匹配情况if (num == 1){if (1 > 0) {}else {}}else if (num == 2){if (2 > 0) {}else {}}else if (num == 3){}else if (num == 4){}else if (num == 5){}else if (num == 6){}else{//处理上述之外的情况}system("pause");return 1;
}//02.switch内容总结:
//  1.用于多分支判断情况:
//      多个入口,单个出口
//  2.用于等值判断
//      待判断变量必须和常量
//      等值才能匹配成功
//  3.特殊情况分析:
//      (1).每种情形完成之后需要添加break语句
//          如果没有break语句,会发生穿透现象
//      (2).穿透现象可以用于离散区间模拟
//          类似于区间形式的判断(前提有序)
//      (3).无论default语句放在哪个位置
//          它都是最后才进行判断的,只有排除了
//          所有情况之后才会到default语句
//      (4).switch语句只有一个出口
//      (5).只要没有break关键字,但是存在default
//          语句,那么最后执行的一定是default语句
//          如果最后执行的default语句后面没有break
//          而且该default语句执行之后会发生穿透现象
//          直到遇到break才会终止switch语句
//  4.switch语句只支持整数类型的等值判断
//      不支持其它类型的等值判断
//  5.case关键字后面的常量匹配值不能是表达式
//      只能是整型常量或者本质为整型常量的字符型数据
int main02(void)
{int num = 1;scanf("%d", &num);char fl = 'A';enum week { X, Y, Z };enum week week1 = X;int data = 2;switch (num){//要处理的变量 error C2050:switch 表达式不是整型//case 10://不可以出现相同的case后置常量case 10:printf("一个士兵! \n");break;case 1:printf("一个班12个人! \n");break;case 2:printf("一个排36个人! \n");case 3:printf("一个连108个人! \n");break;case 4:printf("一个营324个人! \n");break;case 5:printf("一个团972个人! \n");break;default:printf("我只能处理到团级编制! \n");break;}system("pause");return 1;
}

程序片段(11):go.c+周瑞富的报仇计划.c
内容概要:周瑞富的报仇计划

///go.c
#include <Windows.h>//01.模拟一个自动化的过程:
//  1.打开浏览器
//  2.跳转到网址
//  3.输入+搜索
//  4.回车进入到
//  5.关闭浏览器
//02.按键程序自动化模拟:
//  1.键盘事件函数:keybd_event(按键虚拟映射值|按键字符, 0, 键盘操作, 0);
//      keybd_event(0x5B, 0, 0, 0);//按下
//      keybd_event(0x5B, 0, 2, 0);//松开
int main01(void)
{//keybd_event(0x5B, 0, 0, 0);//按下//keybd_event(0x5B, 0, 2, 0);//松开keybd_event(0x5B, 0, 0, 0);keybd_event('M', 0, 0, 0);keybd_event('M', 0, 2, 0);keybd_event(0x5B, 0, 2, 0);//system("pause");return 1;
}//02.鼠标程序自动化模拟:
//  1.鼠标事件函数:mouse_event(待执行的鼠标操作, 鼠标移动到x位置, 鼠标移动到y位置, 0, 0);
//      mouse_event(MOUSEEVENT_ABSOLUTE | MOUSEEVENTF_MOVE, 坐标x, 坐标y, 0, 0);
//  2.整数在进行乘除法的时候:
//      与运算顺序密切相关
int main02(void)
{main01();//全屏幕最小化,回到桌面//移动鼠标到40,40这个位置Sleep(2000);//移动到某个指定位置//mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE, 100 / 1366 * 65535, 100 / 768 * 65535, 0, 0);//错误写法-->数据丢失//mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE, 30, 30, 0, 0);//错误写法-->屏幕分点为65535(宽和高都分布为这么多个点)mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE, 25 * 65535 / 1366, 25 * 65535 / 768, 0 , 0);mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);system("pause");return 1;
}

///周瑞富的报仇计划.c
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>//01.模拟一个自动化流程:
//  1.进入到桌面
//  2.移动鼠标点
//  3.打开浏览器
//  4.跳转到网址
//  5.输入+搜索
//  6.点击进入到
//  7.关闭浏览器
//02.ShellExecuteA(0, "open", str, 0, 0, 3);
//  该函数可以实现定制化的打开各种窗口
void openBrowser(char *str)
{ShellExecuteA(0, "open", str, 0, 0, 3);
}//03.system("taskkill /f /im 360chrome.exe");
//  1.该函数用于关闭某种进程名称的所有进程
//  2.只要进程名称是指定名称,就会被全部关闭掉
void closeBrowser()
{system("taskkill /f /im 360chrome.exe");
}//04.键盘模拟方式:
//  1.模拟JINGDONG英文字母的输入
//  2.模拟回车键按下
void searchKeyword()
{keybd_event('J', 0, 0, 0);//按下keybd_event('J', 0, 2, 0);//松开keybd_event('I', 0, 0, 0);keybd_event('I', 0, 2, 0);keybd_event('N', 0, 0, 0);keybd_event('N', 0, 2, 0);keybd_event('D', 0, 0, 0);keybd_event('D', 0, 2, 0);keybd_event('O', 0, 0, 0);keybd_event('O', 0, 2, 0);keybd_event('N', 0, 0, 0);keybd_event('N', 0, 2, 0);keybd_event('G', 0, 0, 0);keybd_event('G', 0, 2, 0);Sleep(100);keybd_event('1', 0, 0, 0);keybd_event('1', 0, 2, 0);Sleep(100);keybd_event(0x0D, 0, 0, 0);//按下keybd_event(0x0D, 0, 2, 0);//松开
}//05.模拟组合键的按下
//  最大化当前窗口
void maxbaidu()
{//组合快捷键模拟keybd_event(VK_LMENU, 0, 0, 0);//按下keybd_event(VK_SPACE, 0, 0, 0);//按下keybd_event(VK_SPACE, 0, 2, 0);//松开keybd_event('X', 0, 0, 0);//按下keybd_event('X', 0, 2, 0);//松开keybd_event(VK_LMENU, 0, 0, 0);//松开
}//06.鼠标操作模拟:
//  1.模拟鼠标移动
//  2.模拟鼠标双击
//  注意:整数的书写方式
void click()
{mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE, 335 * 65535 / 1366, 225 * 65535 / 768, 0, 0);mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 2, 0);
}int main01(void)
{//01.采用默认浏览器打开指定链接:openBrowser("http://www.baidu.com");Sleep(3000);//02.搜索指定关键字searchKeyword();Sleep(3000);//03.最大化浏览器窗口maxbaidu();//04.模拟鼠标移动并打开click();Sleep(5000);//05.关闭浏览器closeBrowser();system("pause");return 1;
}

程序片段(12):go.c
内容概要:if-switch

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>//01.switch多分支语句内容总结:
//  1.switch能够操作的参数说明:
//      (1).switch();括号参数最终只能有一个值
//      (2).case后的校对常数使用特点:
//          必须是:整型数据或者常量表达式(本质常量)
//          不能是:实数,变量
//          如果使用逗号表达式:常量结果
//              必须使用括号括上,否则无效
//      (3).default后面没有指定匹配常量
//          default语句的位置可以任意指定,
//          如果其他case项目不匹配,始终最后执行该项
//          如果没有放在末尾,切记注意穿透现象,直达break
//          语句才会结束switch选择结构
//          default语句可有可无
//      (4).break语句的使用特殊:
//          用于跳出选择结构,如果没有,将会贯穿执行
//          贯穿执行可以利用,也可以避免
//  2.switch多分支语句与if-else if-esle使用特点:
//      switch:等值判断,离散区间判断
//          结构清晰
//      if-else if-else:区间判断
//          结构混乱
//      注意:区间判断要求数据必须有序
int main01(void)
{int num;scanf("%d", &num);//随机数switch (num){case 1+21:keybd_event('J', 0, 0, 0);//按下keybd_event('J', 0, 2, 0);//松开keybd_event('I', 0, 0, 0);//按下keybd_event('I', 0, 2, 0);//松开keybd_event('N', 0, 0, 0);//按下keybd_event('N', 0, 2, 0);//松开keybd_event('G', 0, 0, 0);//按下keybd_event('G', 0, 2, 0);//松开keybd_event('D', 0, 0, 0);//按下keybd_event('D', 0, 2, 0);//松开keybd_event('O', 0, 0, 0);//按下keybd_event('O', 0, 2, 0);//松开keybd_event('N', 0, 0, 0);//按下keybd_event('N', 0, 2, 0);//松开keybd_event('G', 0, 0, 0);//按下keybd_event('G', 0, 2, 0);//松开Sleep(50);keybd_event('1', 0, 0, 0);//按下keybd_event('1', 0, 2, 0);//松开break;default :break;}system("pause");return 1;
}//02.如何判断小写字母?大写字母?数字
//  char x;
//  x >= 'a' && x <= 'z'
//  x >= 'A' && x <= 'Z'
//  x >= '1' && x <= '1'//double db = 1.9;
//double data;
//if (num == db)
//{}
//else if (num == 1.1 && num > data && data > 10)
//{}
//else if (num == 1.1 )
//{}
//else
//{}

程序片段(13):while.c
内容概要:while循环

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>int main01(void)
{while (0)//0和非0{malloc(1024 * 1024 * 10);}system("pause");return 1;
}int main02(void)
{int i = 0;while (i < 500){system("notepad");i++;}system("pause");return 1;
}int main03(void)
{int i = 0;int j = 0;//0 //1//2//3//4-->5次//while (i++ < 5)//++ <//{//  //i++;//  system("notepad");//}//i++ < 5 <==> ++j <6-->依然5次while (i++ < 5 && ++j < 6){system("notepad");}system("pause");return 1;
}//01.如何识别一条语句:
//  1.空语句(";")
//  2.只要以分号(";")结尾就算一条语句
//  3.语句块儿
//  4.任意一个结构:
//      顺序-->循环-->分支
int main04(void)
{while (1){//while()之后不要添加空语句(;),如果是块儿语句,则整个块儿语句被当做一个语句,否则就是最近的一条语句(例如:空语句;)system("notepad");}system("pause");return 1;
}//02.如何判断一个循环结构到底执行执行多少次?
//  判断多少对映射关系成立就行了
int main05(void)
{int i = 1;int res = 0;while (i <= 100){//100组映射关系成立-->执行100次res += i;i++;}printf("%d \n", res);system("pause");return 1;
}int main06(void)
{int n = 0;scanf("%d", &n);int i = 0;int res = 1;while (i < n)//循环条件{res *= 2;//循环执行体i++;}printf("%d \n", res);system("pause");return 1;
}void shellOpenQQ()
{ShellExecuteA(0, "open", "D:\\ProgramFiles\\Tencent\\QQ\\Bin\\QQScLauncher.exe", 0, 0, 1);
}int main01(void)
{shellOpenQQ();Sleep(3000);HWND win = FindWindowA("TXGuiFoundation", "QQ");if (win != NULL)//找到{//控制窗体显示和隐藏/*printf("窗体显示和隐藏! \n");while (1){ShowWindow(win, SW_SHOW);Sleep(30);ShowWindow(win, SW_HIDE);Sleep(30);}*///控制窗体从左向右移动printf("窗体从左往右移动! \n");//while (1)//{//  int i = 0;//  while (i < 1000)//  {//      SetWindowPos(win, NULL, i, 0, 500, 400, 1);//      //Sleep(30);//      i++;//      //i=0;i-->1000(从左往右进行移动)//      //500,400-->指定窗体的宽高//  }//}//控制窗体从上往下移动printf("窗体从上往下移动! \n");/*while (1){int i = 0;while (i < 500){SetWindowPos(win, NULL, 1000, i, 500, 400, 1);Sleep(30);i++;}}*///控制窗体从右往左printf("控制窗体从右往左! \n");/*while (1){int i = 1000;while (i > 0){SetWindowPos(win, NULL, i, 500, 500, 400, 1);Sleep(30);i--;}}*///控制窗体从下往上printf("控制窗体从下往上! \n");int i = 500;while (i > 0){SetWindowPos(win, NULL, 0, i, 500, 400, 1);Sleep(30);i--;}}system("pause");return 1;
}

程序片段(14):dowhile.c
内容概要:do-while循环

#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>int main01(void)
{do{system("notepad");} while (-1);//do-while至少执行循环体一次,非0将会永远循环执行下去system("pause");return 1;
}//01.通过映射对数判断执行次数的方式:
//  执行-->4
//  执行-->3
//  执行-->2
//  执行-->1
//  执行-->0-->不再执行
int main02(void)
{int i = 5;do{//相当于直接将5映射的哪一次给执行了5-->1:执行5次system("notepad");i--;} while (i);//5次system("pause");return 1;
}//02.通过映射对数判断执行次数的方式:
//  执行-->5
//  执行-->4
//  执行-->3
//  执行-->2
//  执行-->1
//  执行-->0-->不再执行
//  注意:后面的整数是根据while();后面的整个表达式结果进行判断的
//03.循环结构转换特点:
//  1.while循环结构一定能够转换成为do-while循环结构;
//  2.do-while循环结构却不一定能够转换成为while循环结构
//  注意:while<--->do-while循环结构之间的转换规律
int main03(void)
{int i = 5;do{printf("notepad \n");} while (i--);//6次-->整个表达式的映射多加了一个0映射system("pause");return 1;
}int main04(void)
{do{printf("notepad \n");malloc(1024 * 1024 * 500);} while (0);system("pause");return 1;
}int main05(void)
{int i = 5;int j = 4;//执行规律特点分析://  0.确定逻辑与的前后判断关系//  1.针对j的规律分析://      执行-->4//      执行-->3//      执行-->2//      执行-->1//      执行-->0-->映射对数5-->执行5次//  2.针对i的规律分析://      执行-->4//      执行-->3//      执行-->2//      执行-->1//      执行-->0-->映射对数5-->执行5次do{printf("notepad \n");printf("i = %d, j = %d \n", i, j);} while (j-- && --i);//与,有一个为0就终止循环结构system("pause");return 1;
}int main06(void)
{char ch;do{ch = getchar();if (ch >= 'A' && ch <= 'Z'){ch = ch + 32;//大写转小写}getchar();//缓冲回车putchar(ch);putchar('\n');} while (ch != '\t');//等于tab退出do-while循环结构system("pause");return 1;
}//03.Window操作API与do-while函数的结合使用
int main07(void)
{//异步启动一个记事本system("start notepad");Sleep(2000);//获取窗体编号HWND win = FindWindowA("Notepad", "无标题 - 记事本");if (win != NULL){system("echo find notepad! \n");int i = 0;do{//设置窗体信息://win00000000-->窗体句柄号//i---------------->窗体x坐标//i * 768 /1366--->窗体y坐标//400------------->窗体宽度//400------------->窗体高度SetWindowPos(win, NULL, i, i * 768 / 1366, 400, 400, 1);//设置坐标,尺寸i++;} while (i < 1000);}//窗体描述信息//  窗体左上角的坐标表示(IpRect.left, IpRect.top);//  窗体右下角的坐标表示(IpRect.right, IpRect.bottom);RECT IpRect;GetWindowRect(win, &IpRect);printf("%d, %d, %d, %d \n", IpRect.top, IpRect.bottom, IpRect.left, IpRect.right);if (win != NULL){printf("find! \n");//SWP_SHOWWINDOW-->表示显示窗口SetWindowPos(win, NULL, 0, 0, 300, 300, SWP_SHOWWINDOW);//设置坐标尺寸//SetWindowPos();int i = 400;Sleep(1000);do{SetWindowPos(win, NULL, 0, 0, i, i, SWP_SHOWWINDOW);//MoveWindow();printf("%d \n", i);Sleep(100);i += 20;} while (i <= 700);}else{printf("not find! \n");}system("pause");return 1;
}

程序片段(15):for.c
内容概要:for循环

#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>//01.for循环的死循环结构:
//  空语句:for(;;);
//  含语句:for(;-1;);中间只要!0就行
int main01()
{for (;;)//中间的语句起到判断的作用,为空为真,不为空的情况下非0即真,0则假{MessageBoxA(0, "china", "hello", 0);}for (;;);for (; -1;);system("pause");
}//02.还是通过映射对数判断在循环的执行次数
//  先判断,在执行
//03.某种执行结构的末尾空语句和块儿语句特点:
//  所有结构后面都可以出现空语句和块儿语句
//  无论是顺序->分支-->循环结构都是一样的
//  只要是空语句也就当做一条语句进行处理
//  只要是块儿语句也当做一条语句进行处理
//  所有的空语句;都可以通过块儿语句进行替换
//  所有的块儿语句都可以通过空语句进行替换
//  前提条件是一一对应(一个块儿语句对应于一条空语句)
int main02(void)
{//for的作用范围,要么是最近的分号,要么是块儿语句for (int i = 0; i < 5; i++)//i作为初始化条件,i < 5作为循环判断条件,i++作为趋于循环终止的语句{system("calc");}system("pause");
}//04.局部变量作用域分析:
//  循环变量的作用域类似于函数形参这个局部变量一样
//  只在其后面的首个块儿语句当中使用才会有效果
int main02(void)
{int res = 0;for (int i = 1; i <= 100; i++){//循环变量不容易被外部给修改res += i;}printf("res = %d \n", res);int i = 1;while (i <= 100){res += i;}//i = 190;system("pause");
}//05.fox循环特殊点分析:
//  for循环的循环初始化条件,循环判断条件,循环趋向于结束的条件
//  都只会支持一条语句,但是却可以通过逗号运算符或者其他运算符支持多个逻辑执行
//  一个逗号表达式最终只会当做一条语句进行处理
int main03(void)
{for (int i = 0; i < 100; i += 3) {}for (int i = 0, j = 0; i < 100 && j < 100; i += 3, j += 4) {}//for循环通过,逗号运算符支持符合语句system("pause");
}//06.通过for循环实现逻辑:
//  1*2 + 3*4 + 5*6 + ... + 99*100
//  (2n-1)*(2n)-->n从1到50-->由一个数据生成两个数据
int main04(void)
{int res = 0;for (int i = 1; i <= 50; i++){res += i*(i + 1);//C语言当中的乘号不能像数学中的一样进行省略}printf("res = %d \n", res);system("pause");
}int main05(void)
{int res = 0;for (int i = 2; i <= 100; i += 2){res = (i - 1)*i;//推理公式}printf("res = %d \n", res);system("pause");
}int main06(void)
{//让窗口从右上角网左下角移动HWND win = FindWindowA("gdkwindowToplevel", "Cocos");if (win == NULL){printf("Cocos玩儿失踪! \n");}else{for (int i = 0; i < 1000; i++){SetWindowPos(win, NULL, 1366 - i, i * 768 / 1366, 400, 400, 1);}}system("pause");
}

程序片段(16):break.c+break习题.c+google.c
内容概要:break关键字

///break.c
#include <stdio.h>
#include <stdlib.h>//01.不安全函数和安全函数:
//  不安全函数会在安全函数的名称后面添加一个"_s"以作为安全函数的标识
//02.case语句特点:
//  1.swtich当中如果没有使用break关键字,那么switch会贯穿执行
//  2.case语句块儿当中虽然没有使用块儿语句,但是仍然可以编写多条语句
int main01(void)
{int num;scanf_s("%d", &num);//安全的scanf_();函数使用switch (num){case 1://case就像一个开关一样,有一个符合条件,就由开关处从上往下进行执行case后面的语句块儿,一直执行到break关键字为止//如果没有break,就全部进行执行system("tasklist");//进程列表//printf("test \n");//case语句块儿后的语句块儿可以写多条语句break;case 2:system("calc");//计算器break;case 3:system("mspaint");//画图板break;case 4:system("记事本");break;}system("pause");
}//03.break关键字使用总结:
//  1.使用环境:
//      只能用于switch多分支结构和循环结构
//  2.使用特点:
//      用于switch多分支结构:
//          表明终止switch多分支结构(包含break关键字的最内部switch结构)
//      用于循环结构
//          表明终止循环结构(包含break关键字的最内部循环结构)
int main02(void)
{for (int i = 0; ; i++){//for循环第二个语句为空,照样表示的是死循环,除非第二个语句为0,否则都是死循环if (900 == i){break;//退出循环,break一旦执行,表明退出循环结构执行体,也就是说循环结构执行体后面的语句都将得不到执行}printf("%d \n", i);//打印数据}system("pause");
}

///break习题.c
#include <stdio.h>
#include <stdlib.h>//01.求解二元一次方程的两个解
//  二元一次方程
//      316=13*x+11*y
//      316=13*i+11*j
//  穷举法-->枚举法-->暴力破解法
//      (316-13*i) % 11 == 0;//没有余数-->说明整除成功,得到实际的解
int main03(void)
{for (int i = 0;; i++){printf("%d \n", i);if ((316 - 13 * i) % 11 == 0)//判定能否完成整除{//没有余数,说明整除成功-->有结果printf("316 = %d*13 + %d*11 \n", i, (316 - 13 * i) / 11);//整除成功之后的结果就是相应的解break;}}system("pause");
}

///google.c
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>//ShellExecuteA//打开Google浏览器
void openGoogle()
{ShellExecuteA(0, "open", "C:\\Users\\ZHEN\\AppData\\Local\\Google\\Chrome\\Application\\chrome.exe", 0, 0, 1);//默认窗口打开
}//控制Google浏览器
void moveGoogle()
{//寻找一个窗口,获取以后,将窗口编号赋值给变量winHWND win = FindWindowA("Chrome_WidgetWin_1", "打开新的标签页 - Google Chrome");if (win == NULL){printf("谷歌玩儿失踪! \n");return;}//0,10,20,30,40,50//0,1,2,3,4,5for (int i = 0;; i = i + 10){if (i > 1500){break;}SetWindowPos(win, NULL, i, 0, 200, 200, 0);//设置窗口位置,大小if (i / 10 % 2 == 1){ShowWindow(win, SW_HIDE);//隐藏}else{ShowWindow(win, SW_SHOW);//显示}Sleep(30);}int x = 1600;while (1){if (x == 0){break;//跳出循环}SetWindowPos(win, NULL, x, 0, 200, 200, 0);//设置窗口坐标,尺寸Sleep(50);x = x - 10;}SetWindowPos(win, NULL, 0, 0, 100, 100, 0);//初始位置//do-while实现放大和缩小int y = 100;//y长度从100~768,宽度从100*16/9~1366do{if (y == 768){break;//跳出死循环}SetWindowPos(win, NULL, 0, 0, y * 16 / 9, y, 0);//放大,对应于屏幕的分辨率Sleep(50);y += 10;} while (1);y = 768;do{if (y == 100){break;//跳出死循环}SetWindowPos(win, NULL, 0, 0, y * 16 / 9, y, 0);//通过设置长度,宽度实现缩小Sleep(50);y -= 10;} while (1);system("pause");
}//关闭Google浏览器
void closeGoogle()
{system("taskkill /f /im chrome.exe");
}int main04(void)
{closeGoogle();//关闭以前的Google浏览器Sleep(2000);openGoogle();//打开最新的Google浏览器Sleep(5000);moveGoogle();system("pause");
}

程序片段(17):continue.c+游戏迅雷.c
内容概要:continue关键字

///continue.c
#include <stdio.h>
#include <stdlib.h>//01.continue关键字使用总结:
//  1.使用场景:
//      conti`这里写代码片`nue关键字只能用于循环语句当中
//  2.使用特点:
//      用于结束包含continue关键字的最内层循环结构
//      的执行体当中的本次剩余语句
int main01(void)
{for (int i = 100; i < 201; i++){if (i % 3 == 0){//不会打印能够整除3的数字//break;//结束循环结构continue;//结束本次循环,执行下一次循环,在关键字continue之后的本次循环语句就不被执行了}printf("%d \n", i);}system("pause");
}

///调戏迅雷.c
#define _CRT_SECURE_NO_WARNINGS//关闭安全检查
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>//能够被3整除的秒,我们就进行隐藏,否则我们进行显示
//打开迅雷
void openThunder()
{ShellExecuteA(0, "open", "D:\\ProgramFiles\\ThunderNetwork\\Thunder\\Program\\Thunder.exe", 0, 0, 1);
}void showThunder(int i)
{//i为非0的时候隐藏,i为0的时候显示//寻找描述迅雷的窗体HWND win = FindWindowA("XLUEFrameHostWnd", "迅雷");if (i){ShowWindow(win, SW_HIDE);//隐藏}else{ShowWindow(win, SW_SHOW);//显示}
}void closeThunder()
{system("taskkill /f /im Thunder.exe");
}int main02(void)
{closeThunder();Sleep(2000);openThunder();Sleep(3000);HWND win = FindWindowA("XLUEFrameHostWnd", "迅雷7");//计数器的使用://  计数器构建://      int i = 0;//  计数器使用://      1, 3, 5, 7, 9, 11:隐藏//      2, 4, 6, 8, 10, 0 :显示int i = 0;while (1){char str[20];//字符数组,作为字符串的缓冲区模拟,最大长度为20sprintf(str, "title 第%3d秒 \n", i);//跟printf();函数一样,sprintf();函数也是用于打印字符串的://  printf();函数用于将字符串打印到屏幕//  sprintf();函数用于将字符串打印到字符串system(str);//当前命令行中执行的命令,标题就是当前命令行窗口的标题Sleep(1000);if (i % 3 == 0){ShowWindow(win, SW_HIDE);//隐藏continue;//提前结束本次循环的的余后循环执行体-->节省时间,提升效率}ShowWindow(win, SW_SHOW);//显示i++;//计数器自增-->事情完成之后才增加,没有完成就不用增加(完成为1,未完成不为1)}system("pause");
}

程序片段(18):googleearth.c
内容概要:递归调戏GoogleEarth

#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>//01.HWND类型的变量介绍:
//  1.窗体的唯一标识号
//  2.全局变量,谁都可以进行访问,递归函数同样可以调用
HWND win;//打开GoogleEarth
void openGoogleEarth()
{ShellExecuteA(0, "open", "\"C:\\Program Files (x86)\\Google\\Google Earth\\client\\googleearth.exe\"", 0, 0, 1);
}//GoogleEarth窗体的隐藏和显示切换
void HSGoogleEarth()
{//死循环-->反复调用-->递归的形式-->递归函数ShowWindow(win, SW_HIDE);//隐藏Sleep(1000);ShowWindow(win, SW_SHOW);//显示Sleep(1000);//实现完美间隔形式需要这行代码HSGoogleEarth();
}//Google浏览器窗体的从左往右移动
void moveGoogleEarth(int n)
{//递归函数if (1600 == n)//当n == 1600的时候,结束递归循环{return;//跳出递归循环,进行递归函数的弹栈操作}else{SetWindowPos(win, NULL, n, 0, 500, 500, 0);//设置窗体坐标,尺寸Sleep(50);//休眠当前处理本函数的线程n += 10;//让递归循环函数趋于终止的条件}moveGoogleEarth(n);//递归调用
}//0~1600,长度,宽度都会改变,放大
void googleEarthSmallToBig(int n)
{if (1600 == n){return;//跳出递归循环结构}else{//实现从小到大,GoogleEarth有一个最小的窗口比例,最小不能小于这个窗口比例SetWindowPos(win, NULL, 0, 0, n, n * 768 / 1366, 0);//设置窗体坐标,尺寸Sleep(50);//休眠n += 10;}googleEarthSmallToBig(n);
}//关闭GoogleEarth
void closeGoogleEarth()
{system("taskkill /f /im googleearth.exe");
}//玩儿弄GoogleEarth
void playGoogleEarth()
{//寻找GoogleEarth窗体本身win = FindWindowA("QWidget", "Google Earth");if (NULL == win){printf("GoogleEarth正在玩失踪! \n");return;}Sleep(2000);SetWindowTextA(win, "拉里佩奇!你的产品好垃圾! \n");Sleep(2000);moveGoogleEarth(0);//移动googleEarthSmallToBig(0);//放大HSGoogleEarth();//显示隐藏切换
}int main01(void)
{closeGoogleEarth();Sleep(2000);openGoogleEarth();Sleep(5000);playGoogleEarth();system("pause");
}

程序片段(19):playjobs.c
内容概要:goto调戏apple

#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>void openApple()
{ShellExecuteA(0, "open", "\"C:\\Program Files (x86)\\iTunes\\iTunes.exe\"", 0, 0, 1);//启动iTunes
}void moveApple()
{//创建一个窗口编号变量,寻找iTunes的窗体HWND win = FindWindowA("iTunes", "iTunes");//类名,标题if (NULL == win){printf("apple iTunes正在玩儿失踪! \n");}int i = 0;
A: if (i < 1600)//等价于循环结构趋于终止的条件{SetWindowPos(win, NULL, i, i * 768 / 1366, 700, 400, 0);//设置窗体坐标以及尺寸Sleep(10);//便于我们观察,不要太快i++;goto A;//跳转到A}SetWindowPos(win, NULL, 0, 0, 700, 400, 0);//恢复原始位置
B:Sleep(100);//休眠100毫秒ShowWindow(win, SW_HIDE);//隐藏Sleep(100);ShowWindow(win, SW_SHOW);//显示goto B;
}void closeApple()
{system("taskkill /f /im iTunes.exe");
}int main01(void)
{closeApple();Sleep(2000);openApple();Sleep(5000);moveApple();system("pause");
}

20160126.CCPP体系详解(0005天)相关推荐

20160226.CCPP体系详解(0036天)
程序片段(01):01.多线程.c+02.多线程操作.c 内容概要:多线程 ///01.多线程.c #include <stdio.h> #include <stdlib.h> ...
20160203.CCPP体系详解(0013天)
程序片段(01):数组.c+02.数组初始化语法.c 内容概要:数组 ///01.数组.c #include <stdio.h> #include <stdlib.h>//01 ...
20160205.CCPP体系详解(0015天)
程序片段(01):01.杨辉三角.c 内容概要:杨辉三角 #include <stdio.h> #include <stdlib.h>#define N 10//01.杨辉三角 ...
20160127.CCPP体系详解(0006天)
程序片段(01):msg.c 内容概要:线程概念 #include <stdio.h> #include <stdlib.h> #include <Windows.h&g ...
20160202.CCPP体系详解(0012天)
内容概要:C语言控制语句题库.doc 第三章控制语句一.选择题 1. 以下语句中无限循环语句是[B]. A)for(;2&5;); B)while(1,2,3); -> while(3 ...
20160201.CCPP体系详解(0011天)
内容概要:C语言基本数据类型及运算题库(含答案) 第二章基本数据类型及运算一.选择题 1. 若以下选项中的变量已正确定义,则正确的赋值语句是[C]. A) x1=26.8%3; B) 1+2=x2 ...
20160301.CCPP体系详解(0040天)
程序片段:01.fscanfprintf.c+02.51Job.c+03.7K7K.c 内容概要:fscanffprintf ///01.fscanfprintf.c #define _CRT_SEC ...
20160221.CCPP体系详解(0031天)
程序片段(01):01.结构体静态数组.c+02.结构体动态数组.c 内容概要:结构体数组 ///01.结构体静态数组.c #include <stdio.h> #include < ...
20160227.CCPP体系详解(0037天)
程序片段(01):01.一对一模式.c+02.中介者模式.c+03.广播模式.c 内容概要:事件 ///01.一对一模式.c #include <stdio.h> #include < ...

20160126.CCPP体系详解(0005天)

20160126.CCPP体系详解(0005天)相关推荐

最新文章

热门文章