程序片段(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
", 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位整数!
", 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("
");//换行
}
}
//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("
");
}
}
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("
");
}
}
//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("
");
}
}
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("
");
}
}
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("
");
}
}
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("
");
}
}
//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("
");
}
}
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("
");
}
}
//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("
");
}
}
//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 ", j, i, j*i);
}
j++;
}
printf("
");
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
", i);
break;
}
else
{
printf("i != %d
", 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
", 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
", (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
", 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
", i);//只会具有打印奇数的机会
}
system("pause");
}
int main02(void)
{
for (int i = 100; i <= 200; i++)
{
printf("%3d次!
", i - 99);
if (i % 3 == 0)
{
break;
//continue;结束本次循环
}
printf("%d
", 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 ", i, j);
}
printf("
");
}
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("
");
}
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
", 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
", 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("
");
}
AAA: system("notepad");//跳出复杂循环结构
system("pause");
}
int main06(void)
{
goto C;
goto B;
A: printf("AAA
");
B: printf("BBB
");
C: printf("CCC
");
D: printf("ATM
");//一般复杂逻辑,不推荐使用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
", i);
break;
}
}
{//用于控制循环变量的作用域-->模拟for循环
int i = 100;//循环初始化条件只会执行一次
AAA:if (i <= 200)//循环条件判断执行多次
{//循环体内容
if (i % 3 == 0)
{
printf("%d
", 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
", i);
}
{//控制循环变量的作用域
int i = 100;//循环变量初始化条件
AAA:if (i <= 200)
{
if (i % 3 != 0)
{
i++;
goto AAA;//等价于continue
}
printf("%d
", i);
i++;
goto AAA;
}
printf("%d
", 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-玩儿失踪!
");
}
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)
{//线程的main
int 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
", 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
", 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
", f1);
printf("%d
", f2);
for (int i = 3; i <= 40; i++)
{//待推导的位数为40
f3 = f1 + f2;//只要建立了这个关系-->就行了-->剩下的计算机去完成所有的关系计算-->与数据推导
printf("%d
", 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
", isit(33));
for (int i = 100; i < 150; i++)
{
if (isit(i))
{
printf("%d
", 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
", num);
for (int i = 2; i <= num / 2; i++)
{
if (isit(i) && isit(num - i))
{
printf("
num = %d + %d
", i, num - i);
}
}
system("pause");
}
int main03(void)
{
int num = 0;
scanf("%d", &num);
printf("%d
", 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
", 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
", num);
for (; num; num /= 10)//去除个位
{//判断整数是否整个都已经为0了
int temp = num % 10;//取出个位
newnum = newnum * 10 + temp;//新数以前各位进行提升,后来的数作为个位补充
}
printf("newnum = %d
", newnum);
system("pause");
}
//03.整数逆置的方式二:
// while循环实现
int main02(void)
{
int num = 0;
int newnum = 0;
scanf("%d", &num);
printf("%d
", num);
while (num)//循环条件判断:待逆置的整数不能整个数据都为0,允许中间位为0
{
int temp = num % 10;//不断的取出个位的操作
newnum = newnum * +temp;//新数的原来所有位不断的进行向高位提升,后来的位作为个位的补充
num /= 10;//不断的进行去除个位的步骤
}
printf("newnum=%d
", 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
", num);
if (num != 0)
{
do
{
int temp = num % 10;//不断的取出待逆置数据的个位
newnum = newnum * 10 + temp;//逆置之后的数据不断的向高位提升,剩下一个个位,用当前获取的个位进行补充
//取出一次个位,去除一次个位
num /= 10;//不断的去除待逆置数据的个位
} while (num);
}
printf("newnum = %d
", newnum);
system("pause");
}
//05.整数逆置的方式四:
// goto语句模拟循环实现整数逆置
int main04(void)
{
int num = 0;
int newnum = 0;
scanf("%d", &num);
printf("%d
", num);
AAA:if (num)
{
int temp = num % 10;//不断的取出待逆置整数的个位
newnum = newnum * 10 + temp;//不断的将逆置之后的整数向高位进行提升,提升之后空余的个位采用刚取出的个位补上
num /= 10;//不断的去除待逆置整数的个位
goto AAA;//回到循环判断条件
}
printf("%d
", 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
", num);
newnum = revInt(num, newnum);
printf("%d
", newnum);
system("pause");
}程序片段(16):go.c
内容概要:解决习题
#include <stdio.h>
#include <stdlib.h>
#define 尊严上的安全感 15
#define 经济上的安全感 22
#define 情感上的安全感 28
#define 帅 98
#define 富 88
#define 高 97
int main01(void)
{
if (帅 > 尊严上的安全感)
{
printf("%d-->%d
", 尊严上的安全感, 帅);
}
if (富 > 经济上的安全感)
{
printf("%d-->%d
", 经济上的安全感, 富);
}
if(高 >情感上的安全感)
{
printf("%d-->%d
", 情感上的安全感, 高);
}
system("pause");
}
#define 吸引力 80
#define 高价值 80
int 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
", get100(365, 0.99), get100(365, 0.98), get100(365, 1.01), get100(365, 1.02));
system("pause");
}