程序片段(01):hanoi.c+汉诺塔.c

内容概要:汉诺塔

  1. ///hanoi.c
  2. #define _CRT_SECURE_NO_WARNINGS
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. int main01(void)
  6. {
  7. //int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };//一维数组,代码块儿初始化方式(指定)
  8. //for (int i = 0; i < 10; i++)
  9. //{
  10. // printf("%5d", a[i]);//数组的索引都是从0开始的
  11. //}
  12. int a[10][3] = { 0 };//二维数组,代码块儿初始化方式(统一)
  13. for (int i = 0; i < 10; i++)
  14. {//行
  15. for (int j = 0; j < 3; j++)
  16. {//列
  17. printf("%5d", a[i][j]);
  18. }
  19. printf("\n");
  20. }
  21. system("pause");
  22. }
  23. int main02(void)
  24. {
  25. int n = 0;
  26. int a[10][3] = { 0 };//二维数组,代码块儿初始化方式(统一)
  27. scanf("%d", &n);
  28. for (int i = 0; i < n; i++)//控制
  29. {//-1的原因是因为,索引最大为9,索引最大,赋值却最小-->索引逆向赋值i=0-->index=10-1-i-->sequence=10-0
  30. a[10 - 1 - i][0] = n - i;//布局
  31. }
  32. for (int i = 0; i < 10; i++)//控制行
  33. {
  34. for (int j = 0; j < 3; j++)//控制列
  35. {
  36. printf("%5d", a[i][j]);
  37. }
  38. printf("\n");
  39. }
  40. system("pause");
  41. }
  1. ///汉诺塔.c
  2. #define _CRT_SECURE_NO_WARNINGS
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. int hanoiTower[10][3] = { 0 };//二维数组,代码块儿初始化(统一形式)
  6. //01.将二维数组的操作采用图形化方式模拟出来:
  7. // 1.设计操作流程:
  8. // 汉诺塔逻辑实现-->显示汉诺塔流程-->补充函数说明
  9. // 2.所涉及到的设计模式:
  10. // MVC设计模式(简化版本)
  11. //汉诺塔辅助程序
  12. void movehanoiTower(char x, char y);//移动汉诺塔的过程当中,保留移动痕迹到二维数组(逻辑&数据-->链接起来)
  13. //汉诺塔逻辑实现
  14. void hanoiTowerLogic(unsigned int n, char i, char j, char k);//汉诺塔主逻辑
  15. //显示汉诺塔流程
  16. void showHanoiTower(int hanoiTower[10][3]);//显示汉诺塔数据
  17. void moveHanoiTower(char x, char y)
  18. {
  19. //实质:就是数组当中两个位置的字符数据之间的交换
  20. //hanoiTower[imove][m]<--->hanoiTower[jmove][n];
  21. int m = x - 65;//字符形式转换为整数相差形式(间接记忆字符)
  22. int n = y - 65;
  23. int imove = -1;
  24. int jmove = -1;
  25. for (int i = 0; i < 10; i++)
  26. {
  27. if (0 != hanoiTower[i][m])
  28. {//检索第一个不为0的
  29. imove = i;
  30. break;
  31. }
  32. }
  33. if (0 == hanoiTower[9][n])
  34. {
  35. jmove = 9;
  36. }
  37. else
  38. {
  39. jmove = 10;
  40. for (int i = 0; i < 10; i++)
  41. {
  42. if (0 != hanoiTower[i][n])
  43. {
  44. jmove = i;
  45. break;
  46. }
  47. }
  48. jmove -= 1;
  49. }
  50. //将用于间接记忆字符的整数形式进行交换
  51. int temp = hanoiTower[imove][m];
  52. hanoiTower[imove][m] = hanoiTower[jmove][n];
  53. hanoiTower[jmove][m] = temp;
  54. }
  55. void hanoiTowerLogic(unsigned int n, char i, char j, char k)
  56. {
  57. if (0 == n)
  58. return;
  59. else if (1 == n)
  60. {
  61. //printf("%c-->%c \n", i, k);
  62. moveHanoiTower(i, k);
  63. showHanoiTower(hanoiTower);
  64. return;
  65. }
  66. hanoiTowerLogic(n - 1, i, k, j);
  67. //printf("%c-->%c \n", i, k);
  68. moveHanoiTower(i, k);
  69. showHanoiTower(hanoiTower);
  70. hanoiTowerLogic(n - 1, j, i, k);
  71. }
  72. void showHanoiTower(int hanoiTower[10][3])
  73. {
  74. printf("%5c%5c%5c \n", 'A', 'B', 'C');
  75. printf("---------------\n");
  76. for (int i = 0; i < 10; i++)
  77. {
  78. for (int j = 0; j < 3; j++)
  79. {
  80. printf("%5d", hanoiTower[i][j]);
  81. }
  82. printf("\n");
  83. }
  84. }
  85. int main(void)
  86. {
  87. int n = 0;
  88. scanf("%d", &n);
  89. for (int i = 0; i < n; i++)//控制
  90. {
  91. hanoiTower[n - 1 - i][0] = n - i;//布局
  92. }
  93. hanoiTowerLogic(n, 'A', 'B', 'C');
  94. showHanoiTower(hanoiTower);
  95. system("pause");
  96. }

