经典算法_指针

最新推荐文章于 2024-08-31 10:10:36 发布

B1334628598

最新推荐文章于 2024-08-31 10:10:36 发布

阅读量175

点赞数

原文链接：http://www.cnblogs.com/denggelin/p/5533115.html

版权

每次指针加深一层，增加一个下标当作维度

a[i]　　　　　　　　等价于　　　　　　*(a + i)　　一维数组，一级指针，1个*

a[i][j]　　　　　　　等价于　　　　　　*(a[i] + j)　　　　*(*(a + i) + j)　　　　二维数组，二级指针，2个*　

a[i][j][k]　　　　　等价于　　　　　　*(a[i][j] + k)　　*(*(a[i] + j) + k)　　*(*(*(a + i) + j) + k)　　　　三维数组，三级指针，3个*

a[i][j][k][l]　　　　等价于　　　　　　*(a[i][j][k] + l)　　*(*(a[i][j] + k) + l)　　　　*(*(*(a[i] + j) + k) + l)　　　　*(*(*(*(a + i) + j) + k) + l)　　　　四维数组，四级指针，4个*

数组的指针，地址相同，但是指针类型不同

 1 #define _CRT_SURE_NO_WARNINGS
 2 
 3 #include <stdio.h>
 4 #include <stdlib.h>
 5 
 6 main1()
 7 {
 8     char str[5][10] = { "calc","notepad","tasklist","pause","mapaint" };
 9 
10     char(*p)[10] = str;
11 
12     printf("%x,%x,%x\n", str, &str, *str);//第一个指向字符串数组第一行的首地址，第二个指向字符串数组的首地址，第三个指向一个字符的首地址
13 
14     printf("%d,%d,%d\n", sizeof(*str), sizeof(*(&str)), sizeof(*(*str)));
15     
16     //指针地址一样，但是指针类型不一样
17     //str代表行地址, &str代表整个数组的地址, *str代表第一个字符的地址
18 
19     system("pause");
20 }
21 
22 main2()
23 {
24     int num = 10;
25     int *p1 = &num;
26     
27     double db = 10.9;
28     double *p2 = &db;
29 
30     printf("%d,%d\n", sizeof(p1), sizeof(p2));
31     
32     printf("%d,%d\n", sizeof(*p1), sizeof(*p2));
33 
34     system("pause");
35 }
36 
37 main()
38 {
39     int a[2][3] = { 1,2,3,4,5,6 };
40 
41     printf("%x,%x,%x\n", a, &a, *a);
42 
43     printf("%d,%d,%d\n", sizeof(*a), sizeof(*(&a)), sizeof(*(*a)));
44 
45     //a代表第一行的首地址, &a代表数组的首地址, *a代表第一个整型常量的首地址
46 
47     system("pause");
48 }

32位，指针就是4个字节

64位，指针占8个字节

一个指向整型数的指针 int*p

一个指向整型数指针的指针 int **p

一个有10个整型指针的数组 int *p[10]

一个指向有10个整型数数组的指针 int (*p)[10]

一个指向函数的指针，该函数有一个整型参数，并返回一个整型数 int ( *p)(int)

一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数，并返回一个整型数。 int(*p[10])(int)

一个指向函数指针的指针，所指向的函数有一个整型参数，并返回一个整型数。 int (**p)(int)

int a一个变量

int *p一个指向整数的指针

int **pp一个指向（指向整数的指针）的指针

int a[10]一个数组

int *p[10]一个数组，每一个元素都是指向整数的指针

int (*p)[10]一个指向有10个元素的数组的指针

int add(int a)

int (*p)(int )一个指向函数的指针

