C++ 共享指针上的成员访问权限

我有一个类，它需要有一个对抽象类接口的成员引用，而抽象类接口不能在类构造函数中实例化。我希望此引用是一个共享指针。因为我希望引用是一个接口，并且我无法在构造函数中实例化共享\u ptr指向的对象，所以我必须将共享\u ptr设置为指向接口实例的指针

现在我想在shared_ptr上使用member access操作符->，但这非常难看，因为每次都要取消对指针的引用

#include <iostream>
#include <memory>

class IFace {
public:
    virtual ~IFace() {};
    virtual void doSomething() = 0;
};

class A : public IFace {
public:
    A() {};
    ~A() {};
    virtual void doSomething() { std::cout << "Foo"; };
};

class B {
public:
    B() {};
    ~B() {};
    std::shared_ptr<IFace *> myA;
    void attachA(std::shared_ptr<IFace *> a) {
    this->myA = a;
    };

    void callDoSomethingFromIFace() {
    (*(this->myA))->doSomething();
    };
};

int main() {
    A a;
    B b;

    b.attachA(std::make_shared<A *>(&a));
    b.callDoSomethingFromIFace();
}

而不是

(*(this->myA))->doSomething();

---

不确定为什么假定

[…]因为接口是抽象类，普通共享指针将不会编译，因为接口没有构造函数。

这非常好：

#include <iostream>
#include <memory>

class IFace {
public:
    virtual ~IFace() {};
    virtual void doSomething() = 0;
};

class A : public IFace {
public:
    A() {};
    ~A() {};
    virtual void doSomething() { std::cout << "Foo"; };
};

class B {
public:
    B() {};
    ~B() {};
    std::shared_ptr<IFace> myA;
    void attachA(std::shared_ptr<IFace> a) {
    this->myA = a;
    };

    void callDoSomethingFromIFace() {
     this->myA->doSomething();
    };
};

int main() {
    B b;
    std::shared_ptr<A> a = std::make_shared<A>();
    b.attachA(a);
    b.callDoSomethingFromIFace();
}

#包括
#包括
I类{
公众：
虚拟~IFace（）{}；
虚空doSomething（）=0；
};
A类：公共设施{
公众：
A（）{}；
~A（）{}；
虚空doSomething（）{std:：cout myA=a；
};
void callDoSomethingFromIFace（）无效{
这->myA->doSomething（）；
};
};
int main（）{
B B；
std:：shared_ptr a=std:：make_shared（）；
b、 阿塔查（a）；
b、 callDoSomethingFromIFace（）；
}

对象

a

分配了自动存储持续时间，其所有权无论如何不能共享。通过创建一个指向该对象的额外堆分配指针，只会增加无意义的开销。如果需要一个

shared\u ptr

，则需要在堆上分配此对象（并确保接口具有虚拟析构函数）。将

shared\u ptr

分配给指针没有意义。“我无法在构造函数中实例化shared_ptr指向的对象，我必须将shared_ptr指向指向接口实例的指针“-什么？我根本不懂这个逻辑all@UnholySheep因为接口是一个抽象类，普通的共享指针不会编译，因为接口没有构造函数。@DJohnson这是绝对错误的-如果

std:：shared\u ptr

没有编译，那么原始指针也不会编译，这样就行了，但我不清楚为什么。区别在于对attachA的调用中没有进行make_共享调用。这是我使用错误代码得到的错误：

new\u分配器。h:136:4：错误：抽象类类型“IFace”的新表达式无效{：：new（（void*）\uu p）\u Up（std:：forward（\uu args）；}^~main.cpp:4:7：注意：因为以下虚拟函数在“IFace”中是纯的：类IFace{main.cpp:7:18:note:virtual void IFace:：doSomething（）virtual void doSomething（）=0；

这让我相信这是因为我没有构造它。错误的代码是什么样子的？因为

b.attachA（std:：make_shared（））

也可以。啊，是的，我犯了一个愚蠢的错误，将对象a传递给make_shared，这显然不希望被对象调用。谢谢你澄清这一点。@DJohnson如果

a

的构造函数有参数，那么你将把参数传递给

std:：make_shared

，它将被转发给o

A

的构造函数。因此

std:：make_shared（1，“foo”）

将等于

newa（1，“foo”）

。

#include <iostream>
#include <memory>

class IFace {
public:
    virtual ~IFace() {};
    virtual void doSomething() = 0;
};

class A : public IFace {
public:
    A() {};
    ~A() {};
    virtual void doSomething() { std::cout << "Foo"; };
};

class B {
public:
    B() {};
    ~B() {};
    std::shared_ptr<IFace> myA;
    void attachA(std::shared_ptr<IFace> a) {
    this->myA = a;
    };

    void callDoSomethingFromIFace() {
     this->myA->doSomething();
    };
};

int main() {
    B b;
    std::shared_ptr<A> a = std::make_shared<A>();
    b.attachA(a);
    b.callDoSomethingFromIFace();
}