程序片段(02):QQ.c

内容概要:调戏妹子上QQ

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <Windows.h>
  4. #include <time.h>
  5. int main01(void)
  6. {
  7. //HWND win = FindWindowA("TXGuiFoundation", "QQ");
  8. HWND win = FindWindowA("StandardFrame", "阿里旺旺");
  9. int i = 0;
  10. POINT point;
  11. point.x = point.y = 0;
  12. time_t te;
  13. unsigned int seed = (unsigned int)time(&te);
  14. srand(seed);
  15. int rnum = 0;
  16. while (1)
  17. {
  18. GetCursorPos(&point);
  19. rnum = rand() % 4;
  20. switch (rnum)
  21. {
  22. case 0:
  23. SetWindowPos(win, NULL, point.x - 500, point.y - 500, 0, 0, 1);//1:禁止修改窗体尺寸
  24. break;
  25. case 1:
  26. SetWindowPos(win, NULL, point.x + 500, point.y - 500, 0, 0, 1);
  27. break;
  28. case 2:
  29. SetWindowPos(win, NULL, point.x - 500, point.y + 500, 0, 0, 1);
  30. break;
  31. case 3:
  32. SetWindowPos(win, NULL, point.x + 500, point.y + 500, 0, 0, 1);
  33. break;
  34. }
  35. Sleep(1000);
  36. ++i;
  37. if (1000 == i)
  38. //break;//跳出
  39. return;//结束
  40. }
  41. system("taskkill /f /im iexplore.exe");
  42. MessageBoxB(0, "发现病毒", "提示信息", 0);
  43. system("pause");
  44. }

程序片段(03):模块.c

内容概要:鬼哭神嚎

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <Windows.h>
  6. #include <time.h>
  7. #include <process.h>//多线程
  8. //01.如何将一个控制台应用程序转换成为Windows应用程序:
  9. // 控制台-->Windows:实质就是去掉黑窗口
  10. // 控制台应用程序-->链接为-->Windows应用程序(可有Windows窗口,也可以没有)
  11. #pragma comment (linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")
  12. void setDktopBkgroundPicture(char *path)
  13. {
  14. SystemParametersInfoA(20, 0, path, 3);
  15. }
  16. void setBkgroundMusic(char *path)
  17. {
  18. ShellExecuteA(0, "open", path, 0, 0, 0);//0:代表隐藏(最后一个)
  19. }
  20. void setFegroundText(int x, int y, char * text)
  21. {
  22. HWND win = GetDesktopWindow();//获取系统窗体(当前程序运行时所显示的整个窗体)
  23. HDC dc = GetWindowDC(win);//获取设备的上下文(以待用于进行设置)
  24. SetTextColor(dc, RGB(255, 0, 0));
  25. SetBkColor(dc, RGB(0, 0, 255));
  26. while (1)
  27. {
  28. TextOutA(dc, 300, 400, text, strlen(text));//显示文本
  29. Sleep(2000);
  30. }
  31. }
  32. void bgJpgPicture(void *p)
  33. {
  34. int rnum = 0;
  35. char *path[200] = { 0 };
  36. time_t te;
  37. unsigned int seed = (unsigned int)time(&te);
  38. srand(seed);
  39. while (1)
  40. {
  41. rnum = rand() % 9;
  42. sprintf(path, "C:\\Users\\ZHEN\\Desktop\\TestPictore\\%d.jpg", rnum);
  43. setDktopBkgroundPicture(path);
  44. Sleep(1000);
  45. }
  46. }
  47. void bgMp3Music(void *p)
  48. {
  49. int rnum = 0;
  50. char *path[200] = { 0 };
  51. time_t te;
  52. unsigned int rseed = (unsigned int)time(&te);
  53. srand(rseed);
  54. while (1)
  55. {
  56. system("taskkill /f /im mediaplayer.exe");
  57. rnum = rand() % 4;
  58. sprintf(path, "C:\\Users\\ZHEN\\Desktop\\TestMp3\\%d.mpe", rnum);
  59. setBkgroundMusic(path);
  60. Sleep(10000);
  61. }
  62. }
  63. void feFontText(void *p)
  64. {
  65. setFegroundText(50, 50, "i love you!!!");
  66. }
  67. int main01(void)
  68. {
  69. setDktopBkgroundPicture("C:\\Users\\ZHEN\\Desktop\\TestPicture\\3.jpg");
  70. setBkgroundMusic("C:\\Users\\ZHEN\\Desktop\\TestMusic\\3.mp3");
  71. setFegroundText(30, 40, "测试文本");
  72. //02.开启多线程执行某一段儿线程任务代码:
  73. // _beginthread(arg1, arg2, arg3);
  74. // arg1:线程任务代码
  75. // arg2:栈内存尺寸
  76. // arg3:线程任务参数
  77. _beginthread(bgJpgPicture, 0, NULL);
  78. _beginthread(bgMp3Music, 0, NULL);
  79. _beginthread(feFontText, 0, NULL);
  80. system("pause");
  81. }

