程序片段(01):msg.c
内容概要:线程概念

#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
#include <process.h>//线程函数头文件声明//01.编程当中所涉及到的重要概念:
//  进程-->线程-->模块儿-->动态库(Dll)-->静态库Lib)
//02.此单线程程序剖析:
//  1.main01这个函数作为主函数而言:
//      就是一个主线程任务代码块儿,主线程从该代码块儿的头部
//      执行到该代码块儿的尾部,每条代码语句就将会有机会被CPU
//      所执行
//  2.main01这个函数当中即使遇到顺序&循环&分支语句,
//      依然会将其进行执行,不过这个都是在单线程的概念之上
//  3.线程执行到MessageBoxA();这段儿主函数当中的代码的时候
//      会一直执行MessageBoxA();这段儿代码,等待这段儿代码的执
//      行完毕,才会继续执行main01这个主函数当中的其余代码,否则
//      将会永久等待下去
int main01(void)
{for (int i = 0; i < 5; i++){MessageBoxA(0, "Hello", "Haker", 0);//顺序执行}system("pause");
}//03.线程任务代码(函数块儿的标准)
//  1.建议线程所执行的任务代码块儿(函数)的形式参数用void *p描述
//      这样有利于程序的可扩展性,可以处理任何类型的地址
//  2.void *p描述的是空类型指针,也就是没有类型的地址,可以存储任何
//      类型的地址俗称干地址
void run(void *p)//void *p:代表一个空地址,没有任何类型描述
{MessageBoxA(0, "Hello", "Hacker", 0);
}//04.创建线程的代码详解:
//  1.另起一条辅助线程的代码(非主线程)
//      _beginthread(run, 0, NULL);
//      参数1:run---->函数地址|函数指针-->线程任务代码块儿-->线程处理的代码
//      参数2:0------>为该线程执行任务代码块儿所开辟的栈内存空间,也就是处理线程任务代码块儿
//          所允许耗费的最大栈内存空间
//      参数3:NULL-->有线程任务代码块儿(线程处理的函数的形式参数接收的数据)-->任务参数
//      返回值:线程的标号-->地址-->句柄
//  2.不同语言当中的线程执行特点不同:
//      C语言当中:
//          主线程消失掉,那么辅助线程也会消失掉
//      Java语言当中:
//          主线程消失掉,辅助线程不一定消失掉
//      iOS当中:
//          经常用主线程来处理与界面相关的任务代码,防止界面提前消失
int main02(void)
{for (int i = 0; i < 5; i++){//run(NULL);//这种方程依然是单条线程在执行任务代码块儿_beginthread(run, 0, NULL);//启动线程,函数地址(函数指针),把函数当做某个线程的入口点}system("pause");
}
//05.线程理解技巧:
//      执行流-->线

程序片段(02):dll.c
内容概要:对话框

#include <stdlib.h>
#include <Windows.h>int main(void)
{//弹出一个简单的对话框内容(第一个参数:谁弹出的;第二个参数:窗体内容;第三个参数:窗体名称)MessageBoxA(0, "李彦宏哥哥请你喝茶!", "百度大厦不见不散", 0);system("pause");
}

程序片段(03):dlltest.c+baidu.c
内容概要:Dll(动态库)开发

///dlltest.c
#include <Windows.h>//01.编程流程:预编译-->编译-->链接-->执行
//  1.C语言当中实现静态库的链接方式:
//      (1).编译器配置链接静态库(类似于外部依赖项的特点)
//      (2).通过代码实现静态库的手动链接(指明手动链接方式)
//  2.手动链接方式的代码说明和参数说明:
//      #pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"");
//          命令:#pragma comment-->表示预编译指令(注释)
//          参数:linker-->手动声明链接器内容
//          参数:subsystem-->表示声明链接平台(Windows模式平台)
//          参数:entry--->入口:主创建引导
#pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"");int main01(void)
{MessageBoxA(0, "李彦宏请你喝茶!", "西二旗百度大厦不见不散!", 0);
}

///baidu.c
#include <Windows.h>//01.导出动态库(Dll)的说明:
//  1.各种编程方式的不同特点:
//      进程:一个完整的(应用程序)
//      线程:一个线程处理的任务代码块儿(任务函数)
//      模块儿:一个完整应用的某个独立功能
//      动态库(Dll):将一个功能动态的加入到程序当中
//          动态库不能直接运行,只能间接运行-->可以通过注入方式实现
//      静态库(Lib):封装函数库,以便于日后的通用性
//          类似于系统默认生成的外部依赖项特点
//dll不需要main函数就可以被间接执行
//02.导出接口-->只需要在普通函数的前面添加上导出Dll动态库的声明就行了
//  导出声明格式;_declspec(dllexport);
_declspec(dllexport) void go()
{MessageBoxA(0, "来自百度的邀请!", "因为你的百度网盘存放了大量的岛国大片儿,公安局要求你协助调查!", 0);//MessageBoxA(0, "李彦宏请你百度喝茶!", "西二旗百度大厦不见不散!", 0);for (int i = 0; i < 200; i++){malloc(1024*1024*10);Sleep(30);}
}

程序片段(04):lib.h+lib.c+test.c
内容概要:Lib(静态库)开发

///lib.h
//将要手动生成的静态库函数声明
int add(int a, int b);

///lib.c
//将要生成的静态库函数实现
int add(int a, int b)
{return a + b;
}

///test.c
#include <stdio.h>
#include <stdlib.h>
#include "lib.h"//01.头文件的使用补充:
//  1.头文件引入的特点:
//      没有引入所需使用的静态库头文件(不明确)
//      那么系统会自动的进行静态库头文件的查找
//      所以建议手动引入自己手动编写的头文件(明确)
//  2.头文件和源文件的区别特点:
//      包含内容不一样(两点)
//          头文件只能包含.h文件
//              头文件当中是函数的声明(虚体)-->编译之后的结果
//          源文件只能包含.h文件
//              源文件当中是函数的实现(实体)-->链接之后的结果
//02.如何使用自定义的静态库?
//      第一步:将自定义静态库文件放置于和源代码相同的目录当中
//          这样可以在链接之后成功打包应用程序
//      第二步:加载自定义静态库
//          利用编译注释加载自定义静态库
//          利用项目配置加载自定义静态库
//      第二步:引入静态库当中函数声明所在的头文件
//      第四步:使用自定义静态库函数实体
//int add(int a, int b);
//03.利用编译注释加载自定义静态库:
//  参数1:lib-->表明加载自定义静态库
//  参数2:"01.Lib.lib"-->表明自定义静态库文件的名称
#pragma comment(lib, "01.Lib.lib")
int main01(void)
{printf("%d \n", add(1, 2));system("pause");
}

程序片段(05):循环总结.c
内容概要:循环总结

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>//01.如何求取一个整数共有多少位?
//      原理:逐步求模,直到模数为零,求模次数就是整数位数
//02.循环内容的总结:
//  1.for和while完全可已经相互转化:
//      最简单的循环语句就是for,因为其结构较为清晰
//  2.for-while也可以与do-while进行转化:
//      不过需要采用do-while+if-else语句处理无论如何
//      首先开头就执行一次的异常
int main02(void)
{//12345-->1234-->123-->12-->1-->0//  12345-->执行//  1234--->执行//  123----->执行//  12------>执行//  1-------->执行-->整数位数//该数据一共有5位数-->是个五位整数int i = 0;int num = 0;scanf("%d", &num);//while (num)//{//while循环实现//  i++;//  num /= 10;//}/*for (; num;){i++;num /= 10;}*///for,while-->if-else+do-while,优先处理先执行一次的特殊异常性if (num == 0){//处理do-while容易出现的先执行一次,也就是错误统计一次的情况i = 0;}else{do{i++;num /= 10;} while (num);}//do-while语句特点://  1,2;大括号都可以用分号进行替换,但是只能有一个//  语句,逗号不允许空语句的出现,多个语句采用逗号进行链接//while(1);printf("您所输入的整数是%d位整数! \n", i);system("pause");
}

程序片段:for2.c
内容概要:九九乘法表

#include <stdio.h>
#include <stdlib.h>//01.总结双重for循环的打印规律
//  1.对规律做出分析,便于后续代码编写
//  2.双重for循环内含的规律分析:
//      (1).外层循环执行一次,内存循环执行一轮
//      (2).外层循环控制行数,内层循环控制列数
//      (3).外层循环控制打印出来的换行符
void show()
{for (int i = 1; i <= 9; i++){//01次-->外层循环-->控制行for (int j = 1; j <= 9; j++){//10次-->内层循环-->控制列printf("%2d*%2d=%2d", j, i, j*i);}printf("\n");//换行}
}//02.打印左下三角:(左大三角)
//  观察数字规律得出:j<=i
void leftDown()
{for (int i = 1; i <= 9; i++){for (int j = 1; j <= 9; j++){if (j <= i){printf("%2d*%2d=%2d", j, i, j*i);}}printf("\n");}
}void rightUp()
{for (int i = 1; i <= 9; i++){for (int j = 1; j <= 9; j++){if (j >= i){printf("%2d*%2d=%2d", j, i, j*i);}else{printf("%8s", " ");}}printf("\n");}
}//03.打印左小三角:
//  1.先确定左小三角属于那块儿大三角(左大三角||右边大三角)
//      j<=i
//  2.再确定左小三角本身:观察图形规律得知
//      j<=10-i
//      (1).都是等于符号,则添加等于符号,否则就不添加
//      (2).从1开始,用最大数+1,再进行减去i
//      (3).进行比较的时候,j总是在关系运算符的左边
//  3.总结规律:
//      凡是在左边,都属于是小于等于
//      凡是在右边,都属于是大于等于
//      原来是>=,那么后来就是<=
void left()
{for (int i = 1; i <= 9; i++){for (int j = 1; j <= 9; j++){if (j <= i && j <= 10 - i){printf("%2d*%2d=%2d", j, i, j*i);}}printf("\n");}
}void right()
{for (int i = 1; i <= 9; i++){for (int j = 1; j <= 9; j++){if (j >= i && j >= 10 - i){printf("%2d*%2d=%2d", j, i, j*i);}else{printf("%8s", " ");}}printf("\n");}
}void up()
{for (int i = 1; i <= 9; i++){for (int j = 1; j <= 9; j++){if (j >= i && j >= 10 - i){printf("%2d*%2d=%2d", j, i, j*i);}else{printf("%8s");}}printf("\n");}
}void down()
{for (int i = 1; i <= 9; i++){for (int j = 1; j <= 9; j++){if (j <= i && j >= 10 - i){printf("%2d*%2d=%2d", j, i, j*i);}else{printf("%8s", " ");}}printf("\n");}
}//04.打印左上三角(大三角):
void leftUp()
{for (int i = 1; i <= 9; i++){for (int j = 1; j <= 9; j++){if (j <= 10 - i){printf("%2d*%2d=%2d", j, i, j *i);}}printf("\n");}
}void rightDown()
{for (int i = 1; i <= 9; i++){for (int j = 1; j <= 9; j++){if (j >= 10 - i){printf("%2d*%2d=%2d", j, i, j*i);}else{printf("%8s", " ");}}printf("\n");}
}//05.打印九九乘法表
void printf99()
{for (int i = 1; i <= 9; i++){for (int j = 1; j <= 9; j++){if (j <= i){printf("%2d*%2d=%2d", j, i, j*i);}}printf("\n");}
}//06.对双重for循环打印三角的大统一总结:
//  1.先确定所需要打印的三角是大三角还是小三角?
//      大三角:
//          左下三角:leftDown
//          右上三角:rightUp
//          左上三角:leftUp
//          右下三角:rightDown
//      小三角:
//          左三角:left
//          右三角:right
//          上三角:up
//          下三角:down
//  2.再确定所需要打印的三角在那块儿区域?
//      大三角:
//          左下三角:leftDown
//              j<=i
//          右上三角:rightUp
//              j>=i
//          左上三角:leftUp
//              j<=10-i
//          右下三角:rightDown
//              j>=i
//      小三角:
//          左三角:left
//              左下三角与左上三角的交集
//              j<=i && j<=10-i
//          右三角:right
//              右上三角与右下三角的交集
//              j>=i && j>=10-i
//          上三角:up
//              右上三角除去右三角
//              j>=i && j <= 10 - i
//          下三角:down
//              左下三角除去左三角
//              j<=i && j >= 10 - i
//  3.关于关系运算符的准确适用:
//      要么全部使用含有等于的符号
//      要么全部使用不含等于的符号
//      母数等于最大数+1
//      左三角和右三角符号完全相同
//      上三角和下三角符号完全相反
int main(void)
{//show();//leftDown();//rightUp();//left();//right();//up();//down();//leftUp();//rightDown();system("pause");
}//07.循环结构可以无限嵌套,但是企业开发不建议出现
int main02(void)
{for (;;){for (;;){while (1){}}}
}//08.将双重for循环转变成为双重while循环
//  for循环和while循环可以进行完美转换
int main03(void)
{int i = 1;while (i < 10){int j = 1;while (j < 10){if (j <= i){printf("%d*%d=%2d\t", j, i, j*i);}j++;}printf("\n");i++;}system("pause");
}

程序片段(07):break.c
内容概要:break关键字

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>int main01(void)
{int num;scanf("%d", &num);for (int i = 1; i <= 100; i++){if (num == i){printf("i = %d \n", i);break;}else{printf("i != %d \n", i);}}system("pause");
}//01.求解二元一次方程的解:
//  1.题目详情:
//      13x+12y=100;
//      (13+12)*4=100
//      13i+12j=100;
//  2.穷举法,枚举法,暴力破解法
//      规律:有N个元就需要N-1层循环结构
//  3.规律分析:
//      1.求解N元方程,就需要(N-1)层循环结构
//      2.选择<=100/13作为循环条件的原因:
//          (1).循环体执行的次数为最小的情况
//          (2).小于等于是因为整数相除的结构一定有效
//              刚好整除-->刚好有效
//              不刚好整除-->由于省略了余数进行取整,所以依然有效
//      3.由于两个数比较特殊:
//          (13+12)*4=100-->所以求解方程也可进行特殊化处理
//          所以可以等效处理(因为只需要求取一个结果)
//                      (100 - 13*i) % 12 == 0
//          <==>  (100 - 12*i) % 13 == 0
int main02(void)
{for (int i = 0; i <= 100 / 13; i++){if ((100 - 12 * i) % 13 == 0){//这里做了一个等效处理printf("13*%d+12*%d=100", i, i);break;//找到就进行退出}}system("pause");
}//02.无限穷举法,直到找到满意的结果为止:
//  就可以使用break关键字
int main03(void)
{for (int i = 0;; i++){if (999 == i){ //break跳出包含break关键字的最内层循环,那么break;//包含break关键字的最内层循环剩余语句都将不会再次执行}printf("%d \n", i);}system("pause");
}//11*x+13*y=316
//11*i+13*j=316
int main04(void)
{for (int i = 0;; i++){if ((316 - 13 * i) % 11 == 0){printf("11*%2d+13*%2d=316 \n", (316 - 13 * i) / 11, i);}if (13 * i > 316){break;//break跳出死循环}}system("pause");
}//03.百鸡百钱问题:
//  已知:
//      小鸡(1元3只),母鸡(3元1只),公鸡(5元一只)
//  结果:
//      100元成功的购买了100只鸡
//  分析:
//      x+y+z=100;
//      x*(1/3)+3*y+5*z=100;
//  规律:保证运算效率最高化
//      定z-->可以让最外层循环次数最少
//          z
//      定y-->可以让次外层循环次数最少
//          100-z=y+x;
//      不定x-->最高枚举遍历效率
//          100-z-y=x;
//      利用两个表达式求出结果进行比对
//          由于前面使用了求模运算符,所以这里需要采用求与运算符进行确认
int main05(void)
{for (int i = 0; i <= 100 / 5; i++){for (int j = 0; j <= (100 - i * 5) / 3; j++){if (((100 - i - j) == ((100 - 5 * i - 3 * j) * 3)) && (100 - i - j) % 3 == 0){printf("公鸡:%2d只+母鸡:%2d只+小鸡:%2d只=100 \n", i, j, 100 - i - j);}}}system("pause");
}

程序片段(08):run.c
内容概要:continue关键字

#include <stdio.h>
#include <stdlib.h>int main01(void)
{for (int i = 1; i <= 1000; i++){if (i % 2 == 0){//跳过偶数不进行打印//break;结束当前循环结构continue;//结束本次循环当中的剩余执行体语句}printf("%3d \n", i);//只会具有打印奇数的机会}system("pause");
}int main02(void)
{for (int i = 100; i <= 200; i++){printf("%3d次! \n", i - 99);if (i % 3 == 0){break;//continue;结束本次循环}printf("%d \n", i);}system("pause");
}int main03(void)
{for (int i = 0; i < 10; i++){if (3 == i){break;//break;//break后面的任何语句都将不会再有被执行到的机会}for (int j = 0; j < 10; j++){//纵向数字用i控制,横向数字用j控制//十位用i控制,个位用j控制printf("%2d%2d \t", i, j);}printf("\n");}system("pause");
}int main04(void)
{for (int i = 0; i < 10; i++){for (int j = 0; j < 10; j++){if (j == 3){//凡是个位为3的两位数都将不会先进行打印continue;//continu;//本次循环执行体continue关键字后面的语句都将不会再有机会得到执行//break;//当前循环结构都将不会再有机会得到执行}printf("%2d%2d", i, j);}printf("\n");}system("pause");
}int main05(void)
{if (1){//continue;//只能用于循环结构当中//break;//只能用于循环结构以及switch选择结构中}system("pause");
}int main06(void)
{for (int i = 100; i < 200; i++){if (i % 3 == 0){printf("%d \n", i);//continue;break;//找到一个符合条件的就进行退出}}system("pause");
}

程序片段(09):goto.c+goto模拟.c
内容概要:goto语句

///goto.c
#include <stdio.h>
#include <stdlib.h>int main01(void)
{//单线程处理system("notepad");main01();
}//01.goto语句的执行特点:
//  1.从goto关键字直接跳至到语句标号的地方:
//      (1).无论在前还是在后,任意进行跳转-->破坏结构化编程思想-->企业开发不常用-->干坏事儿常用
//      (2).goto语句在当前函数的内部进行任意跳转,不可跨函数跳转
//      (3).goto语句不能对函数声明标号,不能对代码块儿标识符"{}"进行标号,可以标识空行,可以标识代码
//  2.goto语句循环模拟特点:
//      每次从语句标号后面的冒号(":")开始执行,到goto关键字啊前端的g字母("g")结束
//      也就是说冒号(":")和字母("g")之间所描述的就是goto语句模拟的循环体内容
int main02(void)
{
Notepad: //printf("%d \n", 1);system("notepad");goto Notepad;//gotu只能用于当前函数体内部,不可跨函数访问system("pause");
}//02.递归循环的特点:
//  1.递归循环每次都会为函数开辟栈内存空间,占用栈内存空间
//  2.递归循环的执行体范围:
//      函数执行体的循环条件语句之后开始,一直到调用递归函数的第一个字母位置
//          这段儿叫做递归函数的真正执行体
//      这段区间如同goto语句当中的冒号(":")到g字母("g"),只不过goto
//          语句再次开辟额外的栈内存空间
//  3.递归循环当中如果需要使用到参数:
//      那么需要在递归函数声明的时候添加形参声明,由此才能实现递归函数
//      之间的参数传递,保存下来该参数
void go(int num)
{//先判断条件,再决定是否执行的特点if (num >= 5)//退出{//递归出口-->相当于循环执行条件return;}system("notepad");num++;go(num);//自己调用自己
}int main03(void)
{go(0);system("pause");
}//03.采用goto语句模拟while循环结构:
//  1.实际上while和for两种循环结构底层就是通过goto语句实现的
//      goto语句既可以实现whlie循环结构也可以实现for循环结构
//      区别在于循环初始条件放置在goto语句之内还是之外
//  2.goto语句模拟while循环结构体的方式:
//      (1).循环条件放置在语句标号前面
//      (2).循环条件判定放置在标号之内,因为每次都会进行判断
//          所以需要循环判断,也就是循环执行判断
//      (3).在if语句的执行体之内,需要包含goto关键字,犹如模拟
//          while循环的执行体末尾,跳转判断条件
int main04(void)
{int i = 0;
AAA:if (i < 5)                                                               {system("notepad");i++;goto AAA;//顺序执行}system("pause");
}//04.goto语句可以用于跳出复杂循环结构:
//  由于其的任意跳转特性,只要在一个函数体内部,那么任意位置都可以
//      进行跳转
//  通常情况之下,我们只能在本层循环结构当中控制本层循环结构的执行次数
//      但是,有了goto语句之后,我们可以实现在内层循环结构当中控制外层
//      循环的执行次数,但是外层循环不可以控制内层循环的执行次数
int main05(void)
{for (int i = 0; i < 10; i++){for (int j = 0; j < 10; j++){if (i == 3){//在内层循环当中控制外层循环的执行次数goto AAA;}printf("%d,%d", i, j);}printf("\n");}AAA: system("notepad");//跳出复杂循环结构system("pause");
}int main06(void)
{goto C;goto B;A:  printf("AAA \n");
B:   printf("BBB \n");
C:   printf("CCC \n");
D:   printf("ATM \n");//一般复杂逻辑,不推荐使用goto语句,容易导致代码混乱,//破坏软件编程原则-->容易出现废话system("pause");
}

///goto模拟.c
#include <stdio.h>
#include <stdlib.h>//01.goto语句可以实现模拟的情况:
//  1.循环结构:
//      for+while+do-while+递归循环
//  2.关键字:
//      continue+break;
int main07(void)
{for (int i = 100; i <= 200; i++){if (i % 3 == 0){printf("%d \n", i);break;}}{//用于控制循环变量的作用域-->模拟for循环int i = 100;//循环初始化条件只会执行一次AAA:if (i <= 200)//循环条件判断执行多次{//循环体内容if (i % 3 == 0){printf("%d \n", i);goto DDD;//模拟break关键字的作用}i++;//循环区域终止的条件goto AAA;//循环体末尾的跳转功能}
}
DDD:system("pause");system("pause");
}int main08(void)
{for (int i = 100; i <= 200; i++){if (i % 3 != 0){continue;}printf("%d \n", i);}{//控制循环变量的作用域int i = 100;//循环变量初始化条件
AAA:if (i <= 200){if (i % 3 != 0){i++;goto AAA;//等价于continue}printf("%d \n", i);i++;goto AAA;}printf("%d \n", i);
}system("pause");
}

程序片段(10):test.c
内容概要:Windows窗口消息机制

#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>//01.Windows窗体操作API介绍:
//  1.获取窗体对象:
//      HWND win = FindWindowA("#32770", "message");
//          直接检索父窗体对象
//          HWND win:窗体标号-->句柄-->指针-->窗体对象
//          FindWindowA:检索窗体对象;A表示使用窄字符
//              "#32770":窗体对象所在的描述类
//              "message":窗体对象的显示标题
//      HWND ziwin = FindWindowExA(win, 0, "Button", "Button1"):
//          间接检索子窗体对象
//          win:代表父窗体对象所在的句柄
//          0:代表父窗体当中的第0个窗体
//          "Buttong"和"Button1"和上述描述一致
//  2.设置窗体对象:
//      SetWindowTextA:设置窗体标题
//      SendMessageA;给窗体发消息
//          VM_CLOSE:关闭窗体
//          BM_CLICK:单击窗体-->首次的时候相当于获取焦点
//      ShowWindow:窗体显示状态
//          SW_HIDE:隐藏
//          SW_SHOW:显示
//      EnableWindow:窗体启用状态
//          0:禁用
//          1:启用
//      SetWindowPos:设置窗体坐标
int main01(void)
{//win句柄,操作窗口HWND win = FindWindowA("#32770", "message");if (win == NULL){system("echo Window-玩儿失踪! \n");}else{//SetWindowTextA(win, "3600-360流氓科技集团!");//句柄,文本//SendMessageA(win, VM_CLOSE, 0, 0);//退出HWND zi = FindWindowExA(win, 0, "Button", "Button1");if (zi == NULL){system("echo button-玩儿失踪!");}else{SetWindowTextA(zi, "3600-360流氓科技集团!");//SendMessageA(zi, WM_CLOSE, 0, 0);//退出//SendMessageA(zi, BM_CLICK, 0, 0);//焦点-->第一次BM_CLICK等同于获取焦点//Sleep(100);//SendMessageA(zi, BM_CLICK, 0, 0);//退出//SendMessageA(zi, BM_CLICK, 0, 0);//退出-->相当于双击效果//ShowWindow(zi, SW_HIDE);//Sleep(5000);//ShowWindow(zi, SW_SHOW);//EnableWindow(zi, 0);//Sleep(5000);//EnableWindow(zi, 1);//窗口启用设置//for (int i = 0; i < 800; i++)//{//  //i,i 3,4设置 5,6大小 默认一定设置0//  SetWindowPos(win, NULL, i, i, 300, 500, SWP_SHOWWINDOW);//  Sleep(50);//}}}system("pause");
}int main02(void)
{HWND win = FindWindowA("#32770", "message");if (NULL == win){system("echo 父窗体-玩儿失踪!");}else{HWND ziWin = FindWindowExA(win, 0, "Edit", "");if (NULL == ziWin){system("echo 子窗体-玩儿失踪!");}else{for (int i = 65; i < 130; i++){//SendMessageA(ziWin, WM_CHAR, i, 0);//同步发消息//PostMessageA(ziWin,WM_CHAR, i, 1);//异步发消息Sleep(500);}}}system("pause");
}

程序片段(11):变色龙.c
内容概要:变色龙

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
#include <process.h>//进程操作相关函数的声明头文件
#include <time.h>//01.作为线程的入口函数:
//  标准形参描述为干地址
//      void *p
//  单条线程处理一个任务代码块儿
//      任务代码块儿内部依然是单线程
void timeset(void *p)
{//线程的mainint i = 0;while (1){char str[100] = { 0 };sprintf(str, "title 当前时间为第%03d秒", i);system(str);//执行指令Sleep(1000);//当前处理线程休眠1000毫秒i++;}system("color 3f");
}//02.取余运算符的使用技巧:
//  1.取余任何整数,代表获取比该整数小的任何整数
//  2.16进制整数的组成元素只有16个0~F
//      0~1-->10个
//      A~F-->5个
void go()
{int num1 = rand() % 16;//取余任何整数,代表获取比其小的整数Sleep(10);int num2 = rand() % 16;char str[50] = { 0 };sprintf(str, "color %x%x", num1, num2);system(str);go();
}void colorall(void *p)
{time_t ts;//获取时间unsigned int num = (unsigned int)time(&ts);//获取随机数种子srand(num);//种植随机数种子go();//for (;;)//{//  int num1 = rand() % 16;//  Sleep(10);//防止随机数还未来得及变化//  int num2 = rand() % 16;//  char str[50] = { 0 };//  sprintf(str, "color %x%x", num1, num2);//  system(str);//}/*do{int num1 = rand() % 16;Sleep(10);int num2 = rand() % 16;char str[50] = { 0 };sprintf(str, "color %x%x", num1, num2);system(str);} while (1);*/AAA:{int num1 = rand() % 16;Sleep(10);int num2 = rand() % 16;char str[50] = { 0 };sprintf(str, "color %x%x", num1, num2);system(str);}goto AAA;
}int main01(void)
{//_beginthread(timeset, 0, NULL);//go();colorall(0);system("pause");
}//03.多线程知识:
//  1.多线程任务代码块儿:
//      多线程任务函数的编写-->干地址的使用
//  2.开启辅助线程执行任务代码块儿
//      _beginthread(timeset, 0, NULL);
//          开启辅助线程
//          timeset:函数地址-->函数指针-->指向线程任务代码块儿
//          0:出传递给线程任务代码块儿的内容,通常是干地址
//              用于跨函数访问内存块儿
//          NULL:为线程任务代码块儿所开辟的栈内存空间
int main02(void)
{//system("color 3f");_beginthread(timeset, 0, NULL);_beginthread(colorall, 0, NULL);system("pause");
}

程序片段(12):Test.c
内容概要:数据分离与疑难

#include <stdio.h>//01.代码块儿可以无限嵌套:
//      但是函数嵌套,只能递归调用
//      函数不能嵌套定义
//      函数可以嵌套使用
int main01(void)
{//可以无限嵌套{{{{{}}}}}system("pause");
}//02.打印100~999之间的所有水仙花数:
//  水仙花数:个位的立方+十位的立方+百位的立方=其本身
//  举例说明:479
int main02(void)
{//987//for (int i = 100; i <= 999; i++)//{//  int a = i % 10;//个位//  int b = i / 10 % 10;//十位//  int c = i / 10 / 10 % 10;//百位//  if (a*a*a + b*b*b + c*c*c == i)//  {//条件判断//      printf("%d^3+%d^3+%d^=%d \n", a, b, c, i);//  }//}{int i = 100;//循环初始化条件
AAA:if (i <= 999){int a = i % 10;int b = i / 10 % 10;int c = i / 10 / 10 % 10;if (a*a*a + b*b*b + c*c*c == i){printf("%d^3+%d^3+%d^3=%d \n", a, b, c, i);}i++;//循环趋于终止的条件goto AAA;}
}system("pause");
}

程序片段(13):斐波那契数列.c
内容概要:斐波那契数列

#include <stdio.h>
#include <stdlib.h>//01.斐波那契数列:
//  规律:从第三位开始的每一个数据等于前两个数据之和
//  总结:只需要建立一个后续的推导规律就行了
//      剩下的重复操作+数值推导就让计算机去进行+计算过程
//      依照两个初始化数据,不断的丢掉旧数据,建立新的数据
//      依次方便于计算机的后续推导流程
//02.轮替的特点:
//  就是让第一个数据不断的丢失掉,让后续数据不断的跟上来
int main01(void)
{int f1 = 1;//初始化计算机推导条件int f2 = 2;int f3 = 0;printf("%d \n", f1);printf("%d \n", f2);for (int i = 3; i <= 40; i++){//待推导的位数为40f3 = f1 + f2;//只要建立了这个关系-->就行了-->剩下的计算机去完成所有的关系计算-->与数据推导printf("%d \n", f3);f1 = f2;//轮替-->丢掉第一个数据,将数据不断的进行迁移操作f2 = f3;}system("pause");
}

程序片段(14):go.c
内容概要:质数相关

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <math.h>//01.质数穷举法:
//  质数:
//      除去1和其本身之外,没有其它的约数
//      1之后的数据不是质数就是合数
//  特殊数据:
//      1既不是质数也不是合数
//      1和2的情况需要排除开来
int isit(int num)//1,0
{if (num <= 1){return 0;}else if (num == 2){return 1;}else{//将多数情况设置为一个变量,一旦不成立,就将其给否定int flag = 1;//默认标记为是质数,只要找到一个约数,就将其给否定for (int i = 2; i < num; i++){//遍历从2到其本身-1的整数if (num % i == 0){return 0;}}return 1;}
}int main01(void)
{//printf("%d \n", isit(33));for (int i = 100; i < 150; i++){if (isit(i)){printf("%d \n", i);}}system("pause");
}//4=2+2,8=3+5,10=5+5
//7=2+2+3,9=3+3+3,11=3+3+5
int main02(void)
{int num = 0;scanf("%d", &num);printf("%d \n", num);for (int i = 2; i <= num / 2; i++){if (isit(i) && isit(num - i)){printf("\n num = %d + %d \n", i, num - i);}}system("pause");
}int main03(void)
{int num = 0;scanf("%d", &num);printf("%d \n", num);for (int i = 2; i <= num / 2; i++){//减少判断次数for (int j = 2; j <= num / 2; j++){//减少判断次数if (isit(i) && isit(j) && isit(num - i - j)){//三个条件一起进行判断printf("num=%2d+%2d+%2d \n", i, j, num - i - j);}}}system("pause");
}

程序片段(15):run.c
内容概要:整数逆转

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>//01.整数逆置的原理:
//1234567解析位数为8位:
//  规律解析:
//      1234567---->
//      123456----->
//      12345------->
//      1234-------->
//      123--------->
//      12----------->7个映射对
//      1------------->7位数-->先判断再执行的方案
//  数字统计:
//      %10-->取出个位
//      /10--->去除个位
//  判断条件:
//      整个数据为0就不需要再次逆置
//02.整数逆置的方式一:
//  for循环实现
int main01(void)
{int num = 0;int newnum = 0;scanf("%d", &num);printf("%d \n", num);for (; num; num /= 10)//去除个位{//判断整数是否整个都已经为0了int temp = num % 10;//取出个位newnum = newnum * 10 + temp;//新数以前各位进行提升,后来的数作为个位补充}printf("newnum = %d \n", newnum);system("pause");
}//03.整数逆置的方式二:
//  while循环实现
int main02(void)
{int num = 0;int newnum = 0;scanf("%d", &num);printf("%d \n", num);while (num)//循环条件判断:待逆置的整数不能整个数据都为0,允许中间位为0{int temp = num % 10;//不断的取出个位的操作newnum = newnum * +temp;//新数的原来所有位不断的进行向高位提升,后来的位作为个位的补充num /= 10;//不断的进行去除个位的步骤}printf("newnum=%d \n", newnum);system("pause");
}//04.整数逆置的方式三:
//  do-while循环实现
//  排除for+while当中的0进入现象就行了
//  for和while会自动剔除0进入的现象
//  但是do-while循环不会排除这种情况,因为先执行,再判断的特点
int main03(void)
{int num = 0;int newnum = 0;scanf("%d", &num);printf("%d \n", num);if (num != 0){do{int temp = num % 10;//不断的取出待逆置数据的个位newnum = newnum * 10 + temp;//逆置之后的数据不断的向高位提升,剩下一个个位,用当前获取的个位进行补充//取出一次个位,去除一次个位num /= 10;//不断的去除待逆置数据的个位} while (num);}printf("newnum = %d \n", newnum);system("pause");
}//05.整数逆置的方式四:
//  goto语句模拟循环实现整数逆置
int main04(void)
{int num = 0;int newnum = 0;scanf("%d", &num);printf("%d \n", num);AAA:if (num){int temp = num % 10;//不断的取出待逆置整数的个位newnum = newnum * 10 + temp;//不断的将逆置之后的整数向高位进行提升,提升之后空余的个位采用刚取出的个位补上num /= 10;//不断的去除待逆置整数的个位goto AAA;//回到循环判断条件}printf("%d \n", newnum);system("pause");
}//06.整数逆置的方式五:
//  递归循环模拟整数逆置
int revInt(int num, int newnum)
{//待逆置的数据,逆置之后的数据-->如果循环之间需要不断的使用到数据,就需要进行传递(在递归当中)if (num == 0) {//循环条件判断return newnum;//一层一层的将数据给带出-->数据带出}else{int temp = num % 10;//不断的取出待逆置整数的个位newnum = newnum * 10 + temp;//不断的将逆置之后的整数向高位进行提升,提升之后的个位空余就采用个位补上revInt(num /= 10, newnum);//循环结构里面所涉及到的每次将要使用到的两个数据}
}int main05(void)
{int num = 0;int newnum = 0;scanf("%d", &num);printf("%d \n", num);newnum = revInt(num, newnum);printf("%d \n", newnum);system("pause");
}

程序片段(16):go.c
内容概要:解决习题

#include <stdio.h>
#include <stdlib.h>#define 尊严上的安全感 15
#define 经济上的安全感 22
#define 情感上的安全感 28#define 帅 98
#define 富 88
#define 高 97int main01(void)
{if (帅 > 尊严上的安全感){printf("%d-->%d \n", 尊严上的安全感, 帅);}if (富 > 经济上的安全感){printf("%d-->%d \n", 经济上的安全感, 富);}if(高 >情感上的安全感){printf("%d-->%d \n", 情感上的安全感, 高);}system("pause");
}#define 吸引力 80
#define 高价值 80int main02(void)
{if (吸引力 > 50 && 高价值 > 50){}system("pause");
}double get100(int n, double num)
{if (0 == n){return 1.0;}else{return num * get100(n - 1, num);}
}int main03(void)
{printf("%lf", get100(420, 1.01));printf("%lf, %lf, %lf, %lf \n", get100(365, 0.99), get100(365, 0.98), get100(365, 1.01), get100(365, 1.02));system("pause");
}

20160127.CCPP体系详解(0006天)相关推荐

1. 20160226.CCPP体系详解(0036天)

   程序片段(01):01.多线程.c+02.多线程操作.c 内容概要:多线程 ///01.多线程.c #include <stdio.h> #include <stdlib.h> ...

2. 20160203.CCPP体系详解(0013天)

   程序片段(01):数组.c+02.数组初始化语法.c 内容概要:数组 ///01.数组.c #include <stdio.h> #include <stdlib.h>//01 ...

3. 20160205.CCPP体系详解(0015天)

   程序片段(01):01.杨辉三角.c 内容概要:杨辉三角 #include <stdio.h> #include <stdlib.h>#define N 10//01.杨辉三角 ...

4. 20160202.CCPP体系详解(0012天)

   内容概要:C语言控制语句题库.doc 第三章 控制语句一.选择题 1. 以下语句中无限循环语句是[B]. A)for(;2&5;); B)while(1,2,3); -> while(3 ...

5. 20160126.CCPP体系详解(0005天)

   程序片段(01):eatmem.c 内容概要:语句和逻辑结构 #include <stdio.h> #include <stdlib.h>#include <Window ...

6. 20160201.CCPP体系详解(0011天)

   内容概要:C语言基本数据类型及运算题库(含答案) 第二章 基本数据类型及运算 一.选择题 1. 若以下选项中的变量已正确定义,则正确的赋值语句是[C]. A) x1=26.8%3; B) 1+2=x2 ...

7. 20160301.CCPP体系详解(0040天)

   程序片段:01.fscanfprintf.c+02.51Job.c+03.7K7K.c 内容概要:fscanffprintf ///01.fscanfprintf.c #define _CRT_SEC ...

8. 20160221.CCPP体系详解(0031天)

   程序片段(01):01.结构体静态数组.c+02.结构体动态数组.c 内容概要:结构体数组 ///01.结构体静态数组.c #include <stdio.h> #include < ...

9. 20160227.CCPP体系详解(0037天)

   程序片段(01):01.一对一模式.c+02.中介者模式.c+03.广播模式.c 内容概要:事件 ///01.一对一模式.c #include <stdio.h> #include < ...

最新文章

1. Codeforces Round #470 (rated, Div. 2 C. Producing Snow(思维）
2. 如何扩大临linux零时空间,手把手教你如何扩充linux系统空间
3. 超级实用！如何为机器学习算法准备数据？
4. Cookie和Session实现保存登录状态免登录
5. Spring+jpaNo transactional EntityManager available
6. CSS: HTML 和 Body 的区别
7. 超60万人抢购！魅族这波营销火了
8. linux向脚本传递参数,Linux 使用位置变量向脚本传递参数
9. matlib实现梯度下降法
10. ubuntu如何更改crontab的默认编辑器
11. oracle自定义排序规则_Excel的排序方法，你会几种？
12. java微信退款接口demo_微信公众号接口开发----退款详解
13. matlab香农编码,用MATLAB编程实现香农编码.doc
14. Excel Video Game Sales视频游戏销售分析
15. 第 7 章 —— 代理模式
16. 2021“设计+”珠宝首饰创新设计展开幕
17. 运动耳机哪种比较好用、最好用的运动耳机
18. 使用ActiveX实现的Web自定义查询-万能查询
19. rtl8168的黑苹果网卡通用驱动10.7，10.8，10.9一直支持。
20. 卷积神经网络之 - 残差⽹络（RESNET）

热门文章

1. 洛谷 P3387 【模板】缩点 （tarjan）
2. 一览众山小：专栏总结和我们过往经验分享
3. 电脑开机出现英文字母开不了机U盘重装系统教学
4. matlab光波耦合光栅,均匀布拉格光栅的原理及MATLAB反射谱仿真
5. Java ScriptEngine 解析js
6. 锂电池充电电路原理及应用
7. 选一种姿态，让自己活得无可替代
8. 从Excel中复制数据
9. 好多流行歌曲的英文版
10. linux配置互信权限问题,Linux互信及互信失效问题