标签: smart-pointers

我听说越来越多,我应该使用智能指针而不是裸指针,尽管我已经实现了有效的内存泄漏系统.

请问使用智能指针的正确编程方法是什么？它们是否真的应用,即使我检查分配的内存块上的内存泄漏？还是由我决定吗？如果我不使用它们,这可以被视为编程弱点吗？

如果强烈建议使用智能指针(例如:std :: auto_ptr),我应该使用它们而不是每个裸指针吗？

我在嵌入式Linux环境中使用C++ GCC version 2.95.

我只是无法boost::shared_ptr用bcp 提取文件,它太重了.

我想要的是一个简单的智能指针实现,boost::shared_ptr但没有所有boost开销(如果可能......).

我可以拿出我自己的版本的阅读升压源,但我生怕漏掉一个或多个点,似乎容易使出现故障的智能指针,我不能忍受任何会马车实现.

那么,是否存在一个"简单"的实现或实现示例boost::shared_ptr(或任何引用计数等效智能指针)我可以使用或者我可以作为灵感？

我有一些目前使用原始指针的代码,我想改为智能指针.这有助于以各种方式清理代码.无论如何,我有返回对象的工厂方法,以及调用者管理它们的责任.所有权不是共享的,所以我unique_ptr认为这是合适的.我返回的对象通常都来自一个基类Object.

例如,

class Object { ... };
class Number : public Object { ... };
class String : public Object { ... };

std::unique_ptr<Number> State::NewNumber(double value)
    {
        return std::unique_ptr<Number>(new Number(this, value));
    }

std::unique_ptr<String> State::NewString(const char* value)
    {
        return std::unique_ptr<String>(new String(this, value));
    }

经常返回的对象需要传递给另一个函数,该函数对类型的对象Object(基类)进行操作.没有任何智能指针,代码就是这样.

void Push(const Object* object) { ... } // push simply pushes the value contained by object onto a stack, which makes a copy of the value
Number* number = NewNumber(5);
Push(number); …

无论如何我可以向删除器发送参数std::shared_ptr吗？

感觉像是:

std::shared_ptr<A> myA( a, myDeleter(a, 5) );   

myDeleter这个签名在哪里:

void myDeleter(A* a, int i)

(显然上面的语法是错误的,但只是为了强调我需要我的删除器来获取额外的参数.)

我有一个线程类,我偶尔会从中获取一个指针实例变量.我希望这个访问由互斥锁保护,以便阻止线程访问此资源,直到客户端完成其指针.

我最初的方法是返回一对对象:一个是指向资源的指针,另一个是指向互斥锁上的锁定对象的shared_ptr.此shared_ptr包含对锁对象的唯一引用,因此当超出范围时,应该解锁互斥锁.像这样的东西:

void A::getResource()
{
    Lock* lock = new Lock(&mMutex);
    return pair<Resource*, shared_ptr<Lock> >(
        &mResource, 
        shared_ptr<Lock>(lock));
}

此解决方案不太理想,因为它要求客户端保留整个对象.这样的行为打破了线程的安全性:

Resource* r = a.getResource().first;

另外,我自己实现的是死锁,我很难确定原因,所以可能还有其他问题.

我想要的是一个shared_ptr,它包含作为实例变量的锁,并将其与访问资源的方法绑定在一起.这似乎应该有一个既定的设计模式,但做了一些研究,我很惊讶地发现它很难找到.

我的问题是:

• 这种模式有共同的实现吗？
• 将mutex置于我忽略的shared_ptr中是否存在问题,以防止这种模式被广泛传播？
• 是否有充分的理由不实现我自己的shared_ptr类来实现这种模式？

(注意我正在使用Qt的代码库,但遗憾的是在这种情况下不能使用boost.但是,涉及提升的答案仍然是普遍感兴趣的.)

我使用的代码库部分由一个爱上过度复杂的简单问题解决方案的人实现(例如,有两个参数的模板类只能为一对类型实例化).她做的一件事是在智能指针中创建对象,然后让对象存储一个指向自身的弱指针.

class MyClass {
    //...
    boost::weak_ptr<MyClass> m_self;
    //...
};

boost::shared_ptr<MyClass>
Factory::Factory::Factory::CreateMyClass() {
    boost::shared_ptr<MyClass> obj(new MyClass(...));
    boost::weak_ptr<MyClass> p(obj);
    obj->storeSelfPointer(p);
    return obj;
}

然后,类通过锁定并传递生成的共享指针来继续使用m_self.

对于我的生活,我无法理解她想要完成的事情.是否有一些模式或想法可以解释这种实现？在我看来,这是完全没有意义的,我想重构它.

