C语言中&符号的多重用法与底层原理详解

int num = 42;
int *ptr = #  // ptr现在"指向"num

地址        内容
0x1000     [42]    // num的值
0x2000     [0x1000] // ptr的值

int age;
scanf("%d", &age); // 必须传地址才能修改age的值

void increment(int *p) { (*p)++; }
int main() {
    int count = 0;
    increment(&count); // count现在为1
}

struct node {
    int data;
    struct node *next;
};

struct node node1, node2;
node1.next = &node2; // 构建链表关系

unsigned char a = 0b11001100;
unsigned char b = 0b10101010;
unsigned char c = a & b; // 0b10001000

#define led_on  0x01
#define led_off 0xfe

uint8_t status = 0xff;
status &= led_off; // 关闭led而不影响其他位

if (register_value & (1 << 3)) {
    // 第3位为1时执行
}

#define read_perm   0x01
#define write_perm  0x02
#define exec_perm   0x04

uint8_t user_perm = read_perm | write_perm;
if (user_perm & write_perm) {
    // 有写权限
}

if (num & 1) {
    // 奇数
} else {
    // 偶数
}

#define alignment 4
if (ptr & (alignment-1)) {
    // 未对齐
}

uint32_t color = 0xff336699;
uint8_t alpha = (color >> 24) & 0xff;

int x = 10;
int &ref = x;  // ref是x的引用
ref = 20;      // 现在x也变成20

void foo() { printf("hello"); }
int main() {
    void (*pf1)() = foo;    // 合法
    void (*pf2)() = &foo;   // 也合法
    // 两者等价
}

int (*fp)(int);   // fp是指向函数的指针
int *fp(int);     // fp是返回int*的函数
int (&ref)[10];   // c++中，ref是int[10]的引用

int *ptr = null;
printf("%p", &ptr);  // 合法，打印ptr变量本身的地址
printf("%p", ptr);   // 打印null (0x0)

int arr[10];
printf("%p %p", arr, &arr); // 值相同但类型不同
// arr的类型是int*
// &arr的类型是int(*)[10]

register int i;
int *p = &i;  // 错误！不能取register变量的地址

int num = 42;
int *p = #

mov dword ptr [ebp-4], 42   ; num = 42
lea eax, [ebp-4]            ; eax = &num
mov dword ptr [ebp-8], eax  ; p = &num

int arr[10];
&arr;  // 类型是int(*)[10]（数组指针）

#include <stdio.h>
#include <stdint.h>

void mem_inspect(void *ptr, size_t size) {
    uint8_t *p = (uint8_t *)ptr;
    printf("memory at %p:\n", ptr);
    for (size_t i = 0; i < size; i++) {
        printf("%02x ", p[i]);
        if ((i+1) % 8 == 0) printf("\n");
    }
    printf("\n");
}

int main() {
    struct {
        char c;
        int i;
        double d;
    } s = {'a', 42, 3.14};
    
    printf("structure layout analysis:\n");
    printf("size: %zu\n", sizeof(s));
    printf("offsets:\n");
    printf("c: %td\n", (char *)&s.c - (char *)&s);
    printf("i: %td\n", (char *)&s.i - (char *)&s);
    printf("d: %td\n", (char *)&s.d - (char *)&s);
    
    mem_inspect(&s, sizeof(s));
    return 0;
}

int num = 42;
int *p = #
int **pp = &p;

num: 0x1000 [42]
p:   0x2000 [0x1000]
pp:  0x3000 [0x2000]

struct {
    int type;
    union {
        int i;
        float f;
    }; // 匿名联合
} obj;

int *pi = &obj.i; // 直接访问

void copy(int *restrict dst, const int *restrict src, size_t n);

#include <stdalign.h>
alignas(16) int arr[4]; // 16字节对齐
printf("%zu", alignof(arr)); // 获取对齐要求

gcc -g test.c -o test
gdb ./test
(gdb) p &variable
(gdb) x/4xb &array  # 查看内存内容

valgrind --tool=memcheck ./program

clang --analyze test.c

#define print_addr(var) \
    printf("%s at %p (size: %zu)\n", #var, &var, sizeof(var))

#include <time.h>

void test_deref(int *p, size_t n) {
    clock_t start = clock();
    for (size_t i = 0; i < n; i++) {
        *p += i;
    }
    double elapsed = (double)(clock() - start) / clocks_per_sec;
    printf("deref ops/sec: %.2fm\n", n/elapsed/1e6);
}

void safe_write(int *p) {
    if (p == null || (uintptr_t)p % alignof(*p) != 0) {
        // 错误处理
    }
    *p = 42;
}

void array_access(int *arr, size_t len, size_t idx) {
    if (idx >= len) {
        // 错误处理
    }
    arr[idx] = 0;
}

int x = 0x12345678;
uint8_t *p = (uint8_t *)&x;
// p[0]在小端是0x78，大端是0x12

#define gpio_base 0x40020000
typedef struct {
    volatile uint32_t moder;
    volatile uint32_t otyper;
    // ...
} gpio_typedef;

gpio_typedef *gpioa = (gpio_typedef *)gpio_base;
gpioa->moder |= 0x01; // 配置引脚模式

void *mem_pool[pool_size];
void **free_ptr = &mem_pool[0];

void *alloc_block() {
    void *block = *free_ptr;
    free_ptr = (void **)*free_ptr;
    return block;
}

void register_callback(void (*cb)(int), int *data) {
    g_callback = cb;
    g_callback_data = data;
}

void event_handler(int event) {
    if (g_callback) {
        g_callback(event + *g_callback_data);
    }
}

// c++引用
int x = 10;
int &ref = x;
ref = 20; // x也变为20

// c中必须用指针
int x = 10;
int *p = &x;
*p = 20;

struct data {
    int type;
    char buf[100];
};

// 通过buf地址获取整个结构体指针
char *get_buf_ptr(struct data *d) { return d->buf; }
struct data *get_data_ptr(char *buf) {
    return (struct data *)((char *)buf - offsetof(struct data, buf));
}

typedef struct {
    int type;
    void (*print)(void *);
} object;

void print_int(void *p) { printf("%d\n", *(int *)p); }

object create_int_obj(int value) {
    int *p = malloc(sizeof(int));
    *p = value;
    return (object){.type=1, .print=print_int};
}

typedef struct node {
    int data;
    struct node *next;
} node;

node *head = null;
void append(node **head_ref, int data) {
    node *new_node = malloc(sizeof(node));
    new_node->data = data;
    new_node->next = *head_ref;
    *head_ref = new_node;
}

let x = 42;
let r = &x; // 不可变引用
let mut y = 10;
let m = &mut y; // 可变引用

var x int = 42
p := &x
fmt.println(*p)

std::shared_ptr<int> p = std::make_shared<int>(42);

#include <stdio.h>

void mystery(int **pp, int *p) {
    *pp = p;
    **pp = (*p)++;
}

int main() {
    int a = 5, b = 10;
    int *pa = &a, *pb = &b;
    
    printf("start: a=%d b=%d *pa=%d *pb=%d\n", a, b, *pa, *pb);
    
    mystery(&pa, pb);
    
    printf("after 1: a=%d b=%d *pa=%d *pb=%d\n", a, b, *pa, *pb);
    
    (*pa)++;
    (*pb)++;
    
    printf("after 2: a=%d b=%d *pa=%d *pb=%d\n", a, b, *pa, *pb);
    
    return 0;
}

start: a=5 b=10 *pa=5 *pb=10
after 1: a=5 b=11 *pa=10 *pb=11
after 2: a=5 b=12 *pa=11 *pb=12