指针与动态分配

int int_num = -1; float float_num = 1.0;
/* sizeof 作为一个运算符，可以用于获取对象类型的内存存储大小
 * printf %#x 将数字按照16进制打印并且包含前缀
 * 通过打印16进制的方式，直接打印出数据在内存中存储的数值
 * 直接打印出 -1 在内存中存储的二进制数值
 * 通过 *(int*)& ，对数值重新进行解释
 * 从而打印出 1.0 在内存中存储的二进制数值
 * 你将在本节学习 *(int*)& 的语法细节
 */
printf("sizeof int_num: %zu, value: %#x\n"
       "sizeof float_num: %zu, value: %#x\n",
        sizeof int_num, int_num, sizeof float_num,
        *(int *)&float_num);

sizeof int_num: 4, value: 0xffffffff
sizeof float_num: 4, value: 0x3f800000

printf("addr of int_num: %p, addr of float_num: %p\n", &int_num, &float_num);

addr of int_num: 0x7fff017eb4d0, addr of float_num: 0x7fff017eb4d4

void swap(int a, int b) {
  int tmp = a; a = b; b = tmp;
}

int main(void) {
  int x = 114, y = 514;
  printf("Before swap: x=%d, y=%d\n", x, y);
  swap(x, y); printf("After swap: x=%d, y=%d\n", x, y);
  return 0;
}

Before swap: x=114,y=514
After swap: x=114,y=514

int x = 114514;
int *ptr = &x;
printf("x:[%d] *ptr:[%d]\n", x, *ptr);
*ptr = 1919810;
printf("x:[%d] *ptr:[%d]\n", x, ptr[0]);

x:[114514] *ptr:[114514]
x:[1919810] *ptr:[1919810]

int x[5] = {0, 1, 2, 3, 4};
int *p = &a[0];
printf("%x %x\n", p, p + 3);
// 可能的结果： ffffd7f0 ffffd7fc
// ffffd7f0 + 3 * sizeof(int) -> ffffd7fc
int *p1 = &x[0], *p2 = &x[4];
printf("%d %d\n", p1 - p2, p2 - p1);
// 输出： -4 4

int a[5] = {0, 1, 2, 3, 4};
int *ptr = a;
printf("%zu %zu\n", sizeof a, sizeof ptr);
printf("%d %d\n", *(ptr+2), a[2]);

int a[3] = {0, 1, 2};
int (*ptr)[3] = &a;
printf("%zu %zu\n", sizeof a, sizeof ptr);
//输出：12 8

/* 结构体定义：引入一个新类型 struct 名字 并定义其含义 */
struct IntVector {
  /* 结构体成员 */
  int *data;
  size_t size;
  size_t capacity;
};  // 记得末尾的 `;`
/* 结构体变量 */
struct IntVector vector = {.data = NULL, .size = 0, .capacity = 0};
/* 通过成员运算符`.`访问结构体成员 */
printf("%p, %zu, %zu", vector.data, vector.size, vector.capacity);
/* 结构体指针 */
struct IntVector *v_p = &vector;
/* 结构体指针通过成员运算符`->`访问对象成员 */
printf("%p, %zu, %zu", v_p->data, v_p->size, v_p->capacity);

/* 声明 int_t 为类型 int 的别名 */
typedef int int_t;
typedef char char_t, str_t[10], *char_p, (*fp)(void);
char_t ch = 'a'; // 声明 char_t 为类型 char 的别名
str_t str = "abcdefg"; // str_t 为 char[10] 的别名
char_p ch_p = &ch; // char_p 为 char* 的别名
char function(void) { return 'a'; }
fp ch_fp = &function; // fp 为 char(*)(void) 的别名
/* 声明 IntVector 为匿名结构体的别名 */
typedef struct {
  int *data;
  size_t size;
  size_t capacity;
} IntVector;
IntVector vector = {.data = NULL, .size  = 0, .capacity = 0};

typedef char str_t[];
/* 此时 s 的类型为 char[13] */
str_t s = "hello world\n";

#include <stdint.h>
#include <inttype.h>
int main(void) {
    printf("%zu\n", sizeof(int64_t));
    printf("%s\n", PRId64);
    printf("%+" PRId64 "\n", INT64_MIN);
    printf("%+" PRId64 "\n", INT64_MAX);
    int64_t n = 7;
    printf("%+" PRId64 "\n", n);
}

#include <stdio.h>
#include <stdlib.h>
void test(void) {
  int* a = malloc(1000000);
  printf("%p\n", a);
}
int main(void) {
  while (1) {
    test();
  }
  return 0;
}

int *ptr1, *ptr2 = (int *)0x11451400;
printf("%d %d\n", *ptr1, *ptr2); // ERROR

int *ptr = malloc(sizeof(int));
free(ptr);
printf("%d\n", *ptr); // ERROR

int a[5];
int *ptr = &a[4];
ptr += 1;
printf("%d\n", *ptr); //ERROR

int *ptr = NULL;
int sum = 0;

