标签: shared-ptr

我正在使用 tr1 shared_ptr （工作尚未更新到 C++0x 或 C++11），并且我需要将 std::tr1::shared_ptr 与具有自定义分配器和删除器的类 Foo 一起使用。

目前 Foo 通过以下代码分配/释放：

void createFoo(Foo** mem) {
 *mem = (Foo *) malloc(sizeof(Foo));
  memset(*mem, 0, sizeof(Foo));
}

和

void deleteFoo(Foo* mem) {
  // code to call recursive methods to delete Foo substructures
  memset(...)
}

如何声明std::tr1::shared_ptr<Foo>使用 createFoo 和 deleteFoo ？

在我的项目中，我使用 boost::shared_ptr，在一个头文件中，我写道：

typedef boost::shared_ptr<boost::lockfree::spsc_queue<PacketsInput, boost::lockfree::capacity<4096> > > queue_ptr;

在另一个源文件中，我使用它：

std::vector<queue_ptr> v;
for (...)
    v.push_back(boost::make_shared(/* #1 */));

在#1中，我想将queue_ptr的点写入类型，而不是

boost::lockfree::spsc_queue<PacketsInput, boost::lockfree::capacity<4096> >

有多长啊！

但是boost::shared_ptr中没有typedef，我找到的唯一一个typedef:typedef typename boost::detail::sp_element< T >::type element_type;但是我不知道如何使用它。

有什么帮助吗？坦克很多！

我试图使用 来实现单链表share_ptr。这是实现...下面是节点类...

template<typename T>
class Node
{
public:
    T value;
    shared_ptr<Node<T>> next;
    Node() : value(0), next(nullptr){};
    Node(T value) : value(value), next(nullptr){};
    ~Node() { cout << "In Destructor: " << value << endl; };
};

下面是链表类...

template<typename T>
class LinkedList
{
private:
    size_t m_size;
    shared_ptr<Node<T>> head;
    shared_ptr<Node<T>> tail;
public:
    LinkedList() : m_size(0), head(nullptr) {};
    void push_front(T value)
    {
        shared_ptr<Node<T>> temp = head;
        head = make_shared<Node<T>>(Node<T>(value));

        head->next = temp;
        m_size++;

        if (m_size == 1)
            tail = head;
    }
    void pop_front() …

假设我有几个 MyObject 类型的对象，并且我希望有相应的shared_ptr 指向它们中的每一个。然后，我想获取所有这些指针并将它们放入一个列表中 - 我该怎么做？

（我说的是这样的事情：

list<shared_ptr<MyObject>> MyList;

但这显然行不通）

另外 - 列表是一个可增长的容器吗？或者我在创建它时必须声明它的大小吗？

谢谢！

您有两个类Animal和Dog（其中Dog继承自Animal），并且您经常会遇到一种情况，您经常期待动物，但发送的是狗的实例。在我的特定情况下，我经常将强指针（std::shared_ptr<Dog>）投射到动物期望函数（std::shared_ptr<Animal>）。

如果我们接受我们可以将函数参数设置为引用（std::shared_ptr<Animal>&避免争论为什么不应该将强指针作为引用参数，因为担心更改线程的所有权），我认为我们在内存方面可以安全地强制转换std::shared_ptr<Dog> dog使用reinterpret_cast<std::shared_ptr<Animal>&>(dog)，对吗？

如果是这样，除了线程问题之外还会出现什么问题？比如引用计数的变化？

需要明确的是，我们的目的是提供一种可在许多情况下使用的解决方案，在这些情况下，一次强制转换并不是真正可行的解决方案。更重要的是，有许多对象需要铸造。此外，忽略这一点std::unique_ptr可能是也可能不是更好的解决方案。

std::shared_ptr添加最后一个要求 -在通用序列化器类函数是虚拟的因此无法模板化的情况下，使用普通指针将不允许我更改原始指针。

我有以下类结构：

class Bar {
private:
    std::shared_ptr<std::vector<int>> y_;
public:
    Bar(std::shared_ptr<std::vector<int>> p):
        y_(p)
    {}

    int getFirstVal() {return y_->at(0);};
};

class Initialiser {
private:
    std::vector<int> x_;
    Bar bar_;
public:
    Initialiser(std::vector<int>& v):
        x_(v),
        bar_(std::make_shared<std::vector<int>>(x_))
    {}

    void set_x(std::vector<int> x) {x_ = x;}