编辑:我应该提到,使用从锁定m_self获得的结果智能指针的任何地方都没有实际保留智能指针.

我已经读过weak_pointers可以用来打破循环引用.

请考虑以下循环引用示例

struct A
{
boost::shared_ptr<A> shrd_ptr;
};


boost::shared_ptr<A> ptr_A(boost::make_shared<A>());
boost::shared_ptr<A> ptr_b(boost::make_shared<A>());
ptr_A->shrd_ptr = ptr_b;
ptr_b->shrd_ptr = ptr_A;

现在上面是一个循环引用的例子,我想知道如何通过使用来打破上面的循环引用weak_ptr？

更新:根据收到的建议,我想出了以下内容:

struct A
{
  boost::weak_ptr<A> wk_ptr;
};

    boost::shared_ptr<A> ptr_A (boost::make_shared<A>());
    boost::shared_ptr<A> ptr_B (boost::make_shared<A>());
    ptr_A->wk_ptr = ptr_B;
    ptr_B->wk_ptr = ptr_A;

这是正确的方法吗？

假设我有以下类的层次结构:

struct Base 
{
};

struct Derived : public Base 
{ 
    void DoStuffSpecificToDerivedClass() 
    {
    } 
};

以下工厂方法:

std::unique_ptr<Base> factoryMethod()
{
    auto derived = std::make_unique<Derived>();
    derived->DoStuffSpecificToDerivedClass();
    return derived; // does not compile
}

问题是,return语句没有编译,因为std::unique_ptr没有具有协方差支持的复制构造函数(这是有道理的,因为它没有任何复制构造函数),它只有一个具有协方差支持的移动构造函数.

解决这个问题的最佳方法是什么？我可以想到两种方式:

return std::move(derived); // this compiles
return std::unique_ptr<Base>(derived.release()); // and this compiles too

编辑1:我使用Visual C++ 2013作为我的编译器.return derived看起来像这样的原始错误消息:

Error   1   error C2664: 'std::unique_ptr<Base,std::default_delete<_Ty>>::unique_ptr(const std::unique_ptr<_Ty,std::default_delete<_Ty>> &)' : cannot convert argument 1 from 'std::unique_ptr<Derived,std::default_delete<Derived>>' to 'std::unique_ptr<Derived,std::default_delete<Derived>> &&'

编辑2:它是标准VS 2013模板中新创建的控制台应用程序.我没有调整任何编译器设置.编译器命令行如下所示:

调试:

/Yu"stdafx.h" /GS …

澄清英语中可能的优先歧义:我们正在采取"智能(指向成员的指针)",而不是"(智能指针)成员".

我会将一个指向成员的智能指针定义为带有operator ->* (T* lhs, X rhs)重载的类X.

在他的文章"实现操作符 - >*用于智能指针"中,Scott Meyers只是简单地触及指向成员的智能指针,因为当时(1999)特定问题对于成员的原始指针来说已经足够困难了(旁注:后者优雅地解决了)这里有lambdas ).

无论如何,Scott Meyers写了一个脚注:

在撰写本文草稿后不久,我的一位咨询客户向我展示了一个问题,这个问题通过智能指向成员的方式自然而然地解决了.我也很惊讶.

我试图找到一个这样一个成员的自然智能指针的例子.但是我既不能自己想出任何东西,也没有在线搜索发现我在寻找什么.

你知道任何现实世界"成员智能指针"的例子吗？

编辑:我不是在寻找任何->*过载(如某些EDSL所做的那样).针对具有类似内置语义的语义示例->*,我上面的定义明确要求lhs是一个原始指针.

我喜欢使用智能指针,并且已经看到了一些代码,这些代码很好地利用了typedefs make使它们变得更漂亮.例如:

struct A {
    typedef boost::shared_ptr<A> pointer;
};

允许我写: A::pointer a(new A);

但是我在typedef幸福中遇到了一个小问题: - /,前言声明......

想象一下这种情况:

struct B;
struct A {
    boost::shared_ptr<B> b_;
};

struct B {
    boost::shared_ptr<A> a_;
};

效果很好,但我想清理一下.不幸的是,这是行不通的

struct B;
struct A {
    typedef boost::shared_ptr<A> pointer;
    B::pointer b_; // <-- error here
};

struct B {
    typedef boost::shared_ptr<B> pointer;
    A::pointer a_;
};

我理解为什么,在文件中的那一点,编译器没有信息,实际上B中有一个名为的类型pointer.

我有一种感觉,我至少在某些方面坚持使用旧方法,但我很想听到一些聪明的想法.