标签: smart-pointers

是否有C++/CLI RAII智能指针类用于包含托管类型中的本机指针？只是想知道,在我编写自己的clr_scoped_ptr值类模板之前.

我知道微软提供的:

• 包含本机类中的托管句柄​​: auto_gcroot

• 在托管类中包含托管句柄: auto_handle

以上两者类似于auto_ptr或unique_ptr.

• 我在counted_handle这里给了一个骨架代码,类似于shared_ptr

但所有这些都是用于处理托管的ref类实例,而不是用于释放本机对象.

我最近一直在学习托管指针并遇到以下情况.

我正在为游戏视图实现模型/控制器类.我的观点,将在模型中呈现内容.挺直的.在我的main函数中,我将这三个实例化为:

RenderModel m;
m.AddItem(rect); // rect gets added just fine, it's an "entity" derivee
RenderView v;
v.SetModel(m);

我的渲染视图类非常简单:

class RenderView
{
public:
explicit RenderView();
~RenderView();

void Update();

void SetModel(RenderModel& model);

private:
// disable
RenderView(const RenderView& other);
RenderView& operator=(const RenderView& other);

// private members
boost::scoped_ptr<RenderModel> _model;
};

setView的实现非常标准:

void RenderView::SetModel(RenderModel& model)
{
    _model.reset(&model);
}

关键是,视图将模型存储在智能指针中.但是在main中,模型是在堆栈上分配的.程序退出时,内存将被删除两次.这是有道理的.我目前的理解告诉我,任何存储在smart_ptr(任何类型)中的东西都不应该在堆栈上分配.

完成上述所有设置之后,我的问题很简单:如何指示参数未在堆栈上分配？接受智能指针作为参数唯一的解决方案？即使这样,我也无法确保使用我的视图类的人不能做错误的事情,例如:

// If I implemented SetModel this way:
void RenderView::SetModel(const std::shared_ptr<RenderModel>& model)
{
    _model.reset(&*model);
}

RenderModel m;
RenderView v;
std::shared_ptr<RenderModel> ptr(&m); // create a shared_ptr …

我无法弄清楚如何在我的Android项目中使用共享指针.我在Mac OS X上使用最新的Eclipse ADT和Android NDK r8d.

这是我的Android.mk文件中的内容:

LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_CPPFLAGS  := -std=c++11
LOCAL_MODULE    := native
LOCAL_SRC_FILES := native.cpp
include $(BUILD_SHARED_LIBRARY)

这是我的Application.mk文件中的内容:

NDK_TOOLCHAIN_VERSION=4.7
APP_STL := stlport_shared

我已经尝试了默认的GCC 4.6,实验4.7和clang3.1工具链.
我试过链接到stlport_shared和gnustl_sharedc ++运行时库.
我已经试过了FLAGS -std=c++11,-std=c++0x和-std=gnu++11.

我能够使用lambdas和c ++ 11标准的auto,所以C++ 11标志似乎正在工作.但是,无论何时我尝试使用shared_ptr,weak_ptr或unique_ptr,我都会收到错误'suchandsuch_ptr' is not a member of 'std'

我有#include <memory>我的cpp文件.现在Eclipse告诉我Unresolved inclusion: <memory>,但我得到同样的东西<vector>,<string>并且那些似乎编译和工作正常.

智能指针是否未在Android NDK中包含的工具链中实现？
如果没有,为什么不呢？由于GCC和clang已经支持智能指针很长一段时间了,这意味着我要么丢失一些东西,要么Android开发者因为某些原因禁用了它们.
有线索吗？

我想在新项目中使用C++ 11 Smart Pointers,并遇到问题.许多当前项目仍在其接口中使用原始指针作为参数,并且没有智能指针的接口,例如QMainWindow :: setCentralWidget.

为了保持类型一致,我必须get()像这段一样传递存储的指针:

QMainWindow win;

std::shared_ptr<QWidget> scrollArea{ std::make_shared<QScrollArea>() };
// QScrollArea is a derived class of QWidget.

