调用关联类函数时触发Read access violation错误的原因排查

错误原因解析 #

1. 运行时访问违规（Read access violation） #

问题核心是vector扩容导致的悬空指针：

• std::vector在push_back元素时，若当前容量不足，会重新分配内存，将原有元素拷贝到新内存后释放旧内存。
• 你在第一个循环中，每次向m_temp_bs添加B对象后，立刻将&m_temp_bs[i]存入m_bs。当m_temp_bs扩容时，之前存入m_bs的B*会变成悬空指针（指向已被释放的旧内存）。
• 第一个循环仅调用当前i对应的func()，此时该指针指向的B对象仍在新内存中，暂时有效；但第二个循环遍历所有m_bs元素时，其中已包含指向旧内存的悬空指针。
• 调用悬空指针的func()时，B对象的内存已被释放，其成员m_a（A的引用）底层存储的地址变为垃圾值（0xFFFFFFFFFFFFFFF7）。此时通过该无效引用调用A::get_bs()，会导致非法访问A对象的m_bs，最终触发vector拷贝构造函数中的访问违规。

2. 内联B::func()时的编译错误 #

• 在B的类定义阶段，A仅为前向声明，编译器无法获取A的完整结构（包括成员函数get_bs()的细节）。
• 若将B::func()内联在B类中，函数内的m_a.get_bs()需要访问A的完整定义，前向声明无法满足这一要求，因此编译器报错Use of undefined type 'A'。

解决方法 #

针对运行时访问违规 #

需确保m_bs中存储的指针始终指向有效对象，以下是两种可行方案：

方案1：提前预留m_temp_bs的容量

在A构造函数开始时调用reserve()，提前分配足够内存，避免后续push_back触发扩容：

A() {
    m_temp_bs.reserve(10); // 提前预留10个元素的容量，防止扩容
    for (int i = 0; i < 10; i++) {
        m_temp_bs.push_back(B(*this));
        m_bs.push_back(&m_temp_bs[i]);
        m_bs[i]->func();
    }
    for (int i = 0; i < 10; i++) {
        m_bs[i]->func(); // 可正常运行
    }
}

方案2：改用智能指针存储B对象

放弃m_temp_bs，直接用std::unique_ptr存储B对象，避免扩容导致的地址失效：

#include <vector>
#include <memory>

class A;

class B {
public:
    B(A &a) : m_a(a) {}
    ~B() {}
    void func();
    B &operator=(const B &b) { return *this; };
private:
    A &m_a;
};

class A {
public:
    A() {
        for (int i = 0; i < 10; i++) {
            m_bs.push_back(std::make_unique<B>(*this));
            m_bs[i]->func();
        }
        for (int i = 0; i < 10; i++) {
            m_bs[i]->func();
        }
    }
    ~A() {}
    std::vector<std::unique_ptr<B>> get_bs() { return m_bs; }
private:
    std::vector<std::unique_ptr<B>> m_bs = {};
};

void B::func() {
    auto bs = m_a.get_bs();
}

int main() {
    A a; // 直接初始化，避免不必要的拷贝
}

针对内联B::func()的编译错误 #

若要内联func()，需将其实现放在A的完整定义之后：

#include <vector>

class A;

class B {
public:
    B(A &a) : m_a(a) {}
    ~B() {}
    inline void func(); // 仅声明为inline
    B &operator=(const B &b) { return *this; };
private:
    A &m_a;
};

class A {
public:
    A() {
        m_temp_bs.reserve(10);
        for (int i = 0; i < 10; i++) {
            m_temp_bs.push_back(B(*this));
            m_bs.push_back(&m_temp_bs[i]);
            m_bs[i]->func();
        }
        for (int i = 0; i < 10; i++) {
            m_bs[i]->func();
        }
    }
    ~A() {}
    std::vector<B*> get_bs() { return m_bs; }
private:
    std::vector<B> m_temp_bs = {};
    std::vector<B*> m_bs = {};
};

// 此时A已完成定义，可内联实现func()
inline void B::func() {
    std::vector<B*> bs = m_a.get_bs();
}

int main() {
    A a;
}

内容的提问来源于stack exchange，提问作者Edward Green