程序片段(04):位运算.c

内容概要:打印整数原码补码反码

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. //01.位运算使用注意事项:
  5. // 1.位运算只是适用于整数的,不适用于实数
  6. // 2.由于两者的存储方式不一样:
  7. // 整数采取的是补码进行存储
  8. // 实数采取的是阶码进行存储
  9. //02.如何不断的获取一个整数的二进制形式的最高位?
  10. // 举例:原理图
  11. // 10101010010100
  12. // & 10000000000000
  13. // ----------------------
  14. // 10000000000000
  15. // 步骤:执行体
  16. // 0.不断的判断是否将整数的32位全部移完
  17. // 1.不断的将整数进行左移位(<<)运算
  18. // 2.不断的用1进行按位与(&)运算
  19. //03.如何确定两个二进制位进行加法运算之后的对应的二进制位数是多少?
  20. // 举例:原理图
  21. // 00 0 0^0-->0
  22. // 01 1 0^1-->1
  23. // 10 1 1^0-->1
  24. // 11 0 1^1-->0
  25. // 异或运算符特性
  26. // 可以模拟两个二进制位加法运算之后,所对应的具体二进制位是多少.
  27. //04.正负整数的原码反码补码使用规律:
  28. // 1.内存当中所有的整数都是按照补码进行存储的!
  29. // 所以打印所有整数的补码就等同于直接打印整数的内存存储形式
  30. // 2.正整数的原码反码和补码相同(就是直接的内存存储形式)
  31. // 3.负整数的原码反码和补码不相同:
  32. // 补码:就是直接的内存存储形式,可以进行直接打印
  33. // 反码:就是补码-1
  34. // 原码:补码-->对补码(求反,再+1)-->得到原码(符号位丢失,需要补充符号位)
  35. int main01(void)
  36. {//正整数的原码
  37. int inum = 0;
  38. int num1L31 = 1 << 31;
  39. scanf("%d", &inum);
  40. for (int i = 1; i <= 32; i++)
  41. {
  42. if (inum & num1L31)
  43. putchar('1');
  44. else
  45. putchar('0');
  46. if (0 == i % 4)
  47. printf(" ");
  48. inum <<= 1;
  49. }
  50. system("pause");
  51. }
  52. int main02(void)
  53. {//正负整数的原码
  54. int inum = 0;
  55. int num1L31 = 1 << 31;
  56. scanf("%d", &inum);
  57. if (inum < 0)
  58. {
  59. //0000 0000 0000 0110 +6:原码
  60. //1000 0000 0000 0110 -6:原码
  61. //1111 1111 1111 1001 -6:反码(取反)
  62. //1111 1111 1111 1010 -6:补码(加一)
  63. //0000 0000 0000 0101 -6:补码(再取反)
  64. //0000 0000 0000 0110 -6:补码(再加一)
  65. //1000 0000 0000 0110 -6:补码(补符号)
  66. inum = ~inum + 1;//负数的原码(符号位丢失)
  67. inum = inum | num1L31;//补充符号位
  68. }
  69. for (int i = 1; i <= 32; i++)
  70. {
  71. if (inum & num1L31)
  72. putchar('1');
  73. else
  74. putchar('0');
  75. if (i % 4 == 0)
  76. printf(" ");
  77. inum <<= 1;
  78. }
  79. system("pause");
  80. }
  81. int main03(void)
  82. {//正负整数的反码
  83. int inum = 0;
  84. int num1L31 = 1 << 31;
  85. scanf("%d", &inum);
  86. if (inum < 0)
  87. {
  88. inum = inum - 1;//负整数的反码
  89. }
  90. for (int i = 1; i <= 32; i++)
  91. {
  92. if (inum & num1L31)
  93. putchar('1');
  94. else
  95. putchar('0');
  96. if (0 == i % 4)
  97. printf(" ");
  98. inum <<= 1;
  99. }
  100. system("pause");
  101. }

程序片段(05):补码原码反码.c

