1.3 C/C++ 指针、引用（重头戏）

一、数组指针和指针数组的区别

数组指针：int （*ptr）[10]；指针数组：int * ptr[10]

二、函数指针和指针函数的区别

函数指针：int （*ptr）（int，int）；指针函数：int * ptr（int，int）

三、数组名和指针的区别

数组名是常量，不可以改值；指针是变量，可以改值；

数组名使用的时候会隐式转换为第一个元素的地址，只有 &数组名 才表示整个数组的起始地址。

四、为什么要字节对齐

优化存储器访问速度：硬件架构要求数据按特定边界进行存储，可以提高内存访问效率，否则就可能需要额外的访问次数。

五、 结构体内存对其规则

1、每个成员的起始地址必须是该成员类型大小的整数倍。（成员变量对齐）

2、结构体的总大小必须是结构体中最大对齐边界的整数倍。（结构体整体对齐）

struct BBB {
    long num;
    char *name;
    short int data;
    char ha;
    short ba[5];
};
// 4+4+2+1+1个空白字节+2*5=22个字节 第一个规则
// 因为最大对其边界是4,所以是24字节。

六、注意指针加法和数值加法区别

指针加法：p+0x20 = p + sizeof（p的类型）×0x20；

七、指针常量、常量指针、指向常量的常量指针区别？

指针常量：int * const ptr；

常量指针：const int * ptr；

指向常量的常量指针：const int * const ptr；

八、有常量引用，但没引用常量

因为引用本身就是常量，一旦绑定到一个对象后，不能再绑定到其他对象。

c++ 也不允许 int& const 这种写法。

九、指针和引用的区别？

1、指针是实体，是一个变量；引用是别名，不占额外存储空间，由编译器实现替代；

2、 指针和引用的自增运算符意义不同，指针是加 sizeof（类型），引用是对引用的变量值自增。

3、引用使用无需解引用，指针需要；

4、引用本质上是个指针常量，只能在定义时被初始化。

5、引用不能为空，指针可以；

6、sizeof 引用 返回的是引用的变量的类型大小；sizeof 指针 返回的是指针类型的大小（4）。

十、指针不能指向引用，但可以有指针的引用

因为引用本身就是一个逻辑概念，不是物理实体，没有地址，自然无法取地址给指针。

因为指针本身就是一个实体，是变量。所以可以引用。

十一、 野指针是什么

在指针定义之后，没有将其指向其他变量或内存，也没有将其赋值为 NULL

当指针指向的内存空间被释放后，没有将其赋值为 NULL（悬空指针）

十二、 如何避免野指针

1、指针在使用前对其赋值 NULL。

2、指针用完后释放内存，将指针赋值为 NULL。

3、当指针指向 malloc 申请的内存时，需要检查内存是否申请成功。

十三、NULL 和 nullptr 区别

NULL 作为宏定义，它可能被错误地解释为整型 0，可能会导致二义性问题。

nullptr 是一个专门的空指针类型，类型为 std::nullptr_t，因此避免了 NULL 所引起的二义性。

NULL 可以在整型上下文中使用（例如传递给整型函数），但 nullptr 只能用于指针上下文。

void func(int) {
    cout << "Function with int argument"<< endl;
}
void func(char*){
    cout << "Function with char* argument"<< endl;
}
int main(){
    int* ptr1 = NULL;  // NULL用法,指针初始化为空
    int* ptr2 = nullptr;  //nullptr用法,指针初始化为空
    
    cout << "ptr1: "<< ptr1 << endl; // //打印 NULL指针的地址
    cout <<"ptr2:"<< ptr2<<endl; //打印 nullptr 指针的地地址

    //使用NULL和nullptr进行函数调用
    func(NULL);  //这里NULL会导致二义性而报错
    
    func(nullptr);  //这里会调用func(char*),因为nullptr是一个空指针
    return 0;
}

十四、使用一级指针无法解决的问题

传入一级指针只可以修改指针指向内存的内容，但无法修改指针本身的值，因为指针本身传入的时候也是临时变量，只是里面存放的地址和实参一样。

#include <stdio.h>
#include <stdlib.h>
//正确的函数声明,接收 int*类型的指针
void wrongFunction(int *ptr) {
    ptr = (int*)malloc(sizeof(int)); //修改指针,但不能影响外部指抖
    *ptr = 42;
}
int main() {
    int* ptr = NULL;//初始化为NULL

    //调用函数时,确保传递的是一个 int*类型的指针
    wrongFunction(ptr);

    //检查ptr是否改变
    if (ptr == NULL) {
        printf("Pointer is still NULL, memory was not allocatedin wrongFunction.\n");
    } else {
        printf("Pointer points to: %d\n",*ptr);//这行不会被执入行
    }
    return 0;
}

使用二级指针

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