win.setCentralWidget(scrollArea.get());

但我无法确定Qt中的其他方法是否delete对存储的指针执行运算符scrollArea.

如果Qt中的某些方法可以导致内存泄漏或其他问题吗？

我检查了最新的C++标准CD,但没有发现任何内容.似乎这是一个未定义的行为.

如果这样做是一个未定义的行为并且很危险,是否有一种安全的方法可以使用带有原始指针接口的智能指针？

我对智能指针有点困惑。在下面的代码中， & 运算符应该返回智能指针分配的地址还是它控制的指针的地址？

main() {
    std::shared_ptr<int> i = std::shared_ptr<int>(new int(1));
    std::shared_ptr<int> j = i;
    printf("(%p, %p)\n", &i, &j);
}

运行代码，我得到了不同的地址。如果我使用原始指针运行等效代码，我会得到相同的地址：

main() {
    int e = 1;
    int *k = &e;
    int *l = k;

    printf("(%p, %p)\n",k,l);
}

一般来说做智能指针,如std::unique_ptr与Glib::RefPtr当另一个对象重新分配给点删除他们的对象,因为他们持有的是给定的对象(在的情况下,显然隐含的唯一指针std::unique_ptr)？

我有一个工厂方法,它创建一堆对象并返回指向它们的指针.对象的所有权转移给调用者:

std::vector<animal*> create_zoo();

这有效,但容易出现内存泄漏.

auto zoo = create_zoo();

向量在堆栈上并自动清理,包含的对象不是.

返回各种子类型的对象.撤消值而不是指针是行不通的.

我在考虑使用

std::vector<std::unique_ptr<animal> > create_zoo();

但是unique_ptr没有复制语义,我返回了vectorby值,理论上它创建了一个副本.

我可以放在vector堆上以避免这种情况

std::unique_ptr<std::vector<std::unique_ptr<animal> > > create_zoo();

但这太荒谬了.

这也应该有效:

std::vector<std::shared_ptr<animal> > create_zoo();

这可行,但它并没有真正转移所有权.调用者必须假设可能有其他指向对象的指针.

我愿意接受建议.不需要std::vector.我只是在寻找一种实现工厂的好方法,该工厂使用现代c ++返回多个对象的所有权.我现在正在避免提振.我正在尝试探索新的c ++ 11内容.

我试图将一个std::unique_ptr class成员(试图将所有权移动)返回给调用者.以下是示例代码段:

class A {
public:
  A() : p {new int{10}} {}

  static std::unique_ptr<int> Foo(A &a) {
    return a.p; // ERROR: Copy constructor getting invoked
                // return std::move(a.p); WORKS FINE
  }

  std::unique_ptr<int> p;
};

我认为编译器(gcc-5.2.1)能够在这种情况下进行返回值优化(复制省略),而不需要显式的intent via std::move().但事实并非如此.为什么不？

以下代码似乎工作正常,这似乎是等效的:

std::unique_ptr<int> foo() {
  std::unique_ptr<int> p {new int{10}};
  return p;
}

假设我在C++中有以下代码:

#include <memory>
#include <iostream>

struct Some {
        Some(int _a) : a(_a) {}
        int a;
};

int main() {
        Some some(5);

        std::unique_ptr<Some> p1 = std::make_unique<Some>(some);
        std::unique_ptr<Some> p2 = std::make_unique<Some>(some);

        std::cout << p1->a << " " << p2->a << std::endl;
        return 0;
}

据我所知,使用唯一指针来保证资源不被共享.但在这种情况下,两个p1和p2指向同一个实例some.

请揭开这种情况.

这个问题总是让我很烦恼,特别是当我用Qt编程的时候.由于Qt使用对象所有权树,因此传递指针(例如via)myBoostSharedPtr.get()可以隐式转移所有权.现在考虑一些Qt对象被破坏并且整个对象树被破坏但智能指针仍然存在的情况,例如作为不同类的成员.如果之后智能指针被删除会发生什么？双重删除所有令人讨厌的后果？一些智能指针实现会阻止这种情况吗？