/* 在理论上指针不应该为空的地方使用assert保证指针非空 */
assert(ptr != NULL);
if(*ptr > 0) { sum += *ptr; }

/* 在正常情况下指针可能为空的地方，在解引用指针前对指针特判 */
if(ptr == NULL) { return; }
if(*ptr > 0) { sum += *ptr; }

/* 也可以利用逻辑运算符的[短路特性](https://zh.cppreference.com/w/c/language/operator_logical) */
if(ptr != NULL && *ptr > 0) { sum+=*ptr; }

typedef struct {
  int *data;       // 指向整数数组的指针
  size_t size;     // 当前元素数量
  size_t capacity; // 数组的当前容量（已分配的内存大小）
} IntVector;

void initVector(IntVector *vec) {
  vec->size = 0;
  vec->capacity = 4;
  vec->data = malloc(vec->capacity * sizeof(int));
}

void pushBack(IntVector *vec, int value) {
  // 检查是否需要扩容
  if (vec->size >= vec->capacity) {
    vec->capacity *= 2; // 将容量翻倍
    // 重新分配内存
    int *new_data = realloc(vec->data,
                            vec->capacity * sizeof(int));
    vec->data = new_data;
  }
  vec->data[vec->size] = value; // 添加新元素
  vec->size++;                  // 更新当前元素数量
}

int get(IntVector *vec, size_t index) {
  assert(index < vec->size); // 检查索引是否越界
  return vec->data[index];   // 返回指定索引的元素
}

void freeVector(IntVector *vec) {
  free(vec->data);  // 释放动态分配的数组
  vec->data = NULL; // 避免悬空指针
  vec->size = 0;
  vec->capacity = 0;
}

void printVector(IntVector *vec) {
  printf("IntVector (size = %zu, capacity = %zu):",
         vec->size, vec->capacity);
  for (size_t i = 0; i < vec->size; i++) {
    printf(" %d", vec->data[i]);
  }
  printf("\n");
}

int main(void) {
  IntVector vec;
  initVector(&vec);     // 初始化向量
  // 添加元素到向量
  for (int i = 0; i < 10; i++) {
    pushBack(&vec, i);
  }
  printVector(&vec);    // 打印向量内容
  // 获取和打印特定索引的元素
  for (size_t i = 0; i < vec.size; i++) {
    printf("Element at index %zu: %d\n", i, get(&vec, i));
  }
  // 释放向量的内存
  freeVector(&vec);
  return 0;
}

typedef struct Node{
  int elem;                   //代表数据域
  struct Node * next;         //代表指针域，指向直接后继元素
} Node;
// 头指针指向 malloc 分配的头结点/首元结点
Node *head = malloc(sizeof(Node));
head->elem = 0;     // 头结点数据域存储链表元素个数。
head->next = NULL;  // 初始头结点/首元结点的后继元素为空

Node *p = NULL;
while (condition) {
  p = malloc(sizeof(Node));
  p->elem = element;
  p->next = head->next;
  head->next = p;
  head->elem++;
}

Node *r = head;     // r 在尾插法中始终指向最后一个结点
Node *p = NULL;
while (condition) {
  p = malloc(sizeof(Node));
  p->elem = element;
  p->next = NULL;
  r->next = p;
  r = p;
  head->elem++;
}

/* 用 e 返回 list 中第 i 个(从0开始计数)数据元素的值 */
bool GetElem(Node *list, int i, int *e) {
  Node *p;
  p = list->next;           //p 指向首元结点
  int j = 0;
  while (p && j < i) {      //p 不为空或者计数器 j 还没有等于 i 时，循环继续
    p = p->next;            //p 指向下一个结点
    j++;
  }
  if (!p) {                 //第 i 个元素不存在
    return false;
  }
  *e = p->elem;
  return true;
}

/* 在 list 中第 i 个位置之前插入新的数据元素 e */
bool ListInsert(Node *list, int i, int e) {
  Node *p = list;       // p 指向头结点
  int j = 0;
  while (p && j < i) {  // 寻找第 i - 1 个结点，
    p = p->next;
    j++;
  }
  if (!p) {
    return false;
  }
  Node *r = malloc(sizeof(Node));
  r->elem = e;
  r->next = p->next;
  p->next = r;
  list->elem++;
  return true;
}

/* 删除 list 中的第 i 个数据元素，并用 e 返回其值 */
int ListDelete(Node *list, int i, int* e) {
  Node *p = list;
  int j = 0;
  while (p->next && j < i) {              // 寻找删除节点的前驱节点
    p = p->next;
    j++;
  }
  if (!(p->next)) {
    return false;                         // L 中不存在第 i 个元素
  }
  Node *r = p->next;                      // 标记要删除的结点
  p->next = r->next;                      // 移除结点
  *e = r->elem;                           // 返回结点所存数据
  free(r);                                // 释放结点
  return true;
}

void ListDestructs(Node *list) {
  Node *p = list;
  while (p != NULL) { Node *r = p->next; free(p); p = r; }
}