9.18 内存区域 全局变量 线程 插值查找 位域 栈的实现

栈区可以修改默认大小配置：

栈区默认的大小是1M,在vs2013中可以修改。

堆区和栈区的地址区别：

栈是连续的，向上增长，地址越来越小。类似数组。

堆是链接的，向下增长，地址越来越大。类似链表。

栈区   高地址到低地址

堆区   低地址到高地址

1. #include <stdio.h>
2. #include <stdlib.h>
3. int main()
4. {
5. int a = 1, b = 2;
6. printf("%p,%p\n", &a, &b); //a的地址大于b的地址
8. char *p1 = malloc(1);
9. char *p2 = malloc(1);
10. printf("%p,%p\n", &p1, &p2);//p1的地址大于p2的地址
11. printf("%p,%p\n", p1, p2);//p1指向的地址小于p2指向的地址
13. return 0;
14. }

代码区：只读不可写

int  a = 45;  //a在栈上        45在寄存器

常量字符串在代码区：

char *p = "calc"; //  p在栈上，  “calc”在代码区

1. char *p = "liuwei"; //指针只存了地址
2. printf("%d，%d\n",sizeof(p),sizeof("liuwei")); // 4 7

全局变量的注意事项：

1.    全局变量前一定不能加上 auto   不能放在栈上。

2.    全局变量具有声明和定义的区别。

int a;
int a;
int a;
这种是可以通过编译的。因为三个都属于声明。    int a；这样没有赋值的属于声明。 

不过局部内，这样就不可以了， 局部变量没有声明和定义的区别。

1. #include <stdio.h>
2. int a;
3. int a;
4. int a;
5. int main()
6. {
7. printf("%d\n", a); //结果输出0.
8. return 0;
9. }

3.      全局变量如果只有声明，没有定义，会自动初始化0。因为是在Bss段。

4.      全局如果  int a = 1; int a = 2;会出现多重定义问题。有赋值运算符的属于定义。

5.      不同文件的全局变量：

全局变量可以跨文件使用、同一个工程，不同源文件，不能出现两个同名变量的定义 。 

当两个文件同时使用一个全局变量时，需要在另一个文件内，先extern声明，再使用。

见朱老师 9.1 作用域 static extern malloc relloc

因此头文件最好只声明，不要定义，免得包含多次，就会出现多定义。当然可以用ifdef避免

函数默认是全局函数：

函数默认都是全局函数， 跨文件的函数可以直接使用。

a.c

1. #include <stdio.h>
2. int main()
3. {
4. gogo();
5. return 0;
6. }

b.c

1. #include <stdio.h>
2. void gogo()
3. {
4. printf("gogo\n");
5. }

可以直接打印出gogo,虽然在a.c里没有函数声明，因为函数默认就是全局的

但是本文件内部调用函数之前声明，或者在前面定义

1. #include <stdio.h>
2. void gogo();//函数声明
3. int main()
4. {
5. gogo();
6. }
8. void gogo()
9. {
10. printf("gogo\n");
11. }

线程：                             

#include <process.h> //包含线程头文件

_beginthread();//开启一个线程

1. #include <stdio.h>
2. #include <windows.h>
3. #include <process.h>
5. void runMsg(void *p)
6. {
7. MessageBoxA(0, "hello", "world", 0);
8. }
10. void main()
11. {
12. _beginthread(runMsg, 0, NULL);
13. _beginthread(runMsg, 0, NULL);
14. _beginthread(runMsg, 0, NULL);
15. getchar();//不加getchar()不行，因为主线程结束了，其他线程都挂掉了
16. }

线程传递参数：

1. #include <stdio.h>
2. #include <windows.h>
3. #include <process.h>
5. void run(void *p)
6. {
7. MessageBoxA(0, "hello", p, 0);
8. }
11. int main()
12. {
13. _beginthread(run, 0, "ABC");
14. _beginthread(run, 0, "CDE");
15. _beginthread(run, 0, "XYZ");
16. getchar();
17. return 0;
18. }

如果想传递多个参数，可以传递结构体的指针

1. #include <stdio.h>
2. #include <windows.h>
3. #include <process.h>
5. struct STU
6. {
7. char name[10];
8. char title[10];
9. };
11. struct STU stu[3] = { {"hello","world"}, {"fuck","shit"}, {"apple","pear"} };
13. void run(void *p)
14. {
15. struct STU *tmp = (struct STU *)p;
16. MessageBoxA(0, tmp->name, tmp->title, 0);
17. }
20. int main()
21. {
22. for (int i = 0; i < 3;i++)
23. {
24. _beginthread(run, 0, &stu[i]);
25. }
26. getchar();
27. return 0;
28. }