int (*p[10])(int )一个数组有10个指向函数的指针

 1 #include <stdio.h>
 2 
 3 main()
 4 {
 5     int a[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
 6     int i, j;
 7 
 8     for (i = 0;i < 3;i++)
 9     {
10         for (j = 0;j < 4;j++)
11         {
12             printf("%d,%x\n", *(*(a + i) + j), *(a + i) + j);
13         }
14     }
15     printf("\n");
16 
17     printf("%x\n", a);
18 
19     printf("%x\n", *a);
20 
21     printf("%x\n", &a);
22     
23     printf("%x\n", sizeof(a));//30
24 
25     printf("%x\n", sizeof(*a));//10
26 
27     printf("%x\n", sizeof(**a));//4
28 
29     printf("%x\n", sizeof(*&a));//30
30 
31     system("pause");
32 }
33 
34 main1()
35 {
36     int num[5] = { 1,2,3,4,5 };
37 
38     printf("%x\n", num);//第一个元素的首地址，4个字节
39 
40     printf("%x\n", *num);
41 
42     printf("%x\n", &num);//一个数组的首地址，20个字节
43 
44     printf("%d\n", sizeof(num));//20
45 
46     printf("%d\n", sizeof(*num));//4，根据类型地址取出内容
47 
48     printf("%d\n", sizeof(&num));//4
49 
50     printf("%d\n", sizeof(*&num));//20
51 
52     system("pause");
53 }

多线程查找

 1 #define _CRT_SECURE_NO_WARNINGS
 2 
 3 #include<stdio.h>
 4 #include<stdlib.h>
 5 #include<windows.h>
 6 #include<process.h>
 7 
 8 int flag = 0;
 9 int *addrfind = NULL;
10 
11 struct MyStruct
12 {
13     int *pfindstart;//要查找的首地址
14     int length;//限定长度，从地址开始
15     int num;//要查找的数据
16     int bh;//线程编号
17     int *pflag;//传递flag的地址，修改flag
18     int **addr;//传递一个指针的地址
19 };
20 
21 void find(void *p)
22 {
23     struct MyStruct *pstruct = (struct MyStruct *)p;//指针类型转换
24 
25     for (int *px = pstruct->pfindstart;px < pstruct->pfindstart + 100;px++)//内存的遍历，从地址开始累加100个元素的大小，遍历所有元素
26     {
27         if (*(pstruct->pflag) != 0)
28         {
29             printf("%d线程\n", pstruct->bh);
30             return;
31         }
32 
33         if (*px == pstruct->num)
34         {
35             printf("第%d个线程找到%x,%d\n", pstruct->bh, px, *px);
36             *(pstruct->pflag) = 1;
37             *(pstruct->addr) = px;
38             return;
39         }
40     }
41     printf("第%d个线程没有找到\n", pstruct->bh);
42     return;
43 }
44 
45 main()
46 {
47     int a[1000];//寻找783
48     int i;
49 
50     for (i = 0;i < 1000;i++)//数组初始化
51     {
52         a[i] = i;
53     }
54 
55     struct MyStruct threaddata[10];//创建结构体数组，处理不同的线程
56 
57     for (i = 0;i < 10;i++)//创建10个进程并行查找
58     {
59         threaddata[i].pfindstart = a + i * 100;//要查找的首地址
60         threaddata[i].length = 100;//限定长度，从地址开始
61         threaddata[i].bh = i;//线程编号
62         threaddata[i].num = 783;//要查找的数据
63         threaddata[i].pflag = &flag;
64         threaddata[i].addr = &addrfind;
65         _beginthread(find, 0, &threaddata[i]);
66     }
67 
68     Sleep(30000);
69 
70     printf("%d,%x", *addrfind, addrfind);
71 
72     system("pause");
73 }

用指向指针的指针的方法对N个整数排序并输出。要求排序单独写成一个函数。N个整数和N在主程序中输入，最后在主函数中输出。

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <time.h>
 4 
 5 #define N 10
 6 
 7 void main()
 8 {
 9     time_t ts;
10     srand((unsigned int)time(&ts));
11     int arr[N] = { 0 };//初始化数组
12     int *p[N];//存放指针的数组
13     int **pp;//指向指针的指针
14     int i;
15     int j;
16     int temp;
17 
18     for (i = 0; i < N; i++)
19     {
20         arr[i] = rand() % 100;
21         printf("%5d", arr[i]);
22         p[i] = &arr[i];
23     }
24 
25     pp = &p;
26 
27     for (i = 0; i < N - 1; i++)
28     {
29         for (j = 0; j < N - 1 - i; j++)
30         {
31             if (**(pp + j)>**(pp + j + 1))
32             {
33                 temp = **(pp + j);
34                 **(pp + j) = **(pp + j + 1);
35                 **(pp + j + 1) = temp;
36             }
37         }
38     }
39 
40     printf("\n");
41     for (i = 0; i < N; i++)
42     {
43         printf("%5d", arr[i]);
44     }
45 
46     system("pause");
47 }