C语言有关有关数组的相关问题

由于c语言很多时候进行的仅是值传递，所以经常不方便调用函数的方式进行改值，所以更加方便有效。

对于指针 指针也就是内存地址，指针变量是用来存放内存地址的变量，不同类型的指针变量所占用的存储单元长度是相同的，而存放数据的变量因数据的类型不同，所占用的存储空间长度也不同。有了指针以后，不仅可以对数据本身，也可以对存储数据的变量地址进行操作。本文主要介绍C语言中的指针。

int p 这是一个普通的整型变量 
int *p 首先从P 处开始,先与*结合,所以说明P 是一个指针,然后再与int 结合,说明指针所指向的内容的类型为int 型.所以P是一个返回整型数据的指针 
int p[3]; 首先从P 处开始,先与[]结合,说明P 是一个数组,然后与int 结合,说明数组里的元素是整型的,所以P 是一个由整型数据组成的数组 
int *p[3]; 首先从P 处开始,先与[]结合,因为其优先级比*高,所以P 是一个数组,然后再与*结合,说明数组里的元素是指针类型,然后再与int 结合,说明指针所指向的内容的类型是整型的,所以P 是一个由返回整型数据的指针所组成的数组 
int (*p)[3]; 首先从P 处开始,先与*结合,说明P 是一个指针然后再与[]结合(与"()"这步可以忽略,只是为了改变优先级),说明指针所指向的内容是一个数组,然后再与int 结合,说明数组里的元素是整型的.所以P 是一个指向由整型数据组成的数组的指针 
 

int **p; 首先从P 开始,先与*结合,说是P 是一个指针,然后再与*结合,说明指针所指向的元素是指针,然后再与int 结合,说明该指针所指向的元素是整型数据.由于二级指针以及更高级的指针极少用在复杂的类型中,所以后面更复杂的类型我们就不考虑多级指针了,最多只考虑一级指针. 
int p(int); 从P 处起,先与()结合,说明P 是一个函数,然后进入()里分析,说明该函数有一个整型变量的参数,然后再与外面的int 结合,说明函数的返回值是一个整型数据 
Int (*p)(int); 从P 处开始,先与指针结合,说明P 是一个指针,然后与()结合,说明指针指向的是一个函数,然后再与()里的int 结合,说明函数有一个int 型的参数,再与最外层的int 结合,说明函数的返回类型是整型,所以P 是一个指向有一个整型参数且返回类型为整型的函数的指针 

#include <stdio.h>

#if 0

void fn(int *p)
{
    *p += 1;
}

void maxOfTwoNumbers(int a, int b, int *pMax)
{
    *pMax = a > b ? a : b;
}//比较两个术中较大的值

void maxMinOfThreeNumbers(int a, int b, int c, int *pMax, int *pMin)
{
    *pMax = a > b ? a : b;
    *pMax = *pMax > c ? *pMax : c;
    *pMin = a < b ? a : b;
    *pMin = *pMin < c ? *pMin : c;
}比较三个数中最大的值并输出

int main(void)
{
/*    int max;
    int min;
    maxMinOfThreeNumbers(10, 20, 15,  &max, &min);
    printf("%d, %d\n", max, min);*/

    int i = 10;
    int *p = &i, *q;
    
    printf("%lu\n", sizeof(p));
    printf("%lu\n", sizeof(q));

    return 0;
}

void swap(int *a, int *b)
{
    int *t;
    int k;
    t = &k;
    k = *a;
    *a = *b;
    *b = k;
}

int main(void)
{
    int i = 10, j = 20;

    swap(&i, &j);

    printf("%d %d\n", i, j);

    return 0;
}交换两数

int main(void)
{
    int i = 10;
    int *p = &i;

    printf("%p\n", &*p);
    printf("%d\n", *&i);
    printf("%p\n", *&p);
//X    printf("%d\n", &*i);
    return 0;
}

int main(void)
{
    int i = 0x12345678;
    char *p;
    p = (char *)&i;

    if(1 == *p)
    {
        puts("little");
    }
    else
    {
        puts("big");
    }
    return 0;
}

void printArray(int *a, int len)
{
    int i;
    for(i = 0;i < len;++i)
    {
        printf("%d\n", *(a + i));
    }
}遍历数组并打印

int sumOfArray(int *a, int len)
{
    int sum = 0, i;
    for(i = 0;i < len;++i)
    {
        sum += *(a + i);
    }
    return sum;
}求数组的和

void swap(int *a, int *b)
{
    int t = *a;
    *a = *b;
    *b = t;
}

void reverse(int *a, int len)
{
    int i;
    for(i = 0;i < len / 2;++i)
    {
        swap(a + i, a + len - i - 1);
    }
}交换两数

void sort(int *a, int len)
{
    int i, j;
    for(i = 0;i < len - 1;++i)
    {
        for(j = i + 1;j < len;++j)
        {
            if(*(a + i) > *(a + j))
            {
                swap(a + i, a + j);
            }
        }
    }
}

int *binaryFind(int *a, int len, int n)
{
    int begin = 0;
    int end = len - 1;
    while(begin <= end)
    {
        int mid = (begin + end) / 2;
        if(*(a + mid) < n)
        {
            begin = mid + 1;
        }
        else if(*(a + mid) > n)
        {
            end = mid - 1;
        }
        else
        {
            return a + mid;
        }
    }
    return NULL;
}

int main(void)
{
    int a[] = {1,-2,3,-4,5,-6,7,-8,9,0};
    int len = sizeof(a) / sizeof(a[0]);

//    printf("%d\n", sumOfArray(a, len));
    sort(a, len);
    int *ret = binaryFind(a, len, -8);
    if(ret == NULL)
    {
        puts("not found");
    }
    else
    {
        printf("%p, %d\n", ret, *ret);
    }
//    printArray(a, len);
/*
    int i;
    int *p = a;

    for(i = 0;i < len;++i)
    {
        printf("%d\n", *p++); //a[i]  <=> *(a + i)    &a[0]
    }
*/

    return 0;
}

int main(void)
{
    int a[] = {1,2,3,4,5,6,7,8,9,0};
    int *p = a;
    int *q = a + 2;

    printf("%ld\n" ,p - q);

    return 0;
}
#endif

int main(void)
{
    *(int *)(0x30008000) = 0xFFFFFFFF;
    return 0;
}