内容概要:补码原码反码转换工具

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. //获取整数(正负整数)的补码(机器存储形式)
  5. void binBCode(int inum, char binStr[33])
  6. {
  7. int num1L31 = 1 << 31;
  8. for (int i = 1; i <= 32; i++)
  9. {//1:进来的哪一次就是1-->1~32-->共32个映射对
  10. if (inum & num1L31)
  11. binStr[i - 1] = '1';
  12. else
  13. binStr[i - 1] = '0';
  14. inum <<= 1;
  15. }
  16. }
  17. //获取整数(正负整数)的反码
  18. void binFCode(int inum, char binStr[33])
  19. {
  20. int num1L31 = 1 << 31;
  21. if (inum < 0)
  22. {
  23. --inum;
  24. }
  25. for (int i = 1; i <= 32; i++)
  26. {
  27. if (inum & num1L31)
  28. binStr[i - 1] = '1';
  29. else
  30. binStr[i - 1] = '0';
  31. inum <<= 1;
  32. }
  33. }
  34. //数组的副本(实体数据)拷贝浪费内存,所以数组默认采用传址(地址)
  35. //获取整数(正负整数)的原码
  36. void binYCode(int inum, char binStr[33])
  37. {
  38. int num1L31 = 1 << 31;
  39. if (inum < 0)
  40. {
  41. inum = ~inum + 1;//负整数的原码(丢失符号位)
  42. inum = inum | num1L31;//(补充符号位)
  43. }
  44. for (int i = 1; i <= 32; i++)
  45. {
  46. if (inum & num1L31)
  47. binStr[i - 1] = '1';
  48. else
  49. binStr[i - 1] = '0';
  50. inum <<= 1;
  51. }
  52. }
  53. int main(void)
  54. {
  55. int inum = 0;
  56. char strBinY[33] = { 0 };
  57. char strBinF[33] = { 0 };
  58. char strBinB[33] = { 0 };
  59. scanf("%d", &inum);
  60. binYCode(inum, strBinY);
  61. printf("%s \n", strBinY);
  62. binFCode(inum, strBinF);
  63. printf("%s \n", strBinF);
  64. binBCode(inum, strBinB);
  65. printf("%s \n", strBinB);
  66. system("pause");
  67. }

程序片段(06):进制.c

内容概要:进制转换工具

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. //01.十进制转任意进制的原理:
  6. // 十进制 二进制 八进制 十六进制
  7. // 10 /2=5 %2=0 %8=2 %16=10
  8. // 5 /2=2 %2=1 %8=1 0xA
  9. // 2 /2=1 %2=0 012
  10. // 1 /2=0 %2=1
  11. // 1010
  12. // 原理解析完毕:
  13. //02.二进制转任意进制的原理:
  14. // 十进制:每个位进行运算
  15. // 八进制:将二进制当中的每3个二进制位当中一个8进制位处理
  16. // 十六进:将二进制当中的每4个二进制位当中一个16进制位处理
  17. void decToBin(int inum, char binStr[33], int i)
  18. {
  19. if (0 == inum)
  20. return;
  21. binStr[i] = inum % 2;
  22. decToBin(inum / 2, binStr, ++i);
  23. }
  24. int main(void)
  25. {
  26. char binStr[33] = { 0 };
  27. decToBin(10, binStr, 1);
  28. printf("%s", binStr);
  29. system("pause");
  30. }
  31. //void to2str(int num, int i, char str2[32])
  32. //{
  33. // to2str(num / 2,i+1,str2);//位数向前
  34. // //printf("%d", num % 2);
  35. // str2[i] = (num % 2) + '0';//字符整数的转换
  36. // }
  37. //
  38. //}
  39. //void to8str(int num, int i, char str8[32])
  40. //{
  41. // if (num == 0)
  42. // {
  43. // return;
  44. // }
  45. // else
  46. // {
  47. // to8str(num / 8,i+1,str8);
  48. // str8[i] = (num % 8) + '0';//字符整数的转换
  49. // }
  50. //}
  51. //
  52. //void to16str(int num, int i, char str16[32])
  53. //{
  54. // if (num == 0)
  55. // {
  56. // return;
  57. // }
  58. // else
  59. // {
  60. //
  61. // to16str(num / 16,i+1,str16);
  62. // //printf("%x", num % 16);
  63. // if (num % 16<10)
  64. // {
  65. // str16[i] = (num % 16) + '0';//字符整数的转换
  66. // }
  67. // else
  68. // {
  69. // //10,11,12,13,14,15
  70. // str16[i] = (num % 16) - 10 + 'A';
  71. // }
  72. //
  73. //
  74. // //'A' 10
  75. // }
  76. //
  77. //}
  78. //
  79. //void main()
  80. //{
  81. //
  82. // int num = 0;
  83. // char str2[32] = { 0 };
  84. // char str8[32] = {0};
  85. // char str16[32] = {0};
  86. //
  87. //
  88. // scanf("%d", &num);
  89. //
  90. //
  91. // to2str(num,0,str2);
  92. // _strrev(str2);
  93. // printf("\n%s", str2);
  94. //
  95. //
  96. // to8str(num, 0, str8);
  97. // _strrev(str8);
  98. // printf("\n%s", str8);
  99. //
  100. // to16str(num, 0, str16);
  101. // _strrev(str16);
  102. // printf("\n%s", str16);
  103. //
  104. //
  105. // getchar();
  106. // getchar();
  107. //}
  108. //
  109. //void to2(int num)
  110. //{
  111. // if (num==0)
  112. // {
  113. // return;
  114. // }
  115. // else
  116. // {
  117. //
  118. // to2(num / 2);
  119. // printf("%d", num % 2);
  120. // }
  121. //
  122. //}
  123. //
  124. //void to8(int num)
  125. //{
  126. // if (num == 0)
  127. // {
  128. // return;
  129. // }
  130. // else
  131. // {
  132. //
  133. // to8(num / 8);
  134. // printf("%d", num % 8);
  135. // }
  136. //
  137. //}
  138. //
  139. //void to16(int num)
  140. //{
  141. // if (num == 0)
  142. // {
  143. // return;
  144. // }
  145. // else
  146. // {
  147. /**重点内容**/
  148. // to16(num / 16);
  149. // printf("%x", num % 16);
  150. // }
  151. //
  152. //}
  153. //
  154. //
  155. //void main1()
  156. //{
  157. // int num = 0;
  158. // scanf("%d", &num);
  159. // to2(num);
  160. // printf("\n");
  161. // to8(num);
  162. // printf("\n");
  163. // to16(num);
  164. // getchar();
  165. // getchar();
  166. //}