    void check(std::vector<int> x){
        set_x(x);
        std::cout << "New value of x= " << bar_.getFirstVal() << std::endl;
    }
};



int main(){

    std::vector<int> z = {1,2,3};
    Initialiser init(z);

    std::vector<int> x_new = {4,5,6};
    init.check(x_new); // should print 4



}

在初始化器类中，我有一个整数向量和 Bar 类的实例作为私有成员。Bar 应使用指向整数向量的共享指针进行初始化，并且该向量应在初始化器和 Bar 之间共享。然而目前，如果初始化器调用 x 的 …

如果 classA包含 class B，那么在A析构时，B会先调用 \ 的析构函数，即它们的嵌套关系的顺序相反。

但是，如果A包含一个shared_ptrof B，而B包含一个指向 的原始指针A，我们应该如何处理析构函数以使其安全？

考虑以下示例：

#include <iostream>\n#include <memory>\n#include <unistd.h>\n\nstruct B;\nstruct A {\n  int i = 1;\n  std::shared_ptr<B> b;\n\n  A() : b(std::make_shared<B>(this)) {}\n\n  ~A() {\n    b = nullptr;\n    std::cout << "A destruct done" << std::endl;\n  }\n};\n\nstruct B {\n  A *a;\n\n  B(A *aa) : a(aa) {}\n\n  ~B() {\n    usleep(2000000);\n    std::cout << "value in A: " << a->i << …

我正在尝试实现一个固定大小的多维数组，其大小在运行时确定。make_shared与( )的 (2) 重载template<class T> shared_ptr<T> make_shared(std::size_t N) // T is U[]。但是，我面临编译错误（日志如下）。shared如果我将s 更改为其对应项，则不会出现该错误unique。我的问题是，

\n
• 这个错误是关于什么的？
\n
• 为什么unique有效？
\n
• 有更好的方法来实现这种运行时固定的多维数组容器吗？
\n

最小工作示例：

#include <memory>\n#include <iostream>\nint main() {\n    typedef int cell_t;\n    std::size_t x, y;\n    std::cin >> y >> x;\n    auto layout = std::make_shared<std::shared_ptr<cell_t[]>[]>(y);\n    for (std::size_t i = 0; i < y; i += 1) {\n        layout[i] = std::make_shared<cell_t[]>(x);\n    }\n    return 0;\n}\n

错误消息如下g++-10（为简洁起见，省略了注释）

In file included …

我有一个由一些共享指针组成的向量。我试图使用排序比较器函数根据某些标准对该向量进行排序。问题是，如果我们尝试从比较器函数内部访问向量的值；在某些地方我得到了空值。仅在共享指针的情况下才会发生这种情况。对于普通指针，我没有发现这样的问题。为什么在这种情况下我们会在向量内得到空值？

我的代码-

class Tmp {
private :
    int a,b;
public :
    int getA() {
        return a;
    }
    int getB() {
        return b;
    }
    Tmp(int x, int y) : a(x), b(y) {}
};

int main() {
    std::shared_ptr<Tmp> t1 = std::make_shared<Tmp>(11,19);
    std::shared_ptr<Tmp> t2 = std::make_shared<Tmp>(2,3);
    std::shared_ptr<Tmp> t3 = std::make_shared<Tmp>(5,6);
    std::shared_ptr<Tmp> t4 = std::make_shared<Tmp>(3,5);

    vector<std::shared_ptr<Tmp>> v;
    v.push_back(t1);
    v.push_back(t2);
    v.push_back(t3);
    v.push_back(t4);

    auto fun = [&v] (std::shared_ptr<Tmp> &l, std::shared_ptr<Tmp> &r) -> bool {
      for (auto it : v) {
        if (!it) {
            cout<<"null value"<<endl;
        } …

我试图拥有一个带有一组指向另一个对象的指针的对象。当我尝试删除集合的值时，我收到错误并崩溃，我真的不知道是什么原因导致的。这是库，之后是主要功能：当我尝试运行它时，它会执行它应该执行的所有操作，当它到达removeemployee时，它崩溃并发出以下内容：进程已完成，退出代码-1073740940（0xC0000374）

如果重要的话，我在 clion 上运行它，并在 c++11 中运行它。

#include <ostream>
#include <iostream>
#include "Manager.h"

Manager::Manager(int id, string firstName, string lastName, int birthYear)
        : Citizen(id, firstName, lastName,birthYear), salary(0), employees(), work_flag(false) {}

int Manager::getSalary() const {
    return salary;
}

void Manager::setSalary(int _salary) {
    if((salary + _salary) < 0){
        salary = 0;
    }else {
        salary += _salary;
    }
}

void Manager::addEmployee(Employee* employee_add) {
    shared_ptr<Employee> employee(employee_add);
    if(employees.find(employee) != employees.end()){
        throw mtm::EmployeeAlreadyExists();
    }
    employees.emplace(employee);
}

//this is the function

void Manager::removeEmployee(int id) {
    for(auto it = employees.begin(); …