指针的类型与地址值#

指针变量存储的是一个地址值，这个地址值本身的大小（通常是4字节或8字节，取决于系统架构）与指针指向的数据类型无关。

#include<iostream>

int main(){
    int var = 23;
    void* generic_ptr = &var; // void* 可以存储任何类型对象的地址
    int* int_ptr = &var;      // int* 存储int类型对象的地址

    // 打印地址值（通常以十六进制显示）
    std::cout << "Address stored in generic_ptr: " << generic_ptr << std::endl;
    std::cout << "Address stored in int_ptr: " << int_ptr << std::endl;
    std::cout << "Address of var: " << &var << std::endl;

    return 0;
}

如下示例中，即使我们将 int 类型变量的地址强制转换为 double* 类型指针，该指针存储的地址值仍然是 var 的原始地址。

#include<iostream>

int main(){
    int var = 23;
    // 将int*强制转换为double*。注意：通过这种方式解引用ptr来访问数据是未定义行为，
    // 因为var实际是int类型，而我们试图按double类型解释它。
    // 这里仅为说明指针存储的地址值不受类型转换影响。
    double* ptr = reinterpret_cast<double*>(&var);

    std::cout << "Address of var: " << &var << std::endl;
    std::cout << "Address stored in ptr (after cast): " << ptr << std::endl;
    return 0;
}

我们会发现，无论指针被声明为什么类型（例如 int* 或 double*），它所存储的变量 var 的内存地址值本身是相同的。这进一步证明了指针的类型主要是为了辅助程序员和编译器理解如何解释该地址处的数据（即解引用时读取多少字节以及如何解释这些字节），而不是改变地址本身。

C++提供了比C语言更安全的强制类型转换方式，如 static_cast, dynamic_cast, reinterpret_cast, const_cast。对于不相关的指针类型之间的转换，通常使用 reinterpret_cast，但需谨慎，因为它可能导致未定义行为。

当我们对一个指针进行解引用操作（使用 *）时，指针的类型就变得至关重要了。它告诉编译器应该从该内存地址开始读取多少字节（例如，int 通常是4字节，double 通常是8字节），并如何将这些字节解释为一个有意义的数值。

我们也可以使用指针动态分配内存，例如使用 new 关键字分配一块指定大小的字符数组（缓冲区）：

#include<iostream>
#include<cstring> // For memset

int main(){
    // 动态分配一个包含8个char的数组
    char* buffer = new char[8];
    // 将缓冲区所有字节初始化为0
    // 注意：sizeof(buffer) 会得到指针本身的大小（如4或8字节），而不是数组的大小。
    // 这里应明确使用分配时的大小。
    memset(buffer, 0, 8);

    // ptr_to_buffer 是一个指向指针的指针（二级指针）
    char** ptr_to_buffer = &buffer;
    std::cout << "Buffer allocated at: " << (void*)buffer << std::endl; // 打印buffer地址
    std::cout << "ptr_to_buffer points to: " << ptr_to_buffer << " which stores: " << *ptr_to_buffer << std::endl;


    delete[] buffer; // 释放动态分配的数组内存，防止内存泄漏
    buffer = nullptr; // 良好实践：将悬垂指针设为nullptr
    return 0;
}

2.1 引用不可重定向#

引用在初始化后，就不能再“转向”去引用另一个不同的变量。这与指针不同，指针可以在其生命周期内指向不同的内存地址。

就像你有好几个好朋友，但是你能把好朋友A的别名冠给好朋友B吗？这本身算是一种不礼貌的行为，我们的Cpp是一位绅士，拒绝这种情况的发生。

#include<iostream>

int main(){
    int a = 5;
    int b = 8;

    int& ref = a; // 'ref' 初始化为 'a' 的引用。
    std::cout << "a = " << a << ", ref = " << ref << std::endl;

    // int& ref = b; // 编译错误！引用不能被重新声明或重定向到另一个变量。

    ref = b;       // 这不是重定向！这是赋值操作。
                   // 'ref' 仍然是 'a' 的别名，所以这条语句等同于 a = b;
                   // 'a' 的值现在变成了 8。
    std::cout << "After 'ref = b;':" << std::endl;
    std::cout << "a = " << a << std::endl;     // 输出 a = 8
    std::cout << "b = " << b << std::endl;     // 输出 b = 8
    std::cout << "ref = " << ref << std::endl; // 输出 ref = 8 (因为ref是a的别名)

    return 0;
}

引用一旦被初始化绑定到一个对象，它就会一直引用该对象，不能再被重新绑定到另一个对象。这种特性类似于一个常量指针（Type* const pointerName），即指针本身存储的地址不能改变。

然而，除非引用本身是常量引用（const Type&），否则我们仍然可以通过引用来修改它所引用的对象的值。

2.2 值传递 (Pass-by-value) 与引用传递 (Pass-by-reference)#

在函数调用时，参数传递的方式对函数能否修改外部变量至关重要。

值传递 (Pass-by-value):

#include<iostream>

// val 是通过值传递的，函数内部的val是外部实参的一个副本
void IncrementByValue(int val){
    val++; // 修改的是副本，不影响外部变量
    std::cout << "Inside IncrementByValue, val = " << val << std::endl;
}

// 辅助打印函数 (避免与 std::log 冲突)
void LogValue(int val){
    std::cout << "Value: " << val << std::endl;
}

int main(){
    int a = 5;
    IncrementByValue(a);
    LogValue(a); // 输出 Value: 5，a的值未改变
    return 0;
}

我们会发现打印出来的数值仍然是5，并没有增加。这是因为在 IncrementByValue 函数中，参数 val 是通过“值传递”（Pass-by-value）的方式传入的。

这意味着函数内部的 val 是原始变量 a 的一个副本（copy）。对这个副本的修改，并不会影响到函数外部的原始变量 a。当我们需要在函数内部修改外部变量的值时，值传递就显得不够用了。

这时，我们就需要采用“引用传递”（Pass-by-reference）或通过指针传递地址的方式。

通过指针传递 (Pass-by-pointer):

#include<iostream>

// val_ptr 是一个指向int的指针
void IncrementByPointer(int* val_ptr){
    if (val_ptr) { // 检查指针是否有效
        (*val_ptr)++; // 解引用指针，修改指针指向的原始数据
    }
}

void LogValue(int val){
    std::cout << "Value: " << val << std::endl;
}

int main(){
    int a = 5;
    IncrementByPointer(&a); // 传递a的地址
    LogValue(a); // 输出 Value: 6，a的值已改变
    return 0;
}

通过引用传递 (Pass-by-reference):

#include<iostream>

// val_ref 是一个int的引用
void IncrementByReference(int& val_ref){
    val_ref++; // 直接修改val_ref，就是修改它引用的原始数据
}

void LogValue(int val){
    std::cout << "Value: " << val << std::endl;
}

int main(){
    int a = 5;
    IncrementByReference(a); // 传递a本身，函数接收的是a的引用
    LogValue(a); // 输出 Value: 6，a的值已改变
    return 0;
}

通过引用传递，代码看起来比指针传递更简洁，因为不需要显式的解引用（*）和取地址（&）操作（在调用处）。编译器在编译后生成的代码通常与指针版本非常相似。