C08指针

1. 操作系统给每个存储单元分配了一个编号，从ox00 00 00 00~0xff ff ff ff，这个编号称为地址，指针就是地址
2. 指针变量：即这个变量用来存放一个地址编号
3. 无论什么类型的地址，都是存储单元的变换，在32位平台下都是4个字节，即任何类型的指针变量都是4个字节大小，64位操作系统占8个字节。
4. 对应类型的指针变量，只能存放对应类型的地址。例如整型指针变量，只能存放整型变量的地址。

#include 

int main()
{
    char *a;
    short *b;
    int *c;
    long *d;
    float *e;
    double *f;

    printf("sizeof(a)=%dn", sizeof(a));
    printf("sizeof(b)=%dn", sizeof(b));
    printf("sizeof(c)=%dn", sizeof(c));
    printf("sizeof(d)=%dn", sizeof(d));
    printf("sizeof(e)=%dn", sizeof(e));
    printf("sizeof(f)=%dn", sizeof(f));

    return 0;
}

可见，我的操作系统是64位的。
详情可参考：《为什么在64位系统中指针的大小是8，而32位系统中却是4？》

数据类型 *指针变量名
int p; // 定义了一个指针变量p
在定义指针变量的时候， 是用来修饰变量的，代表指针变量。

关于指针的运算符： & 取地址 * 取值

#include 
int main()
{
    int a = 100;
    int *p; // 定义一个指针变量
    p = &a; // 给指针变量赋值
    printf("a = %d, %dn", a, *p);  // *p 等价于变量 a
    return 0;
}

拓展：如果一行中定义多个指针变量，每个变量前面都要加*修饰

1. 字符指针
2. 短整型指针
3. 整型指针
4. 长整型指针
5. float型指针
6. double型指针
7. 函数指针
8. 结构体指针
9. 指针的指针
   10.数组的指针

1.直接通过变量的名称
2.通过*指针名称 引用

#include 
int main()
{
    int *p1, *p2, temp, a, b;
    p1 = &a;
    p2 = &b;
    printf("请输入a,b的值：n");
    scanf("%d %d", p1, p2); // 和之前的scanf不同，这里直接用p1p2作为写入地址。
    temp = *p1;  // 用p1指向的变量a给temp赋值
    *p1 = *p2; // 用p2指向的变量b给p1指向的变量a赋值
    *p2 = temp;  // temp给p2指向的变量b赋值
    printf("a=%d b=%dn", a, b);
    printf("*p1=%d,*p2=%dn", *p1, *p2);
    return 0;
}

如果想让不同类型的指针相互赋值的时候，需要强制类型转换：

#include 
int main()
{
    int a = 0x1234, b = 0x5678;  // 4个字节
    char *p1, *p2;  // char类型只能保存一个字节
    printf("%#x  %#xn", a, b);
    p1 = (char *)&a;  // 强制类型转换
    p2 = (char *)&b;
    printf("%#x  %#xn", *p1, *p2);
    p1++;  // 指针向上移动
    p2++;
    printf("%#x  %#xn", *p1, *p2);
    return 0;
}

指针保存的是数组第一个元素的地址
也可以通过*（p+2）=100给当前地址的下一个变量赋值

#include
int main(){
    int a[5] = {0,1,2,3,4};
    int *p;
    p = a;

    // 指针指向数组a的第一个元素的首地址
    printf("a[2]=%dn",a[2]);
    printf("p[2]=%dn",p[2]);

    // *(a+n) <==> *(p+n) <==> a[n] <==> p[n]
    printf("*(p+2)%dn",*(p+2));
    printf("*(a+2)%dn",*(a+2));

    printf("p=%pn",p);
    printf("p+2=%pn",p+2);
    return 0;

}

#include 

void test1()
{
    int a[10];
    int *p, *q;
    p = a;
    q = p + 2;  // p q 间隔8个字节，意味着加一个整数最终移动的字节数与指针变量的类型也有关系
    printf("p=%pn", p);
    printf("q=%pn", q);

    return;
}

int main()
{
    test1();
    return 0;
}

前提：指向同一个数组的元素

#include 

void test2()
{
    int a[10];
    int *p, *q;
    p = &a[1];
    q = &a[6];
    if (p < q)
    {
        printf("p < qn");
    }
    else if (p > q)
    {
        printf("p > qn");
    }
    else
    {
        printf("p = qn");
    }
    return;
}

int main()
{
    //  test1();
    test2();
    return 0;
}

前提：指向同一个数组元素，减法的结果是指针指向的中间有多少个元素

#include 

void test3()
{
    int a[10];
    int *p, *q;
    p = &a[0];
    q = &a[3];
    printf("%ldn", q - p);
    return ;
}

int main()
{
    //  test1();
    //  test2();
    test3();
    return 0;
}

#include 

void test4()
{
    int a = 100;
    int *p, *q;
    p = &a;

    printf("a=%d %dn", a, *p);

    q = p;
    printf("*q=%dn", *q);

    *q = 999;
    printf("a=%dn", a);
}

int main()
{
    //  test1();
    //  test2();
    //  test3();
    test4();
    return 0;
}