20160127.CCPP体系详解(0006天)

程序片段(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");
}