sizeof 運算符

sizeof運算符，能給出某個類型或變量在內(nèi)存中所占據(jù)的字節(jié)數(shù)。

• sizeof(int)

• sizeof(i)

示例代碼：

#include <stdio.h>
int main()
{
    int a;
    a = 6;
    printf("sizeof(int)=%ld\n", sizeof(int));
    printf("sizeof(a)=%ld\n", sizeof(a));
    return 0;   
}

程序輸出：
sizeof(int)=4
sizeof(a)=4

注：1byte=8bit，則一個整型要占用4byte（32bit）內(nèi)存。

& 運算符

獲取變量的地址，它的操作數(shù)必須是變量

#include <stdio.h>
int main()
{
    int i = 0;
    printf("0x%x\n", &i);  //0x22fe4c
    printf("%p\n", &i);    //000000000022FE4C
    
    
    printf("%lu\n", sizeof(int)); //4 整型4字節(jié)
    printf("%lu\n", sizeof(&i));  //8 32位架構(gòu)下地址使用4字節(jié)存儲、64位架構(gòu)下地址使用8字節(jié)存儲
    return 0;
}

• & 操作符不能操作非變量

#include <stdio.h>
int main()
{
    int i = 0;
    int p;
    p = (int)&i;
    p = (int)&(i+p); //[Error] lvalue required as unary '&' operand
    return 0;
}

• 相鄰變量的地址，有什么特點？

#include <stdio.h>
int main()
{
    int i = 0;
    int p;

    printf("%p\n", &i); //0022FE4C
    printf("%p\n", &p); //0022FE48

    return 0;
}

i與p相差4（整型變量占用4字節(jié)）
i地址高于p（C語言內(nèi)存模型，本地變量在堆棧中分配，變量由高至低分配。）

&操作符與數(shù)組

• 數(shù)組的地址
• 數(shù)組單元的地址
• 相鄰的數(shù)組單元的地址

#include <stdio.h>
int main()
{
    int a[10];

    printf("%p\n", &a);     //數(shù)組的地址
    printf("%p\n", a);      //不寫&

    printf("%p\n", &a[0]);
    printf("%p\n", &a[1]);

    return 0;
}

程序輸出：
0022FE20
0022FE20
0022FE20
0022FE24

• &a == a == &a[0]，獲取數(shù)組第一個元素的三種方式。
• a[0]與a[1] 之間差4字節(jié)，相鄰的數(shù)組單元的差距都是4字節(jié)。

如何保存地址的變量？

• *是一個單目運算符，用來訪問指針的值所表示的地址上的變量。
• 可以做右值也可做左值

#include <stdio.h>

void f(int *p);

int main(void)
{
    int i = 6;
    printf("&i=%p\n", &i);
    f(&i);                  //通過&i傳遞i的地址
    printf(" i=%d\n", i);
    return 0;
}

void f(int *p)             //通過 *p 接收 &i
{
    printf(" p=%p\n", p);  //通過 p 訪問 i 的地址
    printf("*p=%d\n", *p); //通過 *p 訪問 i 變量
    *p = 26;               //通過 *p 給 i 變量賦值
}

程序輸出：
&i=0022FE4C
p=0022FE4C
*p=6
i=26

數(shù)組與指針

函數(shù)參數(shù)表中的數(shù)組實際上是指針

#include <stdio.h>
void getMin(int a[], int len, int *min);
int main()
{
    int a[] = {1, 2, 3, 4, 5, 6};
    int min;

    printf("main sizeof(a)=%lu\n", sizeof(a));
    printf("main a=%p\n", a);

    getMin(a, sizeof(a)/sizeof(a[0]), &min);    
    printf("a[0]=%d\n", a[0]);
    printf("min=%d\n", min);

    return 0;
}

void getMin(int a[], int len, int *min)
{
    int i;
    printf("min sizeof(a)=%lu\n", sizeof(a));
    printf("min a=%p\n", a);
    *min = a[0];
    for( i=1; i<len; i++) {
        if( a[i] < *min) {
            *min = a[i];
        }
    }
}

程序輸出：
main sizeof(a)=24
main a=0022FE30
min sizeof(a)=8
min a=0022FE30
a[0]=1
min=1

• sizeof(a) == sizeof(int*)
• 在函數(shù)參數(shù)表中 int sum(int a[]) 與 int sum(int *a) 是等價的

數(shù)組變量是特殊的指針

數(shù)組變量本身表達地址，所以

• int a[10]; int* p = a //無需用&取地址

但是數(shù)組的單元表達的是變量，需要用&取地址

• &a[0]、&a[1]、&a[2]

[]運算符可以對數(shù)組做，也可以對指針做：

• p[0] 等價于 a[0]

*運算符可以對指針做，也可以對數(shù)組做：

• *a = 25

數(shù)組變量是const的指針，所以不能被賦值

• int a[] 可以看成是 int * const a

指針的常見錯誤

指針變量在未指向一個變量前不能被賦值

int *p;
*p = 12; // Error

int *p;
int i = 10;
p = &i;  // Right
*p = 12;

const 與 指針

int i;
const int *p1 = &i; //指針所指的不可修改
int const *p2 = &i; //指針所指的不可修改
int *const p3 = &i; //指針不可修改

const int a[] = {1, 2, 3, 4, 5, 6};

數(shù)組變量已經(jīng)是const的指針，這里的const表明數(shù)組的每個單元都是const int，所以只能通過初始化賦值。