程序片段(07):add.c

内容概要:时间编程

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. //01.register&volatile关键的使用:
  5. // 1.使用意义不同:
  6. // register:标识寄存器变量
  7. // volatile:标识内存变量,强制读取内存变量
  8. // 特点:register寄存器变量运算较快于volatile内存变量
  9. // 因为其减少了不必要的读取内存时间(读取过程时间)
  10. // 2.编译器的优化特点不同:
  11. // 如果一个内存变量被频繁的进行使用,那么:
  12. // VC编译器:会自动进行优化操作
  13. // GCC编译器:不会进行自动优化操作
  14. // 特点:register对GCC有效,对VC可能无效,VC不听话
  15. // 3.内容总结:
  16. // (1).在程序运行过程当中,根据需要到内存中的相应变量存储
  17. // 单元中进行调用,如果一个变量在程序中频繁使用,例如循环变量
  18. // 那么,系统就必须多次访问该内存中的变量单元,影响程序的执行效率
  19. // 因此,CCPP语言当中还定义了一种变量,不是保存在内存之中的变量
  20. // 而是直接存储于CPU内部的寄存器当中,这种变量被称之为寄存器变量
  21. // (2).寄存器变量的定义形式为:
  22. // register 类型标识符 变量名;
  23. // (3).寄存器与机器硬件密切相关,不同类型的计算机,寄存器的数目是不一样的
  24. // 通常为2到3个,对于在一个函数中说明的多余2到3个的寄存器变量,C编译
  25. // 程序会自动的将寄存器变量变为自动变量
  26. // (4).寄存器说明符只能用于说明函数中的局部变量和函数中的形参变量,因此
  27. // 不允许将全局变量或者静态变量说明为"register"形式.
  28. // VC会自动进行寄存器变量的优化,不可以对寄存器变量进行取内存地址操作
  29. // GCC需要手动指定,MINGW是GCC编译器移植到Windows的版本
  30. // C语言寄存器变量不可以进行取内存地址操作,C++可以,因为C++会
  31. // 在内存当中给C语言寄存器变量保存一个副本
  32. // 4.特殊特点总结:
  33. // 某些情况之下的变量必须强制读内存,因为寄存器变量如果随时都在变化,而多线程
  34. // 情况之下每条线程访问的都是同一个内存变量,如果迟迟不进行读取内存的操作
  35. // 那么,寄存器变量的变量不会被映射到内存变量当中,导致数据变化不能及时生效
  36. int main01(void)
  37. {
  38. time_t start, end;
  39. time(&start);//获取开始时刻的时间
  40. //进行浮点数运算的模拟
  41. volatile double result = 0;
  42. //VC会自动将频繁使用的内存变量优化为寄存器变量
  43. for (volatile double i = 0; i < 100000000; i++)
  44. {
  45. result += i*1.0;
  46. }
  47. time(&end);//获取结束时刻的时间
  48. printf("消耗的时间为:%f \n", difftime(end, start));
  49. }
  50. int main02(void)
  51. {
  52. time_t start, end;
  53. time(&start);
  54. register double result = 0;
  55. for(register double i = 0; i < 100000000; i++)
  56. {
  57. result += i *1.0;
  58. }
  59. time(&end);
  60. printf("消耗时间为:%f \n", difftime(end, start));
  61. }
  62. //02.测试寄存器变量和内存变量的最佳方式:是通过相同阶段的CPU进行测试才能最准确:
  63. // 原理:让一条线程通过一条执行流处理内存变量和寄存器变量-->这样的误差最小
  64. // 免得CPU运算赫兹忽高忽低
  65. int main03(void)
  66. {
  67. main01();
  68. main02();//同样的代码段儿被加载进内存,如果执行相同的操作CPU也会进行优化操作
  69. system("pause");
  70. }

