C++ 包含指向A类指针的B类中的A类初始化

我希望类a包含一些数据，而类B将包含指向该数据的指针。我通过返回对数据对象a的引用的函数提供对数据的访问。如果我创建对象B，那么我可以访问对象a，但是如果创建指向B的指针，那么等效操作会产生分段错误。像这样：

#include <iostream>
#include <vector>

class A {
public:
    A(const int pInt) {mInt = pInt;}
    void print() {std::cout << mInt << std::endl;}
private:
    int mInt; //some data
};

class B {
public:
   B() {mP1 = new A(1);} //initialise to 1
   ~B() {delete mP1;}
   A& access() {return *mP1;} //return reference to the data

private:
    A* mP1; //pointer to some data
};

int main() {
    B vB;
    vB.access().print(); //this works.

    B *vBptr;
    vBptr->access().print(); //Segmentation fault!

    std::vector<B*> vVec;
    vVec.resize(1);
    vVec[0]->access().print(); //Segmentation fault!
}

#包括
#包括
甲级{
公众：
A（const int pInt）{mInt=pInt；}
void print（）{std:：cout access（）.print（）；//分段错误！
}

我猜在创建B*vBptr时，B对象没有被初始化？ 那么，如何创建指向自动初始化的B对象的指针向量呢

---

干杯。

您需要初始化指针：

B *vBptr = new B;
vBptr->access().print();

这同样适用于你的向量——你必须迭代元素并初始化它们

for ( int i = 0 ; i < vVec.size() ; i++ )
   vVec[i] = new B;

及

for（int i=0；i

---

不要运行内存泄漏。

您需要初始化指针：

B *vBptr = new B;
vBptr->access().print();

这同样适用于你的向量——你必须迭代元素并初始化它们

for ( int i = 0 ; i < vVec.size() ; i++ )
   vVec[i] = new B;

及

for（int i=0；i

---

不要遇到内存泄漏。

您实际上需要将指针设置为指向以下内容：

B *vBptr;          // bad -- uninitialized 
B *vBptr = new B;  // proper

---

实际上，您需要设置指向某个对象的指针：

B *vBptr;          // bad -- uninitialized 
B *vBptr = new B;  // proper

当然，您创建了一个变量来存储指向B对象的指针，但实际上并没有使其指向B对象。（提示：请参阅您为B类编写的代码，其中使B

a*mP1

指向某个对象？）

std:：vector vVec；
vVec.resize（1）；
vVec[0]->access（）.print（）；//分段错误！

当然，您创建了指向B对象的指针向量，然后调整了向量的大小以添加一个元素；该元素是默认构造的指向B的指针。对于指针类型，默认构造是空指针，因此您也不会指向任何实际的B对象

您的问题与任何A或B实现无关

那么如何创建指向B对象的指针向量呢

你认为你为什么要这样做？仅仅做一个B对象的向量有什么不对

B vB;
vB.access().print();

B *vBptr = &vB; // or B *vBptr = new B;
vBptr->access().print();

std::vector<B*> vVec;
vVec.push_back(&vB);  // vVec.push_back(new B);
vVec[0]->access().print(); 

当然，您创建了一个变量来存储指向B对象的指针，但实际上并没有使其指向B对象。（提示：请参阅您为B类编写的代码，其中使B

a*mP1

指向某个对象？）

std:：vector vVec；
vVec.resize（1）；
vVec[0]->access（）.print（）；//分段错误！

当然，您创建了指向B对象的指针向量，然后调整了向量的大小以添加一个元素；该元素是默认构造的指向B的指针。对于指针类型，默认构造是空指针，因此您也不会指向任何实际的B对象

您的问题与任何A或B实现无关

那么如何创建指向B对象的指针向量呢

---

你认为你为什么要这样做？仅仅做一个B对象的向量有什么不对吗？

你的程序中有两个问题

B vB;
vB.access().print();

B *vBptr = &vB; // or B *vBptr = new B;
vBptr->access().print();

std::vector<B*> vVec;
vVec.push_back(&vB);  // vVec.push_back(new B);
vVec[0]->access().print(); 

B *vBptr;

您的指针尚未初始化，虽然它是类型B的指针，但未指向类型B的有效对象。请将其更改为

B *vBptr = new B();

vVec.resize(1);

此处调整大小不会为向量的每个元素分配存储。您可以通过向向量的调整大小方法提供初始化来使用实际对象初始化元素

vVec.resize(1,new B());

---

你计划中的两个问题

B *vBptr;

您的指针尚未初始化，虽然它是类型B的指针，但未指向类型B的有效对象。请将其更改为

B *vBptr = new B();

vVec.resize(1);

此处调整大小不会为向量的每个元素分配存储。您可以通过向向量的调整大小方法提供初始化来使用实际对象初始化元素

vVec.resize(1,new B());

---

如其他答案中所述，指针变量不会自动为其分配内存，因此您需要手动分配和取消分配内存，如下所示：

B vB;
vB.access().print(); //this works.

B *vBptr = new B;//allocate memory for vBptr
vBptr->access().print();
delete vBptr;//clean up of vBptr
std::vector<B*> vVec;
vVec.push_back(new B);
vVec[0]->access().print(); 
delete vVec[0];

---

如果您需要最小的开销，并且正在使用c++11

std:：unique齌ptr

是您的朋友，否则iirc boost拥有

boost:：unique齌ptr

。只需远离

std:：auto齌ptr

。除非您喜欢增加的复杂性/潜在的bug，或者您的代码性能非常好，否则没有什么理由手动管理内存对性能敏感（并使用非常高效的自定义分配器）。

如其他答案中所述，指针变量不会自动为其分配内存，因此您需要手动分配和取消分配内存，如下所示：

B vB;
vB.access().print(); //this works.

B *vBptr = new B;//allocate memory for vBptr
vBptr->access().print();
delete vBptr;//clean up of vBptr
std::vector<B*> vVec;
vVec.push_back(new B);
vVec[0]->access().print(); 
delete vVec[0];

---

如果您需要最小的开销，并且正在使用c++11

std:：unique齌ptr

是您的朋友，否则iirc boost拥有

boost:：unique齌ptr

。只需远离

std:：auto齌ptr

。除非您喜欢增加的复杂性/潜在的bug，或者您的代码性能非常好，否则没有什么理由手动管理内存对性能敏感（并使用非常高效的自定义分配器）。

感谢所有参与的人。以下是我现在采用的实现，即使用boost:：shared\u ptr：

#include <iostream>
#include <vector>
#include "boost/smart_ptr.hpp"

class A {
public:
    A(const int pInt) {mInt = pInt;}
    void print() const {std::cout << mInt << std::endl;}
    void set(const int pInt) {mInt = pInt;}
private:
    int mInt; //some data
};

class B {
public:
    B() {}  //leave A pointer as null
    ~B() { } //delete handled by shared_ptr
    A& access() {return *mP1;} //return reference to the data
    boost::shared_ptr<A>& access_A_ptr() {return mP1;} //return the pointer for assignment

private:
    boost::shared_ptr<A> mP1;
};

int main() {

    std::vector< boost::shared_ptr<A> > vVecA; //data to be shared
    for (unsigned int i = 0; i < 5; i++) {
        boost::shared_ptr<A> vAptr(new A(i));
        vVecA.push_back(vAptr);
        vVecA[i]->print();
    }

    vVecA[2]->set(123);

    for (unsigned int i = 0; i < vVecA.size(); i++) {
        vVecA[i]->print(); //changes to the underlying objects are reflected
    }

    boost::shared_ptr<B> vBptr(new B); //make an empty B
    vBptr->access_A_ptr() = vVecA[2]; //assignment of shared pointer

    vBptr->access().print();

    std::cout << "use count of vVecA[1] = " << vVecA[1].use_count() << std::endl; // = 1
    std::cout << "use count of vVecA[2] = " << vVecA[2].use_count() << std::endl; // = 2

    std::vector< boost::shared_ptr<B> > vVecB;

    //vVecB.resize(vVecA.size(), boost::shared_ptr<B> (new B) ); //resize and init to a SINGLE B object, NO!!!

    for (unsigned int i = 0; i < vVecA.size(); i++) {
        vVecB.push_back(boost::shared_ptr<B> (new B)); //filling array with separate empty Bs
        vVecB[i]->access_A_ptr() = vVecA[i];
        vVecB[i]->access().print(); // = 0,1,123,3,4
    }

    vVecA[2]->set(2); //changes to A objects reflected in the B objects

    for (unsigned int i = 0; i < vVecB.size(); i++) {
        vVecB[i]->access().print(); // = 0,1,2,3,4
    }

    std::cout << "use count of vVecA[1] = " << vVecA[1].use_count() << std::endl; // = 2
    std::cout << "use count of vVecA[2] = " << vVecA[2].use_count() << std::endl; // = 3

}

#包括
#包括
#包括“增压/智能水电站”
甲级{
公众：
A（const int pInt）{mInt=pInt；}
void print（）常量{std:：cout print（）；
}
vVecA[2]->组（123）；
for（无符号整数i=0；iprint（）；//反映对底层对象的更改
}
boost:：sharedptrvbptr（新B）；//创建一个空B
vBptr->access_A_ptr（）=vVecA[2]；//共享指针的赋值
vBptr->access（）.print（）；
std:：cout感谢所有贡献者。以下是我现在采用的实现，即使用boost:：shared\u ptr：

#include <iostream>
#include <vector>
#include "boost/smart_ptr.hpp"

class A {
public:
    A(const int pInt) {mInt = pInt;}
    void print() const {std::cout << mInt << std::endl;}
    void set(const int pInt) {mInt = pInt;}
private:
    int mInt; //some data
};

class B {
public:
    B() {}  //leave A pointer as null
    ~B() { } //delete handled by shared_ptr
    A& access() {return *mP1;} //return reference to the data
    boost::shared_ptr<A>& access_A_ptr() {return mP1;} //return the pointer for assignment

private:
    boost::shared_ptr<A> mP1;
};

int main() {

    std::vector< boost::shared_ptr<A> > vVecA; //data to be shared
    for (unsigned int i = 0; i < 5; i++) {
        boost::shared_ptr<A> vAptr(new A(i));
        vVecA.push_back(vAptr);
        vVecA[i]->print();
    }

    vVecA[2]->set(123);

    for (unsigned int i = 0; i < vVecA.size(); i++) {
        vVecA[i]->print(); //changes to the underlying objects are reflected
    }

    boost::shared_ptr<B> vBptr(new B); //make an empty B
    vBptr->access_A_ptr() = vVecA[2]; //assignment of shared pointer

    vBptr->access().print();

    std::cout << "use count of vVecA[1] = " << vVecA[1].use_count() << std::endl; // = 1
    std::cout << "use count of vVecA[2] = " << vVecA[2].use_count() << std::endl; // = 2

    std::vector< boost::shared_ptr<B> > vVecB;

    //vVecB.resize(vVecA.size(), boost::shared_ptr<B> (new B) ); //resize and init to a SINGLE B object, NO!!!

    for (unsigned int i = 0; i < vVecA.size(); i++) {
        vVecB.push_back(boost::shared_ptr<B> (new B)); //filling array with separate empty Bs
        vVecB[i]->access_A_ptr() = vVecA[i];
        vVecB[i]->access().print(); // = 0,1,123,3,4
    }

    vVecA[2]->set(2); //changes to A objects reflected in the B objects

    for (unsigned int i = 0; i < vVecB.size(); i++) {
        vVecB[i]->access().print(); // = 0,1,2,3,4
    }

    std::cout << "use count of vVecA[1] = " << vVecA[1].use_count() << std::endl; // = 2
    std::cout << "use count of vVecA[2] = " << vVecA[2].use_count() << std::endl; // = 3

}

#包括
#包括
#包括“增压/智能水电站”
甲级{
公众：
A（常数整数）