位域实战代码：                        

通过位域实现输入一个数，输出其补码

1. #define _CRT_SECURE_NO_WARNINGS
2. #include <stdio.h>
3. typedef struct
4. {
5. unsigned char ch1 : 1;
6. unsigned char ch2 : 1;
7. unsigned char ch3 : 1;
8. unsigned char ch4 : 1;
9. unsigned char ch5 : 1;
10. unsigned char ch6 : 1;
11. unsigned char ch7 : 1;
12. unsigned char ch8 : 1;
13. }bit;
16. int main()
17. {
18. int num;
19. scanf("%d", &num);
20. bit *mybit = &num;
21. for (int i = 3; i >= 0; i--) //地址要从高字节打到低字节
22. {
23. printf("%d%d%d%d %d%d%d%d ",
24. mybit[i].ch8, mybit[i].ch7, mybit[i].ch6, mybit[i].ch5,
25. mybit[i].ch4, mybit[i].ch3, mybit[i].ch2, mybit[i].ch1);
26. }
27. return 0;
28. }

插值查找（二分查找升级版，注意只能在有序并且分布均匀的情况下查找）

1. #include <stdio.h>
3. int find(int *a, int n, int key)
4. {
5. int low = 0, high = n - 1;
6. int mid, count = 0;
7. while (low <= high)
8. {
9. printf("查找第%d次\n", ++count);
10. //mid = (low + high) / 2; 二分查找bug版本
11. //mid = low + (high - low) / 2; 二分查找正确版
12. mid = low + (high - low) * (key - a[low]) / (a[high] - a[low]);//插值查找
13. if (a[mid] == key)
14. return mid;
15. else if (a[mid] < key)
16. low = mid + 1;
17. else
18. high = mid - 1;
19. }
20. return -1;
21. }
23. int main()
24. {
25. int i;
26. int a[1024 * 100];
27. for (i = 0; i < 1024 * 100; i++)
28. a[i] = i;
29. int pos = find(a, 1024 * 100, 102);
30. if (pos != -1)
31. printf("%d %d\n", pos, a[pos]);
32. else
33. printf("没有找到\n");
35. }

注：二分查找的一个bug

见： 排序算法

数据结构栈，实现递归：

栈的数据结构实现：

1. #include <stdio.h>
2. #include <string.h>
3. #define N 50
4. struct stack
5. {
6. int top;
7. int data[N];
8. };
10. void init_stack(struct stack *p)
11. {
12. p->top = -1;
13. memset(p->data, 0, sizeof(int)*N);
14. }
16. int is_empty(struct stack *p)
17. {
18. if (p->top == -1)
19. return 1;
20. else
21. return 0;
22. }
23. int is_full(struct stack *p)
24. {
25. if (p->top == N - 1)
26. return 1;
27. else
28. return 0;
29. }
31. void push_stack(struct stack *p, int key)
32. {
33. if (is_full(p))
34. return;
35. p->top++;
36. p->data[p->top] = key;
37. }
39. int pop_stack(struct stack *p)
40. {
41. if (is_empty(p))
42. return -1;
43. int data = p->data[p->top];
44. p->top--;
45. return data;
46. }
49. int main()
50. {
51. struct stack mystack;
52. init_stack(&mystack);
53. int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
54. int i;
55. for (i = 0; i < 10; i++)
56. {
57. push_stack(&mystack, a[i]);
58. }
60. while (!is_empty(&mystack))
61. {
62. printf("%d\n", pop_stack(&mystack));
63. }
64. return 0;
65. }

递归打印一个整数的二进制

1. #include <stdio.h>
2. void bin(int num)
3. {
4. if (num == 0)
5. return;
7. bin(num / 2);
8. printf("%d\n", num % 2); // 1 0 1 0
9. }
10. int main()
11. {
12. bin(10);
13. return 0;
14. }

用上面的 栈 数据结构实现以上的递归。

1. int main()
2. {
3. struct stack mystack;
4. init_stack(&mystack);
5. int num = 10;
6. while (num)
7. {
8. push_stack(&mystack, num % 2);
9. num /= 2;
11. }
12. while (!is_empty(&mystack))
13. {
14. printf("%d\n", pop_stack(&mystack));
15. }
16. return 0;
17. }

来自为知笔记(Wiz)

转载于:https://www.cnblogs.com/l6241425/p/3982219.html