程序片段(08):main.c

内容概要:TestTime

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. int main01(void)
  5. {
  6. time_t start, end;
  7. time(&start);
  8. volatile double result = 0.0;
  9. volatile int i;//GCC当中的循环变量必须申明在for循环外部
  10. for (i = 0; i < 100000000; i++)
  11. {//没有优化double是内存变量,13s;采取优化double是寄存器变量,3s
  12. result+=i*1.0;
  13. }
  14. time(&end);
  15. printf("消耗时间为:%f \n", difftime(end, start));
  16. }
  17. int main02(void)
  18. {
  19. time_t start, end;
  20. time(&start);
  21. register double result = 0.0;
  22. register int i;
  23. for (i = 1; i < 100000000; i++)
  24. {
  25. result += i*1.0;
  26. }
  27. time(&end);
  28. printf("消耗时间为:%f \n", difftime(end, start));
  29. }
  30. int main(void)
  31. {
  32. main01();
  33. main02();
  34. }

程序片段(09):run.c+test.c

内容概要:dll调用

  1. ///run.c
  2. #include <Windows.h>
  3. _declspec(dllexport) void go()
  4. {
  5. MessageBoxA(0, "World", "Hello", 0);
  6. }
  7. _declspec(dllexport) int add(int a, int b)
  8. {
  9. return a + b;
  10. }
  1. ///test.c
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <Windows.h>
  5. //01.如何获取函数指针类型?
  6. // 将函数声明头的函数名称替换为(*函数指针名称)
  7. // 举例:void fp();-->void (*fp)();
  8. // fp的类型就是void (*)();
  9. // void go()---->void (*fp1)();
  10. // int add(int a, int b)---->int (*fp2)(int a, int b);
  11. //02.如何使用动态库?
  12. // 动态库加载LoadLibraryA();
  13. // 动态库函数GetProcAddress();
  14. // 动态库释放FreeLibrary();
  15. int main01(void)
  16. {
  17. HMODULE hmod = LoadLibraryA("01.DLL调用.dll");//动态库加载
  18. if (NULL == hmod)
  19. {
  20. system("echo error load! \n");
  21. }
  22. void(*fp1)() = (void(*)())GetProcAddress(hmod, "go");
  23. int(*fp2)(int a, int b) = (int(*)(int a, int b))GetProcAddress(hmod, "add");
  24. if (NULL == fp1 || NULL == fp2)
  25. {
  26. system("echo error find! \n");
  27. }
  28. else
  29. {
  30. fp1();
  31. printf("%d \n", fp2(10, 20));
  32. }
  33. FreeLibrary(hmod);//动态库释放
  34. system("pause");
  35. }

程序片段(10):add.c

内容概要:计算器

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. //01.规律说明:
  4. // 100%7=2
  5. // 100求余7之后为2
  6. // 100-(100/7)*7=2
  7. // 100减去整除数*7=2
  8. // 5%3=2
  9. // 73%4=1 73%5=3
  10. // 74%4=2 74%5=4
  11. // 75%4=3 75%5=0
  12. // 73---->0100 1001
  13. // % 4---->0000 0100
  14. //------------------------
  15. // 1 0000 0001
  16. // 74---->0100 1010
  17. // % 4---->0000 0100
  18. //------------------------
  19. // 2 0000 0010
  20. //10-->2
  21. //100-->4
  22. //1000-->8
  23. //10000---16
  24. // 73---->0100 1001
  25. // % 5---->0000 0101
  26. //------------------------
  27. // 3---->0000 0011
  28. int main(void)
  29. {
  30. unsigned int num = 73;//余数
  31. printf("%d \n", num - (num & ~3));
  32. system("pause");
  33. }
  34. ////11 0 1
  35. ////10 1 0
  36. ////01 1 0
  37. ////00 0 0
  38. //
  39. ////0011 3 15
  40. ////0101 5 16
  41. // //21 +10
  42. ////0010 进位
  43. //
  44. ////0110 ^ 6
  45. //
  46. ////1000 8
  47. //
  48. //int add(int a,int b)
  49. //{
  50. // int wei = 0;
  51. // int jinwei = 0;
  52. //
  53. // do
  54. // {
  55. // wei = a^b;//处理位加法
  56. // jinwei = (a&b) << 1;//进位
  57. //
  58. // a = wei;//没有进位的加法
  59. // b = jinwei;//进位
  60. // } while (b!=0);
  61. // return a;
  62. //}
  63. //
  64. //
  65. //int dadd(int a, int b)
  66. //{
  67. // if (b==0)
  68. // {
  69. // return a;
  70. // }
  71. // else
  72. // {
  73. // int wei = a^b;
  74. // int jinwei = (a&b) << 1;
  75. // dadd(wei, jinwei);
  76. // }
  77. //}
  78. //
  79. //
  80. //void main1()
  81. //{
  82. // printf("%d", dadd(113, 15));
  83. // getchar();
  84. //}

