指针：从 C 到 C++

#include <stdio.h>

int main(void) {
    int x = 10;

    printf("x 的值  ：%d\n", x);
    printf("x 的地址：%p\n", (void*)&x);
    printf("x 占字节：%zu\n", sizeof(x));
    return 0;
}

#include <stdio.h>

int main(void) {
    int x = 10;
    int *p = &x;         // p 是指针，里面装的是 x 的地址

    printf("%d\n", *p);  // 10 —— 解引用：取出 p 指向的那个值
    *p = 99;             // 通过 p 去改 x
    printf("%d\n", x);   // 99 —— x 真的变了
    return 0;
}

int    x = 10;
double d = 3.14;
char   c = 'A';

int    *pi = &x;
double *pd = &d;
char   *pc = &c;

// 在常见的 64 位电脑上：sizeof(x)=4, sizeof(d)=8, sizeof(c)=1
// 而 sizeof(pi) == sizeof(pd) == sizeof(pc)，通常都是 8
// 具体结果以你电脑上 sizeof 的输出为准

#include <stdio.h>

void swapWrong(int a, int b) {
    int t = a; a = b; b = t;    // 换的是两份拷贝
}

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

int main(void) {
    int m = 1, n = 2;

    swapWrong(m, n);
    printf("%d %d\n", m, n);    // 1 2 —— 没换成

    swap(&m, &n);               // 把地址交出去
    printf("%d %d\n", m, n);    // 2 1 —— 换成了
    return 0;
}

int *p = NULL;        // 明确表示“暂时不指向任何东西”

if (p != NULL) {      // 用之前先检查
    printf("%d\n", *p);
}

// 如果 p 是 NULL 还直接写 *p，会触发未定义行为；常见结果是段错误

int arr[5] = {10, 20, 30, 40, 50};
int *p = arr;               // 这里 arr 会转换为首元素地址

printf("%d\n", *p);         // 10
printf("%d\n", *(p + 1));   // 20 —— +1 跳过一个 int，也就是 sizeof(int) 字节
printf("%d\n", p[2]);       // 30 —— p[i] 就是 *(p + i) 的简写

// 反过来也成立：arr[3] 的真实含义，就是 *(arr + 3)

void printAll(int arr[], int n) {   // 形参写成 []，实际仍会调整为指针
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
}

int main(void) {
    int nums[5] = {1, 2, 3, 4, 5};
    printAll(nums, 5);      // 长度必须自己传进去
    return 0;
}

#include <stdio.h>
#include <string.h>

int main(void) {
    char s[] = "hi";        // 内存里是 'h' 'i' '\0'，一共三个字节

    printf("%zu\n", strlen(s));        // 2 —— 从头一个个数到 '\0' 为止
    printf("%c\n", *s);               // h
    printf("%c\n", s[1]);             // i
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int n;
    printf("要几个数：");
    if (scanf("%d", &n) != 1 || n <= 0) {
        printf("请输入正整数\n");
        return 1;
    }

    int *arr = malloc((size_t)n * sizeof *arr); // C 会自动把 void* 转成目标指针类型
    if (arr == NULL) {                          // 申请仍然可能失败，必须检查
        printf("内存不够\n");
        return 1;
    }

    for (int i = 0; i < n; i++) {
        arr[i] = i * i;
    }
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }

    free(arr);      // 用完必须还回去
    arr = NULL;     // 顺手置空，防止后面误用
    return 0;
}

int *p = malloc(sizeof *p);
if (p == NULL) {
    return 1;
}

free(p);
*p = 10;      // 释放后继续使用：未定义行为
free(p);      // 二次释放：也是未定义行为

// 还有一种不崩溃、但更阴险的：
// 申请了从来不 free —— 内存泄漏，程序跑得越久占得越多

void swap(int& a, int& b) {    // 引用：不用星号
    int t = a;
    a = b;
    b = t;
}

int main() {
    int m = 1, n = 2;
    swap(m, n);                // 也不用取地址，直接传变量
    std::cout << m << " " << n << std::endl;   // 2 1
    return 0;
}

int n;
if (!(std::cin >> n) || n <= 0) {
    return 1;
}

int* arr = new int[n];     // 不用 sizeof，不用强制类型转换

for (int i = 0; i < n; i++) {
    arr[i] = i * i;
}

delete[] arr;              // new[] 配 delete[]，new 配 delete
arr = nullptr;

#include <iostream>
#include <vector>

int main() {
    int n;
    if (!(std::cin >> n) || n <= 0) {
        return 1;
    }

    std::vector<int> arr(n);       // 要多大给多大

    for (int i = 0; i < n; i++) {
        arr[i] = i * i;
    }
    // 没有 free，没有 delete —— 离开作用域自动释放
    return 0;
}

#include <iostream>
#include <memory>

int main() {
    std::unique_ptr<int> p = std::make_unique<int>(42);

    std::cout << *p << std::endl;   // 42 —— 用起来和普通指针一样

    // main 结束，p 自动把那块内存 delete 掉，想忘也忘不了
    return 0;
}