标签: shared-ptr

我有很多boost::shared_ptr<MyClass>对象,在某些时候我故意想要delete其中一些来释放一些记忆.(我知道那时我将永远不再需要尖头MyClass物体了.)我怎么能这样做？

我想你不能只delete()用我得到的原始指针调用get().

我见过一个函数get_deleter(shared_ptr<T> const & p)中boost::shared_ptr,但我不知道如何使用它,并且还表示,实验就在旁边.(我想我有1.38升.)

也许只是boost::shared_ptr为变量分配一个新的空？这应该扔掉旧值并删除它.

shared_ptr<Shape> circle(new Circle(Vec2f(0, 0), 0.1, Vec3f(1, 0, 0)));

shared_ptr<Shape> rect(new Rect2f(Vec2f(0, 0), 5.0f, 5.0f, 0,
                                  Vec3f(1.0f, 1.0f, 0))              );

我试图理解为什么以上不会编译.无论出于什么原因,当我尝试创建一个Rect2f实例(其中DOES继承自Shape指定shared_ptr模板参数的类时,就像Circle),我得到以下错误:

error: expected type-specifier before 'Rect2f'
error: expected ')' before 'Rect2f'

关于这一切的一切都Circle shared_ptr很好.它没有问题; 它只是Rect2f导致问题的原因.

此外,传递给构造函数的值是有效的.

那么,这个问题会出现什么问题呢？我已经Rect.h包含了这个.为了简洁起见(并且我错过了该文件中可能影响此内容的内容),我将发布以下内容:

Rect.h

#pragma once

#include <QGLWidget>
#include <GL/glext.h>
#include <cmath>
#include <QDebug>
#include "Shape.h"
#include "Vec3f.h"
#include "rand.h"

const int DEFAULT_SQUARE_WIDTH = 5;
const int DEFAULT_SQUARE_HEIGHT = 5;

typedef enum {
    RC_TOPLEFT, …

在我目前的项目中,我使用boost::shared_ptr得非常广泛.

最近我的队友们也开始使用了weak_ptr.我不知道使用哪一个以及何时使用.

除此之外,如果我想转换weak_ptr为,我该怎么办shared_ptr？是否锁定在其他线程中weak_ptr创建shared_ptr影响我的代码？

我想boost::log在某些时候使用,但我不能传递std::shared_ptr一个参数,因为编译器(VS2010)无法将其转换为boost::shared_ptr.

我真的不喜欢他们是外星人的事实.

是否有一种安全透明的方式将一个转换为另一个,因为它们不会相互绊倒？

我不认为这两个问题都是相同的.

我读过这个

"多个线程可以同时读写不同的shared_ptr对象,即使这些对象是共享所有权的副本." (MSDN:标准C++库中的线程安全性)

这是否意味着更改shared_ptr对象是安全的？
例如,下一个代码是安全的:

shared_ptr<myClass> global = make_shared<myClass>();
...

//In thread 1
shared_ptr<myClass> private = global;
...

//In thread 2
global = make_shared<myClass>();
...

在这种情况下,我可以确定线程1 private将具有global线程2分配的原始值或新值,但无论哪种方式,它将具有对myClass的有效shared_ptr？

==编辑==
只是为了解释我的动机.我想有一个共享指针来保存我的配置,我有一个线程池来处理请求.全局配置也是
如此global.
thread 1在开始处理请求时采用当前配置.
thread 2正在更新配置.(仅适用于未来的请求)

如果它工作,我可以更新配置,而不会在请求处理过程中中断它.

有什么区别:

std::shared_ptr<int> p = std::shared_ptr<int>( new int );

和

std::shared_ptr<int> p = std::make_shared< int >();

？

我应该选择哪一个？为什么？

PS相当肯定这已经得到了答案,但我找不到类似的问题.

我在类中有一些容器,例如vector或map,它包含生活在堆上的对象的shared_ptr.

例如

template <typename T>
class MyExample
{
public:

private:
    vector<shared_ptr<T> > vec_;
    map<shared_ptr<T>, int> map_;
};

我希望有一个这个类的公共接口,有时会将shared_ptrs返回给const对象(via shared_ptr<const T>),有时shared_ptr<T>我允许调用者改变对象.我想要逻辑const正确性,所以如果我将方法标记为const,它就不能更改堆上的对象.

问题:

1)我对shared_ptr<const T>和的可互换性感到困惑shared_ptr<T>.当有人经过一个shared_ptr<const T>shared_ptr的进级,做我把它存储为一个shared_ptr<T>或shared_ptr<const T>载体内,映射或修改我的地图,矢量类型(例如insert_elemeent(shared_ptr<const T>OBJ)？

2)如下实例化类更好MyExample<const int> 吗？这看起来过于严格,因为我永远无法回归shared_ptr<int>？

我想在asio中保留一个连接客户端列表.我已经调整了文档中的聊天服务器示例(http://www.boost.org/doc/libs/1_57_0/doc/html/boost_asio/example/cpp03/chat/chat_server.cpp),这里是重要的部分我结束了:

#include <iostream>
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/asio.hpp>
#include <set>

using boost::asio::ip::tcp;

class tcp_connection;

std::set<boost::shared_ptr<tcp_connection>> clients;

void add_client(boost::shared_ptr<tcp_connection> client)
{
    clients.insert(client);
}

class tcp_connection : public boost::enable_shared_from_this<tcp_connection>
{
public:
    tcp_connection(boost::asio::io_service& io_service) : socket_(io_service)
    {
    }

    tcp::socket socket_;

    void start()
    {
        add_client(shared_from_this());
    }

    tcp::socket& socket()
    {
        return socket_;
    }
};

class tcp_server
{
public:
    tcp_server(boost::asio::io_service& io_service)
        : io_service_(io_service),
        acceptor_(io_service, tcp::endpoint(tcp::v4(), 6767))
    {
        tcp_connection* new_connection = new tcp_connection(io_service_);
        acceptor_.async_accept(new_connection->socket(),
                             boost::bind(&tcp_server::start_accept, this, new_connection,
                                         boost::asio::placeholders::error));
    }

private:
    void start_accept(tcp_connection* …

我想问你关于C++中构造函数的最佳实践.我不太确定我应该在构造函数中做什么,什么不能.

我应该只将它用于属性初始化,调用父构造函数等吗？或者我甚至可以将更复杂的函数放入其中,例如读取和解析配置数据,设置外部库aso

或者我应该为此编写特殊功能？RESP.init()/ cleanup()？

什么是PRO和CON？

我想出了,例如,我可以在使用init()和时删除共享指针cleanup().我可以在堆栈上创建对象作为类属性,并在以后构建它时对其进行初始化.

如果我在构造函数中处理它,我需要在运行时实例化它.然后我需要一个指针.

我真的不知道该如何决定.

也许你可以帮帮我吗？

我有一个内部使用Boost版本的库,shared_ptr只公开那些.对于我的应用程序,我想std::shared_ptr尽可能使用.遗憾的是,两种类型之间没有直接转换,因为引用计数的东西是依赖于实现的.

有没有办法让a boost::shared_ptr和a std::shared_ptr共享同一个ref-count-object？或者至少从Boost版本中窃取引用计数,只让stdlib版本处理它？