程序片段(11):go.c

内容概要:最小公倍数最大公约数

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. //01.最小公倍数和最大公约数:
  4. // 条件:现有两个整数num1和num2
  5. // 那么:num1*num2=minGB*maxGY;
  6. // 编程:
  7. // 方式一:
  8. // 假设num1<num2
  9. // 最小公倍数:
  10. // 从两个整数当中较大的那个整数开始向大数遍历
  11. // 如果(0==num/num2)&&(0==num/num1)
  12. // 最大公约数:
  13. // 从两个整数当中较小的那个整数开始向小数遍历
  14. // 如果(0==num1/num)&&(0==num2/num)
  15. // 方式二:
  16. // 利用:num1*num2=minGB*maxGY
  17. //02.举例说明特点:
  18. // num1=10;num2=25;
  19. // 10 25 50-->minGB
  20. // 10 25 5--->maxGY
  21. // 原理:辗转相除法
  22. // 10 % 25 = 10; //被除数/除数=余数
  23. // 25 % 10 = 5; //除数/余数
  24. // 10 % 5 = 0; //除数/余数
  25. int maxGY(int i, int j)
  26. {
  27. if (0 == i % j)
  28. return j;//跳出
  29. else
  30. return maxGY(j, i % j);//递归
  31. }
  32. int main01(void)
  33. {
  34. int a = 25;
  35. int b = 110;
  36. printf("%d, %d \n", maxGY(25, 110), 25 * 110 / maxGY(25, 110));
  37. system("pause");
  38. }

程序片段(12):猜数字.c

内容概要:猜数字

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <Windows.h>
  5. #include <time.h>
  6. //01.健壮的应用程序当中经常使用abort提示错误:
  7. // 1.相当于其它语言当中的异常处理机制模拟
  8. // 2.区分编译错误和运行时异常
  9. // 编译错误:代码本身存在语法错误
  10. // 运行时异常:实在编译没有错误的情况之下发生的
  11. int main01(void)
  12. {
  13. int a, b;
  14. scanf("%d%d", &a, &b);
  15. if (b == 0)
  16. {
  17. abort();//提示错误
  18. }
  19. else
  20. {
  21. int c = a / b;
  22. }
  23. system("pause");
  24. }
  25. int main02(void)
  26. {
  27. time_t te;
  28. unsigned int rseed = (unsigned int)time(&te);
  29. srand(rseed);
  30. int rnum = rand() % 100 + 1;//1~100
  31. int gnum = 0;
  32. while (1)
  33. {
  34. scanf("%d", &gnum);
  35. if (rnum > gnum)
  36. puts("小了");
  37. else if (rnum < gnum)
  38. puts("大了");
  39. else
  40. {
  41. puts("小伙子才对了! ");
  42. break;
  43. }
  44. }
  45. //这后面的代码需要放置于多线程当中运行才行
  46. int i = 0;//否则限时功能不会生效
  47. while (1)
  48. {
  49. Sleep(1000);
  50. ++i;
  51. if (5 == i)
  52. //abort();//提示错误
  53. //break;//终止循环
  54. exit(0);//结束程序
  55. }
  56. system("pause");
  57. }

程序片段(13):type.cpp

