日本免费高清视频-国产福利视频导航-黄色在线播放国产-天天操天天操天天操天天操|www.shdianci.com

學無先后，達者為師

網站首頁 編程語言 正文

C語言由淺入深理解指針_C 語言

作者：龜π氣功 ? 更新時間： 2022-07-02 編程語言

1. 相關概念

  • 操作系統給每個存儲單元分配了一個編號，從ox00 00 00 00~0xff ff ff ff，這個編號稱為地址，指針就是地址
  • 指針變量：即這個變量用來存放一個地址編號
  • 無論什么類型的地址，都是存儲單元的變換，在32位平臺下都是4個字節，即任何類型的指針變量都是4個字節大小，64位操作系統占8個字節。
  • 對應類型的指針變量，只能存放對應類型的地址。例如整型指針變量，只能存放整型變量的地址。
#include <stdio.h>
int main()
{
    char *a;
    short *b;
    int *c;
    long *d;
    float *e;
    double *f;
    printf("sizeof(a)=%d\n", sizeof(a));
    printf("sizeof(b)=%d\n", sizeof(b));
    printf("sizeof(c)=%d\n", sizeof(c));
    printf("sizeof(d)=%d\n", sizeof(d));
    printf("sizeof(e)=%d\n", sizeof(e));
    printf("sizeof(f)=%d\n", sizeof(f));
    return 0;
}

可見，我的操作系統是64位的。

為什么在64位系統中指針的大小是8，而32位的卻是4？?

64位系統，這個位數指的是CPU 里面的通用寄存器的數據寬度為64位，也就是說一個地址占二進制位數是64，所以：

sizeof(double *)==sizeof(int *)==sizeof(char *)==64/8==8

32位系統，同理，他的一個地址占32位二進制空間，sizeof(double *)==sizeof(int *)==sizeof(char *)==32/8==4

其實明白了兩個系統的尋址原理就能明白，大體就是這個原因。地址跟系統有關，但是基本數據類型占的大小是由C語言本身決定。

2. 指針的定義方法

數據類型 *指針變量名

int p; // 定義了一個指針變量p 在定義指針變量的時候， 是用來修飾變量的，代表指針變量。

關于指針的運算符：

& 取地址 * 取值

#include <stdio.h>
int main()
{
    int a = 100;
    int *p; // 定義一個指針變量
    p = &a; // 給指針變量賦值
    printf("a = %d, %d\n", a, *p);  // *p 等價于變量 a
    return 0;
}

拓展：如果一行中定義多個指針變量，每個變量前面都要加*修飾

3. 指針的分類

  1. 字符指針
  2. 短整型指針
  3. 整型指針
  4. 長整型指針
  5. float型指針
  6. double型指針
  7. 函數指針
  8. 結構體指針
  9. 指針的指針
  10. 數組的指針

4. 指針和變量的關系

引用變量的方法：

1.直接通過變量的名稱

2.通過*指針名稱 引用

#include <stdio.h>
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=%d\n", a, b);
    printf("*p1=%d,*p2=%d\n", *p1, *p2);
    return 0;
}

如果想讓不同類型的指針相互賦值的時候，需要強制類型轉換：

#include <stdio.h>
int main()
{
    int a = 0x1234, b = 0x5678;  // 4個字節
    char *p1, *p2;  // char類型只能保存一個字節
    printf("%#x  %#x\n", a, b);
    p1 = (char *)&a;  // 強制類型轉換
    p2 = (char *)&b;
    printf("%#x  %#x\n", *p1, *p2);
    p1++;  // 指針向上移動
    p2++;
    printf("%#x  %#x\n", *p1, *p2);
    return 0;
}

5. 指針與數組的關系

指針保存的是數組第一個元素的地址

也可以通過*（p+2）=100給當前地址的下一個變量賦值

#include<stdio.h>
int main(){
    int a[5] = {0,1,2,3,4};
    int *p;
    p = a;
    // 指針指向數組a的第一個元素的首地址
    printf("a[2]=%d\n",a[2]);
    printf("p[2]=%d\n",p[2]);
    // *(a+n) <==> *(p+n) <==> a[n] <==> p[n]
    printf("*(p+2)%d\n",*(p+2));
    printf("*(a+2)%d\n",*(a+2));
    printf("p=%p\n",p);
    printf("p+2=%p\n",p+2);
    return 0;
}

6. 指針的運算

指針可以加一個整數，往下指幾個它指向的變量，結果還是地址

#include <stdio.h>
void test1()
{
    int a[10];
    int *p, *q;
    p = a;
    q = p + 2;  // p q 間隔8個字節，意味著加一個整數最終移動的字節數與指針變量的類型也有關系
    printf("p=%p\n", p);
    printf("q=%p\n", q);
    return;
}
int main()
{
    test1();
    return 0;
}

  • 兩個相同的指針可以比較大小

前提：指向同一個數組的元素

#include <stdio.h>
void test2()
{
    int a[10];
    int *p, *q;
    p = &a[1];
    q = &a[6];
    if (p < q)
    {
        printf("p < q\n");
    }
    else if (p > q)
    {
        printf("p > q\n");
    }
    else
    {
        printf("p = q\n");
    }
    return;
}
int main()
{
    //  test1();
    test2();
    return 0;
}

  • 兩個同類型的指針可以做減法

前提：指向同一個數組元素，減法的結果是指針指向的中間有多少個元素

#include <stdio.h>
void test3()
{
    int a[10];
    int *p, *q;
    p = &a[0];
    q = &a[3];
    printf("%ld\n", q - p);
    return ;
}
int main()
{
    //  test1();
    //  test2();
    test3();
    return 0;
}

  • 兩個相同類型的指針可以相互賦值
#include <stdio.h>
void test4()
{
    int a = 100;
    int *p, *q;
    p = &a;
    printf("a=%d %d\n", a, *p);
    q = p;
    printf("*q=%d\n", *q);
    *q = 999;
    printf("a=%d\n", a);
}
int main()
{
    //  test1();
    //  test2();
    //  test3();
    test4();
    return 0;
}

原文鏈接：https://blog.csdn.net/weixin_45231460/article/details/124635087

欄目分類
最近更新