标签: shared-ptr

我遇到了一个问题,想知道是否有人可以帮助我.

在我的一个班级(例如class1)中,我有一个

typedef boost::shared_ptr <class-one-object>

typedef std::vector<class-one-object>

在另一个类(例如class2)中,我需要再次创建一个向量,以便迭代这个

class-one-object

所以我尝试了以下内容

class1::ImportTableObject& table = configPtr->getTable();    
std::vector<class1::class-one-object>::const_iterator* iter = table.begin();

这引发了以下编译错误:

cannot convret `__gnu_cxx::__normal_iterator<boost::shared_ptr<class1::class-one-object>*, std::vector<boost::shared_ptr<class1::class-one-object>,
 std::alloctor<boost::shared_ptr<class1::class-one-object> > > to '__gnu_cxx::__normal_iterator<const class1::class-one-object*, std::vector<class1::class-one-object>

等等

有人可以帮我吗？

先感谢您

是否可以有2个不同的对象共享相同的参考计数器？

说我有

shared_ptr<Foo> myFoo;
shared_ptr<Bar> myBar;

我希望两个对象都存活,直到有一个对Foo或Bar的引用(所以可能没有人引用Bar,但是因为引用Foo都不会被删除).

有没有搞错 ？(此后报价后以粗体显示的真实问题)

§20.7.2.2.1

template<class Y> explicit shared_ptr(const weak_ptr<Y>& r);
23要求:Y*应可转换为T*.24效果:构造一个与r共享所有权的shared_ptr对象,并存储r中存储的指针的副本.
25后置条件:use_count() == r.use_count().
26投掷:bad_weak_ptr何时r.expired().
27异常安全:如果抛出异常,则构造函数无效.

这不是助推行为.从过期的弱构造的共享给出一个空的共享.你可以在布尔上下文中测试它.

为什么委员会选择了例外的方式？例如,谷歌C++指南完全取消了异常使用.具有此类指导的项目,甚至在构建时禁用异常(在授权禁用的编译器上)将如何禁用？

最后,如果这可能经常发生(开发人员依赖过期的指针检测作为正常的程序流),那么它(对于实时程序)是不是很危险？我记得有一篇文章提到了实现异常的两种可能的策略,一种是减慢一切,但不是真的在异常发生时,另一种只有在异常发生时才会缓慢,但不会影响其余部分.我想这在某种程度上仍然必须成立.

我对模板的体验并不是很好,而且我在团队的代码中发现了一些令我困惑的用法.

假设我有一个基类,它有以下两个用于shared_ptr的typedef:

class Foo
{
     virtual ~Foo();
     virtual void bar() = 0;
};

typedef boost::shared_ptr<Foo> FooPtr1;         //this is what i'm used to seeing
typedef boost::shared_ptr<class Foo> FooPtr2;   //this is in our codebase

这些typedef之间有什么区别吗？它与派生类的使用有关吗？

我有base class一个priority_queue这样的:

class base
{
   //...
   std::priority_queue<std::shared_ptr<Obj>, std::vector<std::shared_ptr<Obj>>, obj_less> obj_queue;
   //...
}

在我Obj class,我有一个方法,应该将此对象推入priority_queue:

void Obj::set ()
{
    BaseServer& myObj = BaseFactory::getBase();
    myObj.set(this); //<------ won't compile :(
}

这set()会打电话给set()我base class:

void base::set(const Obj& o)
{
    obj_queue.push(o);
}

我想使用this,获取指向同样的指针Obj,然后将它推入我的vector内部priority_queue....

但它甚至不会编译,我有点迷失...

我在这里缺少什么想法？

我有一个customClass1有一个属性的类std::vector<std::shared_ptr<customClass2>>.

如何制作一个customClass1对象的副本,该对象包含指向第一个元素所指向的对象的相同副本的指针std::vector<std::shared_ptr<customClass2>>？

我并不想简单地使包含于载体指针的副本.我想实际制作指针指向的对象的副本,然后指向存储在我的第二个customClass1对象的vector属性中的这些新对象.

我不小心在C++上发现了这个问题,但完全不知道它是怎么发生的,请查看下面的代码片段:

    int main() {
        int *aptr = new int(20); //Declare an integer space with 20, and aptr points to it
        shared_ptr<int> a(aptr); //Declare a shared_ptr to points where aptr points

        stringstream ss;
        ss << a;
        const char *chstr = ss.str().c_str();  // Save the address as string

        void *address;
        sscanf(chstr, "%p", (void **)&address); // Convert string back to pointer

        a = NULL;  // Free the shared pointer   
        cout << *reinterpret_cast<int*>(address) << endl; // Output: 0, 20 has gone

        return 0;
} …

我有一个层次结构中A是一个抽象类B,C以及D为后代A.我有一个类Controller(MVC模式)与共享指针A:

class Controller {

private: 
 int it;
 std::shared_ptr<A> theBase;

public:
 void doCall();
//more code

}

在里面doCall()我这样做:

void doCall() {

  switch (it) {
    case 4:
      theBase = std::make_shared<B>( B(8) );
      break;
    case 3:
      theBase = std::make_shared<C>( C(6) );
      break;
    default:
      theBase = std::make_shared<D>( D(0) );
      break;
    }

  theBase->method();

}

通过这种方式,我可以正确使用智能指针,我可以使用继承来根据值获取我需要的类it.

假设我调用此代码:

Controller x;
x.doCall();
x.doCall();

我打了doCall()两次电话,所以我要去switch两次.这意味着std::make_shared被调用两次并分配给theBase …

我有一个类似于以下内容的类：

class A : std::enable_shared_from_this<A> {
public: 
  static std::shared_ptr<A> create() {
    return std::shared_ptr<A>(new A());
  }

  void f() { 
    shared_from_this();
  }

private:
  A() { }
};

它的用法类似于：

std::shared_ptr<A> pt = A::create();
pt->f();

尽管在pt创建shared_ptr之后调用了shared_from_this（）的调用，但对该调用的调用f()仍然会bad_weak_ptr引发异常。运行它可以gdb确认对的调用引发了异常，f()而不是在教师未在此处包括的某些代码中引发了异常。

我编写了一个小程序，以检查异常情况下创建shared_ptrvia new和make_shared()函数之间的区别。我到处都读到，通过make_shared()它是异常安全的。

但是，这两种情况的有趣之处在于，两种情况下的析构函数都不会在堆栈展开后调用？我错过了什么吗？提前致谢。

#include <iostream>
#include <memory>

class Car
{
public:
    Car() { cout << "Car constructor!" << endl; throw std::runtime_error("Oops"); }
    ~Car() { cout << "Car destructor!" << endl; }
};

void doProcessing()
{
//    std::shared_ptr<Car> sp(new Car());
    std::shared_ptr<Car> sp2 = std::make_shared<Car>();
}

int main()
{
    try
    {
        doProcessing();
    }
    catch(...)
    {
    }
    return 0;
}