20160130.CCPP体系详解(0009天)

程序片段(01):hanoi.c+汉诺塔.c
内容概要:汉诺塔

///hanoi.c
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

int main01(void)
{
    //int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };//一维数组,代码块儿初始化方式(指定)
    //for (int i = 0; i < 10; i++)
    //{
    //  printf("%5d", a[i]);//数组的索引都是从0开始的
    //}

    int a[10][3] = { 0 };//二维数组,代码块儿初始化方式(统一)
    for (int i = 0; i < 10; i++)
    {//行
        for (int j = 0; j < 3; j++)
        {//列
            printf("%5d", a[i][j]);
        }
        printf("
");
    }

    system("pause");
}

int main02(void)
{
    int n = 0;
    int a[10][3] = { 0 };//二维数组,代码块儿初始化方式(统一)

    scanf("%d", &n);
    for (int i = 0; i < n; i++)//控制
    {//-1的原因是因为,索引最大为9,索引最大,赋值却最小-->索引逆向赋值i=0-->index=10-1-i-->sequence=10-0
        a[10 - 1 - i][0] = n - i;//布局
    }
    for (int i = 0; i < 10; i++)//控制行
    {
        for (int j = 0; j < 3; j++)//控制列
        {
            printf("%5d", a[i][j]);
        }
        printf("
");
    }

    system("pause");
}

///汉诺塔.c
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

int hanoiTower[10][3] = { 0 };//二维数组,代码块儿初始化(统一形式)

//01.将二维数组的操作采用图形化方式模拟出来:
//  1.设计操作流程:
//      汉诺塔逻辑实现-->显示汉诺塔流程-->补充函数说明
//  2.所涉及到的设计模式:
//      MVC设计模式(简化版本)

//汉诺塔辅助程序
void movehanoiTower(char x, char y);//移动汉诺塔的过程当中,保留移动痕迹到二维数组(逻辑&数据-->链接起来)
//汉诺塔逻辑实现
void hanoiTowerLogic(unsigned int n, char i, char j, char k);//汉诺塔主逻辑
//显示汉诺塔流程
void showHanoiTower(int hanoiTower[10][3]);//显示汉诺塔数据

void moveHanoiTower(char x, char y)
{
    //实质:就是数组当中两个位置的字符数据之间的交换
    //hanoiTower[imove][m]<--->hanoiTower[jmove][n];
    int m = x - 65;//字符形式转换为整数相差形式(间接记忆字符)
    int n = y - 65;
    int imove = -1;
    int jmove = -1;

    for (int i = 0; i < 10; i++)
    {
        if (0 != hanoiTower[i][m])
        {//检索第一个不为0的
            imove = i;
            break;
        }
    }

    if (0 == hanoiTower[9][n])
    {
        jmove = 9;
    }
    else
    {
        jmove = 10;
        for (int i = 0; i < 10; i++)
        {
            if (0 != hanoiTower[i][n])
            {
                jmove = i;
                break;
            }
        }
        jmove -= 1;
    }

    //将用于间接记忆字符的整数形式进行交换
    int temp = hanoiTower[imove][m];
    hanoiTower[imove][m] = hanoiTower[jmove][n];
    hanoiTower[jmove][m] = temp;
}

void hanoiTowerLogic(unsigned int n, char i, char j, char k)
{
    if (0 == n)
        return;
    else if (1 == n)
    {
        //printf("%c-->%c 
", i, k);
        moveHanoiTower(i, k);
        showHanoiTower(hanoiTower);
        return;
    }
    hanoiTowerLogic(n - 1, i, k, j);
    //printf("%c-->%c 
", i, k);
    moveHanoiTower(i, k);
    showHanoiTower(hanoiTower);
    hanoiTowerLogic(n - 1, j, i, k);
}

void showHanoiTower(int hanoiTower[10][3])
{
    printf("%5c%5c%5c 
", 'A', 'B', 'C');
    printf("---------------
");
    for (int i = 0; i < 10; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            printf("%5d", hanoiTower[i][j]);
        }
        printf("
");
    }
}

int main(void)
{
    int n = 0;

    scanf("%d", &n);
    for (int i = 0; i < n; i++)//控制
    {
        hanoiTower[n - 1 - i][0] = n - i;//布局
    }
    hanoiTowerLogic(n, 'A', 'B', 'C');
    showHanoiTower(hanoiTower);


    system("pause");
}

程序片段(02):QQ.c
内容概要:调戏妹子上QQ

#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
#include <time.h>

int main01(void)
{
    //HWND win = FindWindowA("TXGuiFoundation", "QQ");
    HWND    win = FindWindowA("StandardFrame", "阿里旺旺");

    int i = 0;
    POINT point;
    point.x = point.y = 0;
    time_t te;
    unsigned int seed = (unsigned int)time(&te);
    srand(seed);
    int rnum = 0;

    while (1)
    {
        GetCursorPos(&point);
        rnum = rand() % 4;
        switch (rnum)
        {
        case 0:
            SetWindowPos(win, NULL, point.x - 500, point.y - 500, 0, 0, 1);//1:禁止修改窗体尺寸
            break;
        case 1:
            SetWindowPos(win, NULL, point.x + 500, point.y - 500, 0, 0, 1);
            break;
        case 2:
            SetWindowPos(win, NULL, point.x - 500, point.y + 500, 0, 0, 1);
            break;
        case 3:
            SetWindowPos(win, NULL, point.x + 500, point.y + 500, 0, 0, 1);
            break;
        }

        Sleep(1000);
        ++i;
        if (1000 == i)
            //break;//跳出
            return;//结束
    }
    system("taskkill /f /im iexplore.exe");
    MessageBoxB(0, "发现病毒", "提示信息", 0);

    system("pause");
}

程序片段(03):模块.c
内容概要:鬼哭神嚎

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <Windows.h>
#include <time.h>
#include <process.h>//多线程

//01.如何将一个控制台应用程序转换成为Windows应用程序:
//      控制台-->Windows:实质就是去掉黑窗口
//      控制台应用程序-->链接为-->Windows应用程序(可有Windows窗口,也可以没有)
#pragma comment (linker, "/subsystem:"windows" /entry:"mainCRTStartup"")

void setDktopBkgroundPicture(char *path)
{
    SystemParametersInfoA(20, 0, path, 3);
}

void setBkgroundMusic(char *path)
{
    ShellExecuteA(0, "open", path, 0, 0, 0);//0:代表隐藏(最后一个)
}

void setFegroundText(int x, int y, char * text)
{
    HWND win = GetDesktopWindow();//获取系统窗体(当前程序运行时所显示的整个窗体)
    HDC dc = GetWindowDC(win);//获取设备的上下文(以待用于进行设置)
    SetTextColor(dc, RGB(255, 0, 0));
    SetBkColor(dc, RGB(0, 0, 255));

    while (1)
    {
        TextOutA(dc, 300, 400, text, strlen(text));//显示文本
        Sleep(2000);
    }
}

void bgJpgPicture(void *p)
{
    int rnum = 0;
    char *path[200] = { 0 };
    time_t te;
    unsigned int seed = (unsigned int)time(&te);
    srand(seed);


    while (1)
    {
        rnum = rand() % 9;
        sprintf(path, "C:\Users\ZHEN\Desktop\TestPictore\%d.jpg", rnum);
        setDktopBkgroundPicture(path);
        Sleep(1000);
    }
}

void bgMp3Music(void *p)
{
    int rnum = 0;
    char *path[200] = { 0 };
    time_t te;
    unsigned int rseed = (unsigned int)time(&te);
    srand(rseed);

    while (1)
    {
        system("taskkill /f /im mediaplayer.exe");
        rnum = rand() % 4;
        sprintf(path, "C:\Users\ZHEN\Desktop\TestMp3\%d.mpe", rnum);
        setBkgroundMusic(path);
        Sleep(10000);
    }
}

void feFontText(void *p)
{
    setFegroundText(50, 50, "i love you!!!");
}

int main01(void)
{
    setDktopBkgroundPicture("C:\Users\ZHEN\Desktop\TestPicture\3.jpg");
    setBkgroundMusic("C:\Users\ZHEN\Desktop\TestMusic\3.mp3");
    setFegroundText(30, 40, "测试文本");

    //02.开启多线程执行某一段儿线程任务代码:
    //  _beginthread(arg1, arg2, arg3);
    //      arg1:线程任务代码
    //      arg2:栈内存尺寸
    //      arg3:线程任务参数
    _beginthread(bgJpgPicture, 0, NULL);
    _beginthread(bgMp3Music, 0, NULL);
    _beginthread(feFontText, 0, NULL);

    system("pause");
}

程序片段(04):位运算.c
内容概要:打印整数原码补码反码

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

//01.位运算使用注意事项:
//  1.位运算只是适用于整数的,不适用于实数
//  2.由于两者的存储方式不一样:
//      整数采取的是补码进行存储
//      实数采取的是阶码进行存储
//02.如何不断的获取一个整数的二进制形式的最高位?
//      举例:原理图
//          10101010010100      
//      &   10000000000000      
//      ----------------------
//          10000000000000
//      步骤:执行体
//          0.不断的判断是否将整数的32位全部移完
//          1.不断的将整数进行左移位(<<)运算
//          2.不断的用1进行按位与(&)运算
//03.如何确定两个二进制位进行加法运算之后的对应的二进制位数是多少?
//      举例:原理图
//          00      0       0^0-->0
//          01      1       0^1-->1
//          10      1       1^0-->1
//          11      0       1^1-->0
//      异或运算符特性
//          可以模拟两个二进制位加法运算之后,所对应的具体二进制位是多少.
//04.正负整数的原码反码补码使用规律:
//  1.内存当中所有的整数都是按照补码进行存储的!
//      所以打印所有整数的补码就等同于直接打印整数的内存存储形式
//  2.正整数的原码反码和补码相同(就是直接的内存存储形式)
//  3.负整数的原码反码和补码不相同:
//      补码:就是直接的内存存储形式,可以进行直接打印
//      反码:就是补码-1
//      原码:补码-->对补码(求反,再+1)-->得到原码(符号位丢失,需要补充符号位)
int main01(void)
{//正整数的原码
    int inum = 0;
    int num1L31 = 1 << 31;

    scanf("%d", &inum);
    for (int i = 1; i <= 32; i++)
    {
        if (inum & num1L31)
            putchar('1');
        else
            putchar('0');

        if (0 == i % 4)
            printf(" ");

        inum <<= 1;
    }

    system("pause");
}

int main02(void)
{//正负整数的原码
    int inum = 0;
    int num1L31 = 1 << 31;

    scanf("%d", &inum);
    if (inum < 0)
    {
        //0000 0000 0000 0110   +6:原码
        //1000  0000     0000 0110   -6:原码
        //1111 1111 1111 1001    -6:反码(取反)
        //1111 1111 1111 1010    -6:补码(加一)
        //0000 0000 0000 0101    -6:补码(再取反)
        //0000 0000 0000 0110    -6:补码(再加一)
        //1000 0000 0000 0110    -6:补码(补符号)
        inum = ~inum + 1;//负数的原码(符号位丢失)
        inum = inum | num1L31;//补充符号位
    }
    for (int i = 1; i <= 32; i++)
    {
        if (inum & num1L31)
            putchar('1');
        else
            putchar('0');
        if (i % 4 == 0)
            printf(" ");
        inum <<= 1;
    }

    system("pause");
}

int main03(void)
{//正负整数的反码
    int inum = 0;
    int num1L31 = 1 << 31;

    scanf("%d", &inum);
    if (inum < 0)
    {
        inum = inum - 1;//负整数的反码
    }
    for (int i = 1; i <= 32; i++)
    {
        if (inum & num1L31)
            putchar('1');
        else
            putchar('0');
        if (0 == i % 4)
            printf(" ");
        inum <<= 1;
    }

    system("pause");
}

程序片段(05):补码原码反码.c
内容概要:补码原码反码转换工具

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

//获取整数(正负整数)的补码(机器存储形式)
void binBCode(int inum, char binStr[33])
{
    int num1L31 = 1 << 31;
    for (int i = 1; i <= 32; i++)
    {//1:进来的哪一次就是1-->1~32-->共32个映射对
        if (inum & num1L31)
            binStr[i - 1] = '1';
        else
            binStr[i - 1] = '0';
        inum <<= 1;
    }
}

//获取整数(正负整数)的反码
void binFCode(int inum, char binStr[33])
{
    int num1L31 = 1 << 31;

    if (inum < 0)
    {
        --inum;
    }
    for (int i = 1; i <= 32; i++)
    {
        if (inum & num1L31)
            binStr[i - 1] = '1';
        else
            binStr[i - 1] = '0';
        inum <<= 1;
    }
}

//数组的副本(实体数据)拷贝浪费内存,所以数组默认采用传址(地址)
//获取整数(正负整数)的原码
void binYCode(int inum, char binStr[33])
{
    int num1L31 = 1 << 31;

    if (inum < 0)
    {
        inum = ~inum + 1;//负整数的原码(丢失符号位)
        inum = inum | num1L31;//(补充符号位)
    }
    for (int i = 1; i <= 32; i++)
    {
        if (inum & num1L31)
            binStr[i - 1] = '1';
        else
            binStr[i - 1] = '0';
        inum <<= 1;
    }
}

int main(void)
{
    int inum = 0;
    char strBinY[33] = { 0 };
    char strBinF[33] = { 0 };
    char strBinB[33] = { 0 };

    scanf("%d", &inum);
    binYCode(inum, strBinY);
    printf("%s 
", strBinY);
    binFCode(inum, strBinF);
    printf("%s 
", strBinF);                                                   
    binBCode(inum, strBinB);
    printf("%s 
", strBinB);


    system("pause");
}

程序片段(06):进制.c
内容概要:进制转换工具

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//01.十进制转任意进制的原理:
//  十进制     二进制     八进制     十六进制
//  10   /2=5   %2=0        %8=2       %16=10
//    5  /2=2   %2=1       %8=1       0xA
//    2  /2=1   %2=0        012
//    1  /2=0   %2=1
//                   1010
//  原理解析完毕:
//02.二进制转任意进制的原理:
//  十进制:每个位进行运算
//  八进制:将二进制当中的每3个二进制位当中一个8进制位处理
//  十六进:将二进制当中的每4个二进制位当中一个16进制位处理
void decToBin(int inum, char binStr[33], int i)
{
    if (0 == inum)
        return;
    binStr[i] = inum % 2;
    decToBin(inum / 2, binStr, ++i);
}

int main(void)
{
    char binStr[33] = { 0 };
    decToBin(10, binStr, 1);
    printf("%s", binStr);

    system("pause");
}

//void to2str(int num, int i, char str2[32])
//{
//      to2str(num / 2,i+1,str2);//位数向前
//      //printf("%d", num % 2);
//      str2[i] = (num % 2) + '0';//字符整数的转换
//  }
//
//}
//void to8str(int num, int i, char str8[32])
//{
//  if (num == 0)
//  {
//      return;
//  }
//  else
//  {
//      to8str(num / 8,i+1,str8);
//      str8[i] = (num % 8) + '0';//字符整数的转换
//  }
//}
//
//void to16str(int num, int i, char str16[32])
//{
//  if (num == 0)
//  {
//      return;
//  }
//  else
//  {
//
//      to16str(num / 16,i+1,str16);
//      //printf("%x", num % 16);
//      if (num % 16<10)
//      {
//          str16[i] = (num % 16) + '0';//字符整数的转换
//      } 
//      else
//      {
//          //10,11,12,13,14,15
//          str16[i] = (num % 16) - 10 + 'A';
//      }
//
//  
//      //'A' 10
//  }
//
//}
//
//void main()
//{
//
//  int num = 0;
//  char str2[32] = { 0 };
//  char str8[32] = {0};
//  char str16[32] = {0};
//
//
//  scanf("%d", &num);
//
//
//  to2str(num,0,str2);
//  _strrev(str2);
//  printf("
%s", str2);
//
//
//  to8str(num, 0, str8);
//  _strrev(str8);
//  printf("
%s", str8);
//
//  to16str(num, 0, str16);
//  _strrev(str16);
//  printf("
%s", str16);
//
//
//  getchar();
//  getchar();
//}
//
//void to2(int num)
//{
//  if (num==0)
//  {
//      return;
//  } 
//  else
//  {
//
//      to2(num / 2);
//      printf("%d", num % 2);
//  }
//
//}
//
//void to8(int num)
//{
//  if (num == 0)
//  {
//      return;
//  }
//  else
//  {
//
//      to8(num / 8);
//      printf("%d", num % 8);
//  }
//
//}
//
//void to16(int num)
//{
//  if (num == 0)
//  {
//      return;
//  }
//  else
//  {
/**重点内容**/
//      to16(num / 16);
//      printf("%x", num % 16);
//  }
//
//}
//
//
//void main1()
//{
//  int num = 0;
//  scanf("%d", &num);
//  to2(num);
//  printf("
");
//  to8(num);
//  printf("
");
//  to16(num);
//  getchar();
//  getchar();
//}

程序片段(07):add.c
内容概要:时间编程

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

//01.register&volatile关键的使用:
//  1.使用意义不同:
//      register:标识寄存器变量
//      volatile:标识内存变量,强制读取内存变量
//      特点:register寄存器变量运算较快于volatile内存变量
//          因为其减少了不必要的读取内存时间(读取过程时间)
//  2.编译器的优化特点不同:
//      如果一个内存变量被频繁的进行使用,那么:
//      VC编译器:会自动进行优化操作
//      GCC编译器:不会进行自动优化操作
//      特点:register对GCC有效,对VC可能无效,VC不听话
//  3.内容总结:
//      (1).在程序运行过程当中,根据需要到内存中的相应变量存储
//          单元中进行调用,如果一个变量在程序中频繁使用,例如循环变量
//          那么,系统就必须多次访问该内存中的变量单元,影响程序的执行效率
//          因此,CCPP语言当中还定义了一种变量,不是保存在内存之中的变量
//          而是直接存储于CPU内部的寄存器当中,这种变量被称之为寄存器变量
//      (2).寄存器变量的定义形式为:
//          register 类型标识符 变量名;
//      (3).寄存器与机器硬件密切相关,不同类型的计算机,寄存器的数目是不一样的
//          通常为2到3个,对于在一个函数中说明的多余2到3个的寄存器变量,C编译
//          程序会自动的将寄存器变量变为自动变量
//      (4).寄存器说明符只能用于说明函数中的局部变量和函数中的形参变量,因此
//          不允许将全局变量或者静态变量说明为"register"形式.
//              VC会自动进行寄存器变量的优化,不可以对寄存器变量进行取内存地址操作
//              GCC需要手动指定,MINGW是GCC编译器移植到Windows的版本
//                  C语言寄存器变量不可以进行取内存地址操作,C++可以,因为C++会
//                  在内存当中给C语言寄存器变量保存一个副本
//  4.特殊特点总结:
//      某些情况之下的变量必须强制读内存,因为寄存器变量如果随时都在变化,而多线程
//          情况之下每条线程访问的都是同一个内存变量,如果迟迟不进行读取内存的操作
//          那么,寄存器变量的变量不会被映射到内存变量当中,导致数据变化不能及时生效
int main01(void)
{
    time_t start, end;
    time(&start);//获取开始时刻的时间

    //进行浮点数运算的模拟
    volatile double result = 0;
    //VC会自动将频繁使用的内存变量优化为寄存器变量
    for (volatile double i = 0; i < 100000000; i++)
    {
        result += i*1.0;
    }

    time(&end);//获取结束时刻的时间
    printf("消耗的时间为:%f 
", difftime(end, start));
}

int main02(void)
{
    time_t start, end;
    time(&start);

    register double result = 0;
    for(register double i = 0; i < 100000000; i++)
    {
        result += i *1.0;
    }

    time(&end);
    printf("消耗时间为:%f 
", difftime(end, start));
}

//02.测试寄存器变量和内存变量的最佳方式:是通过相同阶段的CPU进行测试才能最准确:
//      原理:让一条线程通过一条执行流处理内存变量和寄存器变量-->这样的误差最小
//          免得CPU运算赫兹忽高忽低
int main03(void)
{
    main01();
    main02();//同样的代码段儿被加载进内存,如果执行相同的操作CPU也会进行优化操作

    system("pause");
}

程序片段(08):main.c
内容概要:TestTime

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main01(void)
{
  time_t start, end;
  time(&start);

  volatile double result = 0.0;
  volatile int i;//GCC当中的循环变量必须申明在for循环外部
  for (i = 0; i < 100000000; i++)
  {//没有优化double是内存变量,13s;采取优化double是寄存器变量,3s
    result+=i*1.0;
  }

  time(&end);
  printf("消耗时间为:%f 
", difftime(end, start));
}

int main02(void)
{
  time_t start, end;
  time(&start);

  register double result = 0.0;
  register int i;
  for (i = 1; i < 100000000; i++)
  {
    result += i*1.0;
  }

  time(&end);
  printf("消耗时间为:%f 
", difftime(end, start));
}

int main(void)
{
  main01();
  main02();
}

程序片段(09):run.c+test.c
内容概要:dll调用

///run.c
#include <Windows.h>

_declspec(dllexport)  void go()
{
    MessageBoxA(0, "World", "Hello", 0);
}

_declspec(dllexport) int add(int a, int b)
{
    return a + b;
}

///test.c
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>

//01.如何获取函数指针类型?
//  将函数声明头的函数名称替换为(*函数指针名称)
//  举例:void fp();-->void (*fp)();
//      fp的类型就是void (*)();
//  void go()---->void (*fp1)();
// int add(int a, int b)---->int (*fp2)(int a, int b);
//02.如何使用动态库?
//  动态库加载LoadLibraryA();
//  动态库函数GetProcAddress();
//  动态库释放FreeLibrary();

int main01(void)
{
    HMODULE hmod = LoadLibraryA("01.DLL调用.dll");//动态库加载
    if (NULL == hmod)
    {
        system("echo error load! 
");
    }
    void(*fp1)() = (void(*)())GetProcAddress(hmod, "go");
    int(*fp2)(int a, int b) = (int(*)(int a, int b))GetProcAddress(hmod, "add");
    if (NULL == fp1 || NULL == fp2)
    {
        system("echo error find! 
");
    }
    else
    {
        fp1();
        printf("%d 
", fp2(10, 20));
    }
    FreeLibrary(hmod);//动态库释放

    system("pause");
}

程序片段(10):add.c
内容概要:计算器

#include <stdio.h>
#include <stdlib.h>

//01.规律说明:
//  100%7=2
//      100求余7之后为2
//  100-(100/7)*7=2
//      100减去整除数*7=2
//  5%3=2
//  73%4=1  73%5=3
//  74%4=2  74%5=4
//  75%4=3  75%5=0
//      73---->0100 1001
//  %     4---->0000 0100
//------------------------
//        1         0000 0001

//      74---->0100 1010
//  %     4---->0000 0100
//------------------------
//        2         0000 0010

//10-->2
//100-->4
//1000-->8
//10000---16

//      73---->0100 1001
//  %   5---->0000 0101
//------------------------
//        3---->0000 0011
int main(void)
{
    unsigned int num = 73;//余数
    printf("%d 
", num - (num & ~3));

    system("pause");
}

////11  0  1
////10  1  0
////01  1  0
////00  0  0
//
////0011  3      15
////0101  5      16
//             //21  +10
////0010  进位
//
////0110   ^ 6
//
////1000  8
//
//int add(int a,int b)
//{
//  int wei = 0;
//  int jinwei = 0;
//
//  do 
//  {
//      wei = a^b;//处理位加法
//      jinwei = (a&b) << 1;//进位
//
//      a = wei;//没有进位的加法
//      b = jinwei;//进位
//  } while (b!=0);
//      return a;
//}
//
//
//int  dadd(int a, int b)
//{
//  if (b==0)
//  {
//      return a;
//  } 
//  else
//  {
//      int wei = a^b;
//      int jinwei = (a&b) << 1;
//      dadd(wei, jinwei);
//  }
//}
//
//
//void main1()
//{
//  printf("%d", dadd(113, 15));
//  getchar();
//}

程序片段(11):go.c
内容概要:最小公倍数最大公约数

#include <stdio.h>
#include <stdlib.h>

//01.最小公倍数和最大公约数:
//  条件:现有两个整数num1和num2
//  那么:num1*num2=minGB*maxGY;
//  编程:
//      方式一:
//          假设num1<num2
//          最小公倍数:
//              从两个整数当中较大的那个整数开始向大数遍历
//              如果(0==num/num2)&&(0==num/num1)
//          最大公约数:
//              从两个整数当中较小的那个整数开始向小数遍历
//              如果(0==num1/num)&&(0==num2/num)
//      方式二:
//          利用:num1*num2=minGB*maxGY

//02.举例说明特点:
//  num1=10;num2=25;
//      10      25      50-->minGB
//      10      25      5--->maxGY
//  原理:辗转相除法
//      10 % 25 = 10;   //被除数/除数=余数
//      25 % 10 = 5;    //除数/余数
//      10 % 5 = 0;     //除数/余数
int maxGY(int i, int j)
{
    if (0 == i % j)
        return j;//跳出
    else
        return maxGY(j, i % j);//递归
}

int main01(void)
{
    int a = 25;
    int b = 110;

    printf("%d, %d 
", maxGY(25, 110), 25 * 110 / maxGY(25, 110));

    system("pause");
}

程序片段(12):猜数字.c
内容概要:猜数字

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
#include <time.h>

//01.健壮的应用程序当中经常使用abort提示错误:
//  1.相当于其它语言当中的异常处理机制模拟
//  2.区分编译错误和运行时异常
//      编译错误:代码本身存在语法错误
//      运行时异常:实在编译没有错误的情况之下发生的
int main01(void)
{
    int a, b;

    scanf("%d%d", &a, &b);
    if (b == 0)
    {
        abort();//提示错误
    }
    else
    {
        int c = a / b;
    }

    system("pause");
}

int main02(void)
{
    time_t te;
    unsigned int rseed = (unsigned int)time(&te);
    srand(rseed);
    int rnum = rand() % 100 + 1;//1~100
    int gnum = 0;

    while (1)
    {
        scanf("%d", &gnum);
        if (rnum > gnum)
            puts("小了");
        else if (rnum < gnum)
            puts("大了");
        else
        {
            puts("小伙子才对了! ");
            break;
        }
    }

    //这后面的代码需要放置于多线程当中运行才行
    int i = 0;//否则限时功能不会生效
    while (1)
    {

        Sleep(1000);
        ++i;
        if (5 == i)
            //abort();//提示错误
            //break;//终止循环
            exit(0);//结束程序
    }

    system("pause");
}

程序片段(13):type.cpp
内容概要:typedef

#include <stdio.h>
#include <stdlib.h>

#include <iostream>//CPP输入输入
using namespace std;//使用名称空间

//01.给任意类型取别名的方式:typedef使用
//  规律:在声明变量的基础之上前置typedef关键字
//      为已经存在的类型另起一个别名(原名和别名都有进行使用)
//      只不过typedef具有简化类型名称的作用,而且某些地方必须
//      为类型定义别名,否则无法进行后续操作
typedef unsigned short int USI;
typedef unsigned long int ULI;

//02.C语言重要知识点概括:
//  补码-->递归-->逻辑
//  数组-->二维数组地图-->排序
//  指针-->外挂(函数指针)
//  字符串-->结构体-->内存四区-->文件
//03.CPP语言当中获取类型的方式:
//  typeid(var).name();
//  根据变量名称获取变量的所属类型;
//  并且将该数据类型以字符串的形式打印出来
int main01(void)
{
    unsigned long int num = 10;
    ULI ulinum = 10;
    printf("%s 
", typeid(ulinum).name());//typedef(x).name();根据变量名称获取变量所属的数据类型(字符串表现形式)

    system("pause");
}