内容概要:typedef

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <iostream>//CPP输入输入
  4. using namespace std;//使用名称空间
  5. //01.给任意类型取别名的方式:typedef使用
  6. // 规律:在声明变量的基础之上前置typedef关键字
  7. // 为已经存在的类型另起一个别名(原名和别名都有进行使用)
  8. // 只不过typedef具有简化类型名称的作用,而且某些地方必须
  9. // 为类型定义别名,否则无法进行后续操作
  10. typedef unsigned short int USI;
  11. typedef unsigned long int ULI;
  12. //02.C语言重要知识点概括:
  13. // 补码-->递归-->逻辑
  14. // 数组-->二维数组地图-->排序
  15. // 指针-->外挂(函数指针)
  16. // 字符串-->结构体-->内存四区-->文件
  17. //03.CPP语言当中获取类型的方式:
  18. // typeid(var).name();
  19. // 根据变量名称获取变量的所属类型;
  20. // 并且将该数据类型以字符串的形式打印出来
  21. int main01(void)
  22. {
  23. unsigned long int num = 10;
  24. ULI ulinum = 10;
  25. printf("%s \n", typeid(ulinum).name());//typedef(x).name();根据变量名称获取变量所属的数据类型(字符串表现形式)
  26. system("pause");
  27. }

20160130.CCPP体系详解(0009天)的更多相关文章

  1. 20160129.CCPP体系详解(0008天)

    程序片段(01):函数.c+call.c+测试.cpp 内容概要:函数 ///函数.c #include <stdio.h> #include <stdlib.h> //01. ...

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

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

  3. 20160208.CCPP体系详解(0018天)

    程序片段(01):main.c 内容概要:PointWithOutInit #include <stdio.h> #include <stdlib.h> //01.野指针详解: ...

  4. 20160206.CCPP体系详解(0016天)

    代码片段(01):.指针.c+02.间接赋值.c 内容概要:内存 ///01.指针 #include <stdio.h> #include <stdlib.h> //01.取地 ...

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

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

  6. 20160204.CCPP体系详解(0014天)

    程序片段(01):define.h+data.h&data.c+control.h&control.c+view.h&view.c+AI.h&AI.c+main.c 内 ...

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

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

  8. 20160128.CCPP体系详解(0007天)

    以下内容有所摘取,进行了某些整理和补充 论浮点数的存储原理:float浮点数与double浮点数的二进制存储原理–>阶码 浮点数转二进制 1.整数int类型和浮点数float类型都是占用4个字节 ...

  9. 20160127.CCPP体系详解(0006天)

    程序片段(01):msg.c 内容概要:线程概念 #include <stdio.h> #include <stdlib.h> #include <Windows.h&g ...

随机推荐

  1. ZOJ 3555 Ice Climber(dp)

    晦涩的题意+各种傻逼害我调了那么久,实际上题目就是一个dp[i][j],dp[i][j]表示第i层第j个最少需要多少时间,当我们去更新dp[i][j]的时候,考虑的是从第i+1层的某一个dp[i+1] ...

  2. C++堆栈与函数调用

    一.C++程序内存分配 1)在栈上创建.在执行函数时,函数内局部变量的存储单元都在栈上创建,函数结束是,这些存储单元自动被释放.栈内存的分配运算内置于处理器的指令集中,一般采用寄存器来存取,效率很高但 ...

  3. mysql 存储过程事务支持回滚

    如图查看表的属性: InnoDB 支持事务. MyISAM 不支持事务,不过性能更优越.

  4. Baidu和Google搜索引擎使用技巧(转)

    转自:Baidu和Google搜索 http://www.douban.com/note/261208979/ 百度搜索一:基本搜索   二:高级搜索   谷歌搜索一:基本搜索1)可部分匹配也可完全匹 ...

  5. HTTP常用的状态码

    一.200状态码: 成功2××:成功处理了请求的状态码. 1.200 :服务器已成功处理了请求并提供了请求的网页. 2.204:服务器成功处理了请求,但没有返回任何内容. 二.300状态码: 重定向3 ...

  6. WebSocket API简介

    WebSocket是html5新增加的一种通信协议,目前流行的浏览器都支持这个协议,例如Chrome,Safari,Firefox,Opera,IE等等,对该协议支持最早的应该是chrome,从chr ...

  7. Android 图片异步加载的体会,SoftReference已经不再适用

      在网络上搜索Android图片异步加载的相关文章,目前大部分提到的解决方案,都是采用Map<String, SoftReference<Drawable>>  这样软引用的 ...

  8. servlet学习笔记一

    Servlet一.基本概念 我们的程序根据是否需要访问网络,可分为网络程序和非网络程序.而 网络程序又分为B/S结构和C/S结构. 什么是C/S?即客户端(Client)/服务器(Server)模式. ...

  9. <iostream> 和 <iostream.h>的区别 及 Linux下编译iostream.h的方法

    0.序言 其实2者主要的区别就是iostream是C++标准的输入输出流头文件,而iostream.h是非标准的头文件. 标准头文件iostream中的函数属于标准命令空间,而iostream.h中的 ...

  10. LoadRunner8 安装步骤

    一.介绍 LoadRunner,是一种预测系统行为和性能的负载测试工具.通过以模拟上千万用户实施并发负载及实时性能监测的方式来确认和查找问题,LoadRunner能够对整个企业架构进行测试.企业使用L ...