经典算法_指针

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

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个*

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

#define _CRT_SURE_NO_WARNINGS

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

main1()
{
    char str[5][10] = { "calc","notepad","tasklist","pause","mapaint" };

    char(*p)[10] = str;

    printf("%x,%x,%x
", str, &str, *str);//第一个指向字符串数组第一行的首地址，第二个指向字符串数组的首地址，第三个指向一个字符的首地址

    printf("%d,%d,%d
", sizeof(*str), sizeof(*(&str)), sizeof(*(*str)));
    
    //指针地址一样，但是指针类型不一样
    //str代表行地址, &str代表整个数组的地址, *str代表第一个字符的地址

    system("pause");
}

main2()
{
    int num = 10;
    int *p1 = &num;
    
    double db = 10.9;
    double *p2 = &db;

    printf("%d,%d
", sizeof(p1), sizeof(p2));
    
    printf("%d,%d
", sizeof(*p1), sizeof(*p2));

    system("pause");
}

main()
{
    int a[2][3] = { 1,2,3,4,5,6 };

    printf("%x,%x,%x
", a, &a, *a);

    printf("%d,%d,%d
", sizeof(*a), sizeof(*(&a)), sizeof(*(*a)));

    //a代表第一行的首地址, &a代表数组的首地址, *a代表第一个整型常量的首地址

    system("pause");
}

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个指向函数的指针

#include <stdio.h>

main()
{
    int a[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
    int i, j;

    for (i = 0;i < 3;i++)
    {
        for (j = 0;j < 4;j++)
        {
            printf("%d,%x
", *(*(a + i) + j), *(a + i) + j);
        }
    }
    printf("
");

    printf("%x
", a);

    printf("%x
", *a);

    printf("%x
", &a);
    
    printf("%x
", sizeof(a));//30

    printf("%x
", sizeof(*a));//10

    printf("%x
", sizeof(**a));//4

    printf("%x
", sizeof(*&a));//30

    system("pause");
}

main1()
{
    int num[5] = { 1,2,3,4,5 };

    printf("%x
", num);//第一个元素的首地址，4个字节

    printf("%x
", *num);

    printf("%x
", &num);//一个数组的首地址，20个字节

    printf("%d
", sizeof(num));//20

    printf("%d
", sizeof(*num));//4，根据类型地址取出内容

    printf("%d
", sizeof(&num));//4

    printf("%d
", sizeof(*&num));//20

    system("pause");
}

多线程查找

#define _CRT_SECURE_NO_WARNINGS

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

int flag = 0;
int *addrfind = NULL;

struct MyStruct
{
    int *pfindstart;//要查找的首地址
    int length;//限定长度，从地址开始
    int num;//要查找的数据
    int bh;//线程编号
    int *pflag;//传递flag的地址，修改flag
    int **addr;//传递一个指针的地址
};

void find(void *p)
{
    struct MyStruct *pstruct = (struct MyStruct *)p;//指针类型转换

    for (int *px = pstruct->pfindstart;px < pstruct->pfindstart + 100;px++)//内存的遍历，从地址开始累加100个元素的大小，遍历所有元素
    {
        if (*(pstruct->pflag) != 0)
        {
            printf("%d线程
", pstruct->bh);
            return;
        }

        if (*px == pstruct->num)
        {
            printf("第%d个线程找到%x,%d
", pstruct->bh, px, *px);
            *(pstruct->pflag) = 1;
            *(pstruct->addr) = px;
            return;
        }
    }
    printf("第%d个线程没有找到
", pstruct->bh);
    return;
}

main()
{
    int a[1000];//寻找783
    int i;

    for (i = 0;i < 1000;i++)//数组初始化
    {
        a[i] = i;
    }

    struct MyStruct threaddata[10];//创建结构体数组，处理不同的线程

    for (i = 0;i < 10;i++)//创建10个进程并行查找
    {
        threaddata[i].pfindstart = a + i * 100;//要查找的首地址
        threaddata[i].length = 100;//限定长度，从地址开始
        threaddata[i].bh = i;//线程编号
        threaddata[i].num = 783;//要查找的数据
        threaddata[i].pflag = &flag;
        threaddata[i].addr = &addrfind;
        _beginthread(find, 0, &threaddata[i]);
    }

    Sleep(30000);

    printf("%d,%x", *addrfind, addrfind);

    system("pause");
}

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

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

#define N 10

void main()
{
    time_t ts;
    srand((unsigned int)time(&ts));
    int arr[N] = { 0 };//初始化数组
    int *p[N];//存放指针的数组
    int **pp;//指向指针的指针
    int i;
    int j;
    int temp;

    for (i = 0; i < N; i++)
    {
        arr[i] = rand() % 100;
        printf("%5d", arr[i]);
        p[i] = &arr[i];
    }

    pp = &p;

    for (i = 0; i < N - 1; i++)
    {
        for (j = 0; j < N - 1 - i; j++)
        {
            if (**(pp + j)>**(pp + j + 1))
            {
                temp = **(pp + j);
                **(pp + j) = **(pp + j + 1);
                **(pp + j + 1) = temp;
            }
        }
    }

    printf("
");
    for (i = 0; i < N; i++)
    {
        printf("%5d", arr[i]);
    }

    system("pause");
}