//正确的函数声明,接收 int **类型的指针
void correctFunction(int **ptr) {
    *ptr=(int*)malloc(sizeof(int)); //修改外部指针
    **ptr=42; //修改堆内存中的值
}

int main() {
    int*ptr=NULL;//初始化为NULL

    //调用正确的函数,传入二级指针
    correctFunction(&ptr);
    //检查ptr是否改变
    if (ptr != NULL) {
        printf("Pointer points to: %d\n",*ptr); //输出 42
        free(ptr);//释放堆内存
    }
    return 0;
}

十五、C++ 中的智能指针是什么

智能指针为了解决野指针、重复释放、内存泄露问题而被发明。

智能指针是一个类，常用的有 unique_ptr、shared_ptr、weak_ptr。（注意 auto_ptr 因为安全问题已经在 C++17 中移除了）

unique_ptr 每个 unique_ptr 独占一块内存，不允许被赋值，但可以通过 std::move() 转交所有权，此时原来的 unique_ptr 变为了 nullptr；当 unique_ptr 被销毁时，其指向的对象实例会被自动调用析构函数进行释放，没有引用计数。

在多线程环境中将一个 unique_ptr的资源所有权从一个线程转移到另一个线程时，必须通过线程同步机制（如互斥锁、原子操作等）保证这一操作的安全性。

shared_ptr 是一种共享所有权的智能指针。通过引用计数的方式可以使多个 shared_ptr 指针指向同一块内存区域，只有计数值为 1 的时候，释放指针才会真正释放内存，引用计数是原子操作的（线程安全）。

shared_ptr 大小为 2 个指针大小：一个是原始指针；一个指向控制快。

template <class T>
class shared_ptr {
public:
    shared_ptr(T* ptr = nullptr)
        : ptr_(ptr), block_(nullptr) {
        if (ptr_) {
            block_ = new ControlBlock;
            block_->refcnt.store(1);
        }
    }
    ~shared_ptr() {
        release();
    }
    shared_ptr(const shared_ptr& sp)
        : ptr_(sp.ptr_), block_(sp.block_) {
        if (block_) block_->refcnt.fetch_add(1, std::memory_order_relaxed);
    }
    shared_ptr& operator=(const shared_ptr& sp) {
        if (this != &sp) {
            release();
            ptr_ = sp.ptr_;
            block_ = sp.block_;
            if (block_) block_->refcnt.fetch_add(1, std::memory_order_relaxed);
        }
    }
    shared_ptr(shared_ptr&& other)
        : ptr_(other.ptr_), block_(other.block_) {
        other.ptr_ = nullptr;
        other.block_ = nullptr;
    }
    shared_ptr& operator=(shared_ptr&& other) {
        if (this != &other) {
            release();
            ptr_ = other.ptr_;
            block_ = other.block_;
            other.ptr_ = nullptr;
            other.block_ = nullptr;
        }
        return *this;
    }

    T& operator*() {
        return *ptr_;
    }
    T* operator->() {
        return ptr_;
    }

    T* get() const {
        return ptr_;
    }

    long use_count() const {
        return block_->refcnt.load();
    }

    void reset(T* ptr = nullptr) {
        if (ptr_ != ptr) {
            release();
            if (ptr) {
                block_ = new ControlBlock();
                block_->refcnt.store(1);
                ptr_ = ptr;
            } else {
                block_ = nullptr;
                ptr_ = nullptr;
            }
        }
    }

    void swap(shared_ptr& other) {
        std::swap(ptr_, other.ptr_);
        std::swap(block_, other.block_);
    }

private:
    void release() {
        if (block_) {
            if (block_->refcnt.fetch_sub(1, std::memory_order_acq_rel) == 1) {
                delete ptr_;
                delete block_;
            }
            ptr_ = nullptr;
            block_ = nullptr;
        }
    }

    struct ControlBlock {
        std::atomic<long> refcnt{0};
    };

    T* ptr_ {nullptr};
    ControlBlock* block_ {nullptr};
};

weak_ptr 是一种不共享所有权的指针，用于解决循环引用的问题，不会增加引用计数，也不会阻止所指内容被销毁。

十六、shared_ptr 是线程安全的吗？

不是。

引用计数的更改是安全的，因为是原子操作，要么执行完毕，要么不执行。

但多个线程的拷贝、释放不是安全的，因为内部 ptr 指向的更改、引用计数的修改，两者是分步执行的，不是原子的。需要加锁。

十七、 智能指针是怎么释放的？

1、unique_ptr

• 当 unique_ptr 离开作用域（如函数结束、块作用域结束）时，它管理的对象会被自动释放。
• 如果显式调用 reset() 或赋值为 nullptr，也会立即释放对象。
• 如果 unique_ptr 被 std::move 转移所有权，原指针变为 nullptr，新指针接管所有权。

2、shared_ptr

• 当最后一个持有对象的 shared_ptr 被销毁或 reset() 时，对象才会被释放。
• 引用计数（use_count()）降为 0 时触发释放。

