相关疑难解决方法(0)

std::shared_ptr<Object> p1 = std::make_shared<Object>("foo");
std::shared_ptr<Object> p2(new Object("foo"));

许多google和stackoverflow帖子就在这里,但我无法理解为什么make_shared比直接使用更有效shared_ptr.

有人可以一步一步解释我创建的对象序列和两者所做的操作,这样我就能理解make_shared效率如何.我在上面给出了一个例子供参考.

我试图围绕C++ 11的新习语.

似乎至少使用shared_ptr,使用new T()和之间存在实质性差异make_shared<T>().

但是重置共享指针以指向某个新实例的方法呢.以前,我通常会使用reset(new T())会员.但是,这不是因为没有首先使用make_shared()的问题吗？(即它不允许make_shared分配对象,因此它被强制将ref计数放在单独的分配中而不是与T本身相同的分配中？)

是否更好地继续使用:

   mysharedptr = make_shared<T>(args...);

或者,还有更好的方法？

并且不应该像make_shared那样重置提供参数的变量转发,这样就可以编写mysharedptr.reset(args ...);?

我正在创建一个将成为DAG一部分的类.构造函数将获取指向其他实例的指针,并使用它们初始化依赖项列表.
初始化依赖列表后,只能缩短它 - 实例永远不能作为自身或其任何子项的依赖项添加.

::std::shared_ptr处理这个是很自然的.对处理DAG进行了参考计数.

不幸的是,依赖关系需要知道它们的依赖 - 当依赖关系被更新时,它需要告诉它所有的依赖.
这创造了一个可以打破的微不足道的循环::std::weak_ptr.依赖关系可以忘掉那些消失的家属.

但我无法找到一种方法让依赖::std::weak_ptr者在构建时创建一个自己.

这不起作用:

object::object(shared_ptr<object> dependency)
{
     weak_ptr<object> me = shared_from_this();
     dependency->add_dependent(me);
     dependencies_.push_back(dependency);
}

该代码导致在构造函数退出之前调用析构函数.

有没有一个很好的方法来处理这个问题？我对使用C++ 11的解决方案非常满意.

我创建了一个类,我想强制任何试图构建对象的人使用unique_ptr.为此,我想到声明构造函数protected并使用friend返回a 的函数unique_ptr.所以这是我想要做的一个例子:

template <typename T>
class A
{
public:
    friend std::unique_ptr<A<T>> CreateA<T>(int myarg);

protected:
    A(int myarg) {}
};

template <typename T>
std::unique_ptr<A<T>> CreateA(int myarg)
{
    // Since I declared CreateA as a friend I thought I
    // would be able to do that
    return std::make_unique<A<T>>(myarg);
}

我做了一些有关朋友函数的阅读,我理解朋友函数可以访问类对象的私有/受保护成员.

无论如何我可以让我的榜样有效吗？

即使没有朋友功能,我的目标也是让某人创建对象CreateA的唯一方法.

编辑

我改变了一下代码.我没有提到我的类有一个模板参数.这显然使事情变得更加复杂.

尝试创建指向对象的共享指针时遇到此错误

#include <iostream>
#include <vector>

class Foo {
public:
    std::shared_ptr<Foo> getFoo(int i) {
        auto foo = std::make_shared<Foo>(i);
        //auto foo = std::shared_ptr<Foo>(new Foo(i)); "works"
        return foo;
    }
protected:
    Foo(int i) {std::cout << "foo" << std::endl; }
};

int main(int argc, const char * argv[]) {

}

我收到构建时错误

 Static_assert failed due to requirement 'is_constructible<Foo, int &>::value' "Can't construct object in make_shared"

我可以通过将构造函数设为私有来避免这种情况，但我想知道为什么 make_shared 失败并且 shared_ptr(new) 有效？

我正在实现一个A我想要通过它专门管理的多态类型(称之为)std::shared_ptr.要允许shared_from_this在派生类的构造函数中A使用new,请使用然后将成员初始化std::shared_ptr为自身以自动管理其生命周期.为了帮助实现这一点,我决定使特定于类的operator new私有,并计划使用create()辅助函数而不是new和make_shared.设计可能看起来有点滑稽,但在我正在研究的UI库的上下文中是有意义的.最小可重复的例子如下:

struct A {
    A() : m_sharedthis(this) {

    }

    void destroy(){
        m_sharedthis = nullptr;
    }

    std::shared_ptr<A> self() const {
        return m_sharedthis;
    }

private:
    friend std::shared_ptr<A> create();

    std::shared_ptr<A> m_sharedthis;
};

std::shared_ptr<A> create(){
    auto a = new A();
    return a->self();
}

这编译并正常工作.当我将以下代码添加到正文时出现问题A:

struct A {
    ...
private:
    void* operator new(size_t size){
        return ::operator new(size);
    }
    void operator delete(void* ptr){ …

我编写的类(通常作为其中的一部分boost::asio),其对象依赖于shared_ptr因为它们使用而被包装在a中shared_from_this().有没有办法防止对象被编译,如果它没有被实例化shared_ptr？

所以,我正在寻找:

std::shared_ptr<MyClass> a = std::make_shared<MyClass>(); // should compile fine
std::unique_ptr<MyClass> a = std::make_unique<MyClass>(); // compile error
MyClass a; // compile error

我目前正在编写一个弱引用资源管理器,如下所示,编译器抱怨Manager有一个私有构造函数.

我的问题是:为什么我不能在静态函数中访问私有成员函数？

#ifndef TENSOR_MANAGER_H
#define TENSOR_MANAGER_H

#include <memory>
#include <functional>
#include <map>
#include <iostream>

template<typename key_t, typename model_t>
class Manager : public std::enable_shared_from_this<Manager<key_t, model_t> > {
public:
    using self_t = Manager<key_t, model_t>;

public:
    static auto Create() {
        return std::make_shared<self_t>();
    }

public:

    std::shared_ptr<model_t> GetOrAdd(const key_t &&key, const char *data, size_t size) {
        auto pos = m_resources.find(key);
        std::shared_ptr<model_t> tmp;
        if (pos != m_resources.end()) {
            tmp = pos->second.lock();
        }
        if (!tmp) {
            model_t *p = new model_t();

            auto deletor = std::bind(&self_t::releaseItem,
                                     std::weak_ptr<self_t>(this->shared_from_this()),
                                     key, …

可能重复:
如何在只有受保护或私有构造函数的类上调用:: std :: make_shared？

我想创建一个类的共享指针,并有一个工厂方法返回它,同时保持构造函数\析构函数的保护.由于共享指针无法访问构造函数或析构函数,因此出现编译错误.

我正在使用llvm 4.1,但我正在寻找一个可以独立于编译器的解决方案(除了使构造函数\析构函数公开).

这是一个代码示例:

class Foo
{
public:
    static std::shared_ptr<Foo> getSharedPointer()
    {
        return std::make_shared<Foo>();
    }

protected:
    Foo(int x){}
    ~Foo(){}

};

有任何想法吗？

我有一个带有私有构造函数的单例类。在静态工厂方法中，我执行以下操作：

shared_ptr<MyClass> MyClass::GetInstance()
{
    static once_flag onceFlag;

    call_once(onceFlag, []() {
        if (_instance == nullptr)
            _instance.reset(new MyClass());
    });

    return _instance;
}

如果我使用

_instance = make_shared<MyClass>();

该代码无法编译。我的问题是：为什么new可以调用私有构造函数却make_shared不能？