• 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返回指向字符串开始字符的地址,NULL
        if (p != NULL)
        {
            printf("存在! 
    ");
        }
        else
        {
            printf("不存在! 
    ");
        }
    
        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 
    ", z);
            }
            else
            {
                printf("最小数是y = %d 
    ", y);
            }
        }
        else
        {
            //y一定不是最小的
            if (x > z)
            {
                printf("最小数是z = %d 
    ", z);
            }
            else
            {
                printf("最小数是x = %d 
    ", x);
            }
        }
    
        system("pause");
    }
    
    int main02(void)
    {
        int x, y, z;
        scanf("%d%d%d", &x, &y, &z);
        (x > y) ? ( (y > z) ? printf("最小数是z = %d 
    ", z) : printf("最小数是y = %d 
    ", y)):((x > z) ? printf("最小数是z = %d 
    ", z) : printf("最小数是x = %d 
    ", x)) ;
    
        system("pause");
    }

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

    #include <stdio.h>
    #include <stdlib.h>
    
    int main01(void)
    {
        printf("%d 
    ", 1);//顺序结构,从上往下执行,从main函数开始
    
        printf("%d 
    ", 11);
    
        printf("%d 
    ", 111);
    
        printf("%d 
    ", 1111);
    
        system("pause");
    }
    
    void p1()
    {
        printf("%d 
    ", 1);
    }
    
    void p2()
    {
        printf("%d 
    ", 11);
    }
    
    void p3()
    {
        printf("%d 
    ", 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 
    ", 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>c
        printf("a = %d, b = %d, c = %d 
    ", 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");
        else
            system("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 
    ", abs > bbs ? abs : bbs);
    
        system("pause");
        return 1;
    }
    
    #define 编程能力 80
    #define 周瑞富的编程能力 81
    
    int main04(void)
    {
        if (周瑞富的编程能力 > 编程能力)
        {
            printf("欢迎加入流氓集团! 
    ");
        }
        else
        {
            printf("回家等电话! 
    ");
        }
    
        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("高薪! 
    ");
        }
        else if (刘振全的编程能力 < 80 && 刘振全的编程能力 > 60)
        {
            printf("低薪! 
    ");
        }
        else
        {
            printf("回家等电话! 
    ");
        }
    
        system("pause");
    }
    
    //02.如何判断同时判断:
    //  数字,小写字母,大写字母
    int main03(void)
    {
        while (1)
        {
            char ch = getchar();
            getchar();//吸收回车符
            if (ch >= '0' && ch <= '9')
            {
                printf("数字! 
    ");
            }
            else if (ch >= 'a' && ch <= 'z')
            {
                printf("小写字母1 
    ");
            }
            else if (ch >= 'A' && ch <= 'Z')
            {
                printf("大写字母! 
    ");
            }
            else
            {
                printf("其它字符! 
    ");
            }
        }
    
        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("一元一次方程! 
    ");
            if (b == 0)
            {
                if (c == 0)
                {
                    printf("x可以为任意值! 
    ");
                }
                else
                {
                    printf("x无解! 
    ");
                }
            }
            else
            {
                printf("x = %lf 
    ", (-1)*(c / b));
            }
        }
        else
        {
            printf("一元二次方程! 
    ");
            double db = b*b - 4 * a*c;
            if (db == 0)
            {
                printf("x1 = x2 = %lf 
    ", (-1) *(b / (2 * a)));
            }
            else if (db > 0)
            {
                //不能实根
                printf("x1 = %lf, x2 = %lf 
    ", (-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 
    ", 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, 6
        enum week { 星期1, 星期2, 星期3, 星期4, 星期5, 星期6, 星期7 };//从左往右逐渐递增1,默认从零开始进行递增
        enum week week1 = 星期5;//enum week-->表示自定义枚举类型 week1-->表示枚举变量
        if (星期5 == week1)
        {
            printf("是%d 
    ", week1);
        }                                           
        printf("%d 
    ", 星期2);
    
        //enum只能被赋予整数,其他任意类型都不可以
        enum jun
        {
            司令 = 10,
            军长 = 9
        };
        enum jun j = 司令;
        printf("%d 
    ", 司令 > 军长);
    
        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("一个士兵! 
    ");
            break;
        case 1:
            printf("一个班12个人! 
    ");
            break;
        case 2:
            printf("一个排36个人! 
    ");
        case 3:
            printf("一个连108个人! 
    ");
            break;
        case 4:
            printf("一个营324个人! 
    ");
            break;
        case 5:
            printf("一个团972个人! 
    ");
            break;
        default:
            printf("我只能处理到团级编制! 
    ");
            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 
    ", 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 
    ", 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("窗体显示和隐藏! 
    ");
            while (1)
            {
                ShowWindow(win, SW_SHOW);
                Sleep(30);
                ShowWindow(win, SW_HIDE);
                Sleep(30);
            }*/
    
            //控制窗体从左向右移动
            printf("窗体从左往右移动! 
    ");
            //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("窗体从上往下移动! 
    ");
            /*while (1)
            {
                int i = 0;
                while (i < 500)
                {
                    SetWindowPos(win, NULL, 1000, i, 500, 400, 1);
                    Sleep(30);
                    i++;
                }
            }*/
    
            //控制窗体从右往左
            printf("控制窗体从右往左! 
    ");
            /*while (1)
            {
                int i = 1000;
                while (i > 0)
                {
                    SetWindowPos(win, NULL, i, 500, 500, 400, 1);
                    Sleep(30);
                    i--;
                }
            }*/
    
            //控制窗体从下往上
            printf("控制窗体从下往上! 
    ");
            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 
    ");
        } while (i--);//6次-->整个表达式的映射多加了一个0映射
    
        system("pause");
        return 1;
    }
    
    int main04(void)
    {
        do
        {
            printf("notepad 
    ");
            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 
    ");
            printf("i = %d, j = %d 
    ", 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('
    ');
        } while (ch != '	');//等于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! 
    ");
            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 
    ", IpRect.top, IpRect.bottom, IpRect.left, IpRect.right);
    
        if (win != NULL)
        {
            printf("find! 
    ");
            //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 
    ", i);
                Sleep(100);
                i += 20;
            } while (i <= 700);
        }
        else
        {
            printf("not find! 
    ");
        }
    
        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 
    ", 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 
    ", res);
    
        system("pause");
    }
    
    int main05(void)
    {
        int res = 0;
    
        for (int i = 2; i <= 100; i += 2)
        {
            res = (i - 1)*i;//推理公式
        }
        printf("res = %d 
    ", res);
    
        system("pause");
    }
    
    int main06(void)
    {
        //让窗口从右上角网左下角移动
        HWND win = FindWindowA("gdkwindowToplevel", "Cocos");
        if (win == NULL)
        {
            printf("Cocos玩儿失踪! 
    ");
        }
        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 
    ");//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 
    ", 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 
    ", i);
            if ((316 - 13 * i) % 11 == 0)//判定能否完成整除
            {//没有余数,说明整除成功-->有结果
                printf("316 = %d*13 + %d*11 
    ", 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()
    {
        //寻找一个窗口,获取以后,将窗口编号赋值给变量win
        HWND win = FindWindowA("Chrome_WidgetWin_1", "打开新的标签页 - Google Chrome");
        if (win == NULL)
        {
            printf("谷歌玩儿失踪! 
    ");
            return;
        }
    
        //0,10,20,30,40,50
        //0,1,2,3,4,5
        for (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~1366
        do
        {
            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 
    ", 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];//字符数组,作为字符串的缓冲区模拟,最大长度为20
            sprintf(str, "title 第%3d秒 
    ", 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正在玩失踪! 
    ");
            return;
        }
        Sleep(2000);
    
        SetWindowTextA(win, "拉里佩奇!你的产品好垃圾! 
    ");
        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正在玩儿失踪! 
    ");
        }
    
        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");
    }
  • 相关阅读:
    关于RadAsm中GetEnvironmentStrings的BUG。
    GetStartupInfo 反调试
    基于TLS的反调试技术
    几种RAID级别的比较
    常用的外网yum源之epel.repo
    常用yum源之(Percona MySQL)
    swap的几点理解
    solaris系统动态查看swap的使用情况
    一次CTS引发的网络故障
    一次goldengate故障引发的操作系统hang起,HA自动切换
  • 原文地址:https://www.cnblogs.com/new0801/p/6176835.html
Copyright © 2020-2023  润新知