3、weak_ptr：仅观察，不释放。

十八、如何把 shared_ptr 转给 unique_ptr？

只有当共享指针的引用计数为 1（即没有其他共享指针指向该对象）时，才能安全地转换。

#include <memory>

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

// 检查引用计数是否为1
if (shared.use_count() == 1) {
    std::unique_ptr<int> unique = std::unique_ptr<int>(shared.get()); // 裸指针
    shared.reset();  // 必须手动释放shared_ptr的所有权
    // 现在unique独占所有权
} else {
    // 不能转换，因为有其他shared_ptr共享所有权
}

十九、循环引用

循环引用指的是两个或多个对象之间相互持有对方的引用，形成一个闭环。当使用智能指针（如 std::shared_ptr）时，这种循环引用会导致资源无法正常释放，进而造成内存泄漏。

#include <iostream>
#include <memory>

class B;  // 前向声明

class A {
public:
    std::shared_ptr<B> b_ptr;
    ~A() { std::cout << "A destroyed" << std::endl; }
};

class B {
public:
    std::shared_ptr<A> a_ptr;
    ~B() { std::cout << "B destroyed" << std::endl; }
};
int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    // 此时创建了一个 A 类型的对象，并且由 std::shared_ptr a 管理。
    // A 对象的引用计数为 1，因为只有 a 指向它。

    std::shared_ptr<B> b = std::make_shared<B>();
    // 此时创建了一个 B 类型的对象，并且由 std::shared_ptr b 管理。
    // B 对象的引用计数为 1，因为只有 b 指向它。

    a->b_ptr = b;
    // a 对象中的成员变量 b_ptr 指向了 b 所管理的 B 对象。
    // 此时 B 对象的引用计数变为 2，因为 b 和 a->b_ptr 都指向它。

    b->a_ptr = a;
    // b 对象中的成员变量 a_ptr 指向了 a 所管理的 A 对象。
    // 此时 A 对象的引用计数变为 2，因为 a 和 b->a_ptr 都指向它。

    return 0;
    // 当 main 函数结束时，局部变量 a 和 b 超出作用域。
    // a 超出作用域，A 对象的引用计数减 1，但由于 b->a_ptr 仍然指向 A 对象，所以 A 对象的引用计数变为 1。
    // b 超出作用域，B 对象的引用计数减 1，但由于 a->b_ptr 仍然指向 B 对象，所以 B 对象的引用计数变为 1。
    // 由于 A 对象和 B 对象的引用计数都不为 0，它们不会被销毁，从而造成内存泄漏。
    // 但程序退出后，系统依然能够回收该程序所占用的所有内存资源。因为操作系统在进程终止时，会清理该进程的所有资源，包括虚拟内存空间、文件描述符等。
}

二十、如何避免 shared_ptr 循环引用（这个在我实习面试的时候真考了）

为了解决循环引用问题，可以使用std::weak_ptr。std::weak_ptr是一种不控制对象生命周期的智能指针，它指向由std::shared_ptr管理的对象，但不会增加对象的引用计数。

#include <iostream>
#include <memory>

class B;  // 前向声明

class A {
public:
    std::shared_ptr<B> b_ptr;
    ~A() { std::cout << "A destroyed" << std::endl; }
};

class B {
public:
    std::weak_ptr<A> a_ptr;  // 使用 std::weak_ptr
    ~B() { std::cout << "B destroyed" << std::endl; }
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    // 此时创建了一个 A 类型的对象，并且由 std::shared_ptr a 管理。
    // A 对象的引用计数为 1，因为只有 a 指向它。

    std::shared_ptr<B> b = std::make_shared<B>();
    // 此时创建了一个 B 类型的对象，并且由 std::shared_ptr b 管理。
    // B 对象的引用计数为 1，因为只有 b 指向它。

    a->b_ptr = b;
    // a 对象中的成员变量 b_ptr 指向了 b 所管理的 B 对象。
    // 此时 B 对象的引用计数变为 2，因为 b 和 a->b_ptr 都指向它。

    b->a_ptr = a;
    // b 对象中的成员变量 a_ptr 是 std::weak_ptr 类型，它指向 a 所管理的 A 对象。
    // 但由于 std::weak_ptr 不会增加对象的引用计数，所以 A 对象的引用计数仍然为 1。

    return 0;
    // 当 main 函数结束时，局部变量 a 和 b 超出作用域。
    // a 超出作用域，A 对象的引用计数减 1，变为 0。此时 A 对象被销毁，A 的析构函数被调用，输出 "A destroyed"。
    // 随着 A 对象被销毁，a->b_ptr 不再指向 B 对象，B 对象的引用计数减 1，变为 1。
    // b 超出作用域，B 对象的引用计数再减 1，变为 0。此时 B 对象被销毁，B 的析构函数被调用，输出 "B destroyed"。
}