标签: smart-pointers

所以我有这个库代码,请看......

class Thing
{
public:

    class Obj 
    {
     public:
        static const int len = 16;

        explicit Obj(char *str)
        {
            strncpy(str_, str, len);
        }

        virtual void operator()() = 0;

    private:
        char str_[len];
    };

    explicit Thing(vector<Obj*> &objs) : objs_(objs) {}

    ~Thing() {
        for(vector<Obj*>::iterator i = objs_.begin(); i != objs_.end(); ++i) {
            delete *i;
        }
    }

private:
    vector<Obj*> objs_;
}

在我的客户端代码中......

   class FooObj : public Thing::Obj
    {
        virtual void operator()() {
            //do stuff
        }
    }

    class BarObj : public Thing::Obj
    {
        virtual void …

我想要一个类似于boost的安全C++指针容器scoped_ptr,但具有类似于值的复制语义.我打算在应用程序的最内层循环中将这个用于非常少使用的类的极少使用的元素,以获得更好的内存局部性.换句话说,只要它的"内联"内存负载很小,我就不关心这个类的性能.

我从以下开始,但我不是那么熟练; 以下是安全的吗？我是否重新发明轮子,如果是这样,我应该在哪里看？

template <typename T> 
class copy_ptr {
    T* item;
public:
    explicit copy_ptr() : item(0) {}
    explicit copy_ptr(T const& existingItem) : item(new T(existingItem)) {}
    copy_ptr(copy_ptr<T> const & other) : item(new T(*other.item)) {}
    ~copy_ptr()  { delete item;item=0;}

    T  * get() const {return item;}
    T & operator*() const {return *item;}
    T * operator->() const {return item;}
};

编辑:是的,这是故意的,它的行为与正常值非常相似.分析表明该算法在其他方面相当有效,但有时会因缓存未命中而受到阻碍.因此,我试图通过提取当前包含在值中但实际上并未在最内层循环中使用的大blob来减小对象的大小.我宁愿在没有语义变化的情况下这样做 - 一个简单的模板包装器将是理想的.

我正在阅读一篇关于有效使用的文章auto_ptr.在那里,以下代码被建议为正确的代码段:

// Example 10(c): Correct (finally!)
//
auto_ptr<String> f()
{
  auto_ptr<String> result = new String;
  *result = "some value";
  cout << "some output";
  return result;  // rely on transfer of ownership;
                  // this can't throw
}

但据我所知,赋值运算符auto_ptr只接受另一个auto_ptr作为rhs- 以避免意外误用.那么,下面的一行是文章中的拼写错误,还是它真的能够起作用？

auto_ptr<String> result = new String;

这是我第一次在C++中使用智能指针.我有一些问题std::shared_ptr:

1. 通过引用设置指针:

   MyToy mytoy_1, mytoy_2;
   set_mytoy(mytoy_1, some_data);
   set_mytoy(mytoy_2, some_data); 
   
   shared_ptr<MyToy> ptr_mytoy(&mytoy_1);
   

   Run Code Online (Sandbox Code Playgroud)

2. 重置和新任务:

   ptr_mytoy.reset(&mytoy_2);
   

   Run Code Online (Sandbox Code Playgroud)

3. 没有分配重置:

   ptr_mytoy.reset();
   

   Run Code Online (Sandbox Code Playgroud)

4. 设置NULL(？):

   ptr_mytoy(nullptr);
   

   Run Code Online (Sandbox Code Playgroud)

这些例子对吗？

如何检查智能指针是否为"空"(例如,之后.reset())或是否NULL？

以此为例:

#include <memory>
#include <iostream>

int add(int a, int b) {
    return a+b;
}

std::unique_ptr<int> addp(int a, int b) {
    std::unique_ptr<int> ip(new int(a + b));
    return ip;
}

int main(int argc, char const* argv[])
{
    std::cout << add(3, 5) << std::endl;
    std::cout << *(addp(3, 5)) << std::endl;
    return 0;
}

功能addp是否会提高性能,或者换句话说,是否可以避免复制数据？我怀疑结果a+b是在堆栈中,然后以任何方式复制到堆中.

我目前正在学习新的c ++内容,而我目前正在学习使用智能指针(std::unique_ptr).

可以说,我有一个std::vector的std::unique_ptr.在我的代码中的某一点,我需要迭代这个stl向量并挑选出我需要计算的对象.

  for (const auto& obj : objectList)
  {
    if(/*check if this is an object I need*/)
      OtherFunc(obj.get());
  }

  void OtherFun(object* obj)
  {
     std::vector tempVector.push_back(obj);
  }

在OtherFunc中,我将这个作为参数传入的对象添加到另一个std::vector(表示为otherVector),我保留并进行计算.我不希望OtherFunc拥有对象的所有权.我只需要保留它们,所以我不必每帧传递对象.

我知道如果智能指针离开作用域(或者在我的情况下,退出程序)将自行解除分配,包含智能指针对象的对象的 otherVector会发生什么.我试着在cplusplus.com查看文档,但我无法得到我的问题的答案.我是否必须取消分配我在otherVector中保存的所有对象？或者由于对象最初是智能指针,我可以假设otherVector中的所有指针也将变为null(因此,不会导致内存泄漏).

对于此代码,C++中有与智能指针相同的编码？

在External.cpp中:

class ExampleClass {...};

ExampleClass* function()
{
  ExampleClass *ptr = new ExampleClass();
  ptr->doSomething();
  return ptr;
}

在Another.cpp中我想做这样的事情,怎么做？:

ExampleClass *ptr2 = function();

我正在重新设计游戏引擎以使用smart-pointers。我有一Object门课，所有东西都从那里继承。我有一个可渲染的GameObject，因此它是从IRenderable（定义纯虚拟渲染函数的类）继承的，而不是从Object继承的。我有一个RenderSystem应该shared_ptr在场景中容纳所有IRenderable的对象。

我遇到的问题是如何将我的GameObject shared_ptr投射到RenderSystem的IRenderable？

我尝试过的想法：

• RenderSystem使用GameObject的shared_ptr，但这不起作用，因为这很危险，因为并非所有gameObjects都是可渲染的。
• 具有IRenderable从Object继承，应该允许我从Object继承。这将意味着IRenderable不再是接口，因为Object包含其他功能。

这完全可以使用原始指针完成，因此，我觉得可以通过智能指针找到某种方法来达到相同的结果

例：

// Object.h
class Object : public enable_shared_from_this<Object> { ... }
// GameObject.h
class GameObject : public Object { ... }
// MeshRenderer.h
class MeshRenderer : public GameObject, IRenderable { 
public:
    void initialize()
    {
         // Not able to cast Object to IRenderable
         RenderSystem::instance().addRenderable(getShared());

         // AND

         // Not able to cast Object to IRenderable

RenderSystem::instance().addRenderable(std::static_pointer_cast<IRenderable>(getShared()));
    }
}
// RenderSystem.h
class …

我有一个std::shared_ptr声明的deque有一个基类的deque(我们称之为Polygon),但我存储指向派生对象的指针(例如Triangle).我现在正在考虑将数据结构更改std::vector为使用向量确保相邻内存的事实但我在这里有几个问题:

1)即使物体尺寸不同,这是否可行？或者可能发生由于派生对象大于它们将在内存中重叠的基础对象？

2)存储std::shared_ptr我不会在内存中将它们完全放在一起只是指针是真的吗？还是我错了？

谢谢

我有一个二进制搜索树实现，其中树的每个节点都具有这种结构。

struct node {
        T data;
        std::unique_ptr<node> left, right;
        node(T data): data(data), left(nullptr), right(nullptr) {}
    };

findmin给定树的根，我实现了一个例程，该例程返回最少的数据（最左边的节点的数据）。目前，我已经递归实现了。

template<typename T>
T Btree<T>::_findmin(std::unique_ptr<node>& curr)
{
    if (curr && curr->left == nullptr)
        return curr->data;
    return _findmin(curr->left);    
}

这行得通，但我想迭代地实现。对于普通的指针，我们可以分配然后继续遍历最左边的节点curr = curr->left，但是这种分配对unique_ptr不起作用。

有没有办法迭代实现？