sizeof 运算符

sizeof运算符，能给出某个类型或变量在内存中所占据的字节数。

• 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）内存。

& 运算符

获取变量的地址，它的操作数必须是变量

#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字节
    printf("%lu\n", sizeof(&i));  //8 32位架构下地址使用4字节存储、64位架构下地址使用8字节存储
    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字节）
i地址高于p（C语言内存模型，本地变量在堆栈中分配，变量由高至低分配。）

&操作符与数组

• 数组的地址
• 数组单元的地址
• 相邻的数组单元的地址

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

    printf("%p\n", &a);     //数组的地址
    printf("%p\n", a);      //不写&

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

    return 0;
}

程序输出：
0022FE20
0022FE20
0022FE20
0022FE24

• &a == a == &a[0]，获取数组第一个元素的三种方式。
• a[0]与a[1] 之间差4字节，相邻的数组单元的差距都是4字节。

如何保存地址的变量？

• *是一个单目运算符，用来访问指针的值所表示的地址上的变量。
• 可以做右值也可做左值

#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

数组与指针

函数参数表中的数组实际上是指针

#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*)
• 在函数参数表中 int sum(int a[]) 与 int sum(int *a) 是等价的

数组变量是特殊的指针

数组变量本身表达地址，所以

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

但是数组的单元表达的是变量，需要用&取地址

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

[]运算符可以对数组做，也可以对指针做：

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

*运算符可以对指针做，也可以对数组做：

• *a = 25

数组变量是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};

数组变量已经是const的指针，这里的const表明数组的每个单元都是const int，所以只能通过初始化赋值。