我应该使用shared_ptr还是返回unique_ptr.get()？
在选择使用shared_ptr还是返回unique_ptr.get()之前，我们需要了解它们的区别和适用场景。
shared_ptr是C++标准库提供的智能指针之一，用于管理动态分配的内存资源。它采用引用计数的方式来跟踪资源的引用情况，当没有任何指针指向该资源时，会自动释放内存。shared_ptr适用于多个指针共享同一块内存的情况，可以避免内存泄漏和悬空指针的问题。
unique_ptr也是C++标准库提供的智能指针，与shared_ptr不同的是，它采用独占所有权的方式管理资源。即同一时间只能有一个unique_ptr指向该资源，当unique_ptr被销毁时，会自动释放内存。unique_ptr适用于需要独占资源的情况，可以避免资源的多重释放和悬空指针的问题。
根据具体的使用场景，我们可以选择使用shared_ptr或返回unique_ptr.get()。
如果需要多个指针共享同一块内存，可以选择使用shared_ptr。例如，在多线程环境下，多个线程需要访问同一个资源，可以使用shared_ptr来管理资源的生命周期，确保资源在所有线程完成后才被释放。
如果只需要在函数内部暂时使用资源，并且不需要与外部共享所有权，可以选择返回unique_ptr.get()。例如，当函数需要返回一个指向动态分配的对象的指针时，可以使用unique_ptr来管理对象的生命周期，并通过返回unique_ptr.get()来获取指针。
需要注意的是，如果返回unique_ptr.get()，则需要确保调用者不会在资源释放后继续使用该指针，否则会导致悬空指针的问题。
腾讯云提供了一系列与云计算相关的产品，包括云服务器、云数据库、云存储等。具体推荐的产品和产品介绍链接地址可以根据实际需求和场景来选择，可以参考腾讯云官方网站或咨询腾讯云的客服人员获取更详细的信息。
相关·内容
1回答
例如，如果找到对象，则有一个函数查找对象并返回shared_ptr，并且必须以某种方式指示没有找到任何对象。
std::vector<std::shared_ptr> Storage::objects;
std::shared_ptr<Object> Storage::findObject()
{
if (objects.find)
{
return objects[x];
}
else
{
return nullptr;
}
}
std::shared_ptr<Object> obj = Storage::fin
浏览 3提问于2016-05-15得票数 24
回答已采纳
这种方法是不安全的吗？
#include <tr1/memory>
Foo * createFoo()
{
return new Foo(5);
}
int main()
{
std::tr1::shared_ptr<Foo> bar(create());
return 0;
}
还是让createFoo返回一个shared_ptr<Foo>对象更可取？
浏览 1提问于2011-04-08得票数 2
回答已采纳
5回答
我有一个关于和的问题。我知道有很多关于何时使用哪一个的问题，但我仍然不确定我是否理解正确。我在某处读到，智能指针的默认选择应该是std::unique_ptr，但据我所知，出于我的需要，我宁愿使用std::shared_ptr。例如，我有：
class B;
class A
{
private:
B* b;
public:
B* getB();
};
A::getB()
{
return b;
}
所以基本上A类拥有指向B类型的对象的指针，并且有一个方法返回这个指针。如果我创建getter，我假设其他类可以访问这个指针，因此它应该是shared_ptr而不是unique_p
浏览 0提问于2013-02-14得票数 26
回答已采纳
如果我使用一个包含shared_ptrs的容器，并且显式地允许访问它的元素，如果我想让这个容器负责“清理”，我应该返回shared_ptrs还是原始指针？
class Container
{
private:
std:vector<shared_ptr<Foo> > foo_ptrs;
public:
shared_ptr<Foo> operator[](std::size_t index) const {}; // or
Foo* operator[](std::size_t index) const {};
};
有没有理由在这
浏览 0提问于2010-10-08得票数 3
回答已采纳
2回答
从工厂返回指针
、、、
从工厂返回指针的最佳方法是什么？它应该是一个std::unique_ptr或std::shared_ptr，还是仅仅是一个原始指针？
另外，有人告诉我，如果有容器，就应该使用std::unique_ptr，如果有聚合，就应该使用std::shared_ptr。这是正确的方式吗？
浏览 1提问于2012-10-25得票数 4
回答已采纳
我有一个类似的东西：
class A {
std::weak_ptr<B> r;
A (std::weak_ptr<B> x) : r(x) {}
~A() {
r.lock();
}
};
class B : std::enable_shared_from_this<B> {
std::shared_ptr<A> r;
foo() {
r = std::make_shared<A>(shared_from_this());
}
};
在B的销毁过程中，将调用~A()；但是它希望回调到
浏览 2提问于2017-09-08得票数 0
回答已采纳
Entity对象的唯一所有者是EntityManager。
class EntityManager
{
public:
std::weak_ptr<Entity> vs std::shared_ptr<Entity> getEntityByID(int ID) const;
private:
std::vector<std::shared_ptr<Entity>> entities;
};
当需要在程序中使用Entity时，通过使用getEntityByID函数从EntityManager接收。
Entity不应该以sha
浏览 1提问于2016-05-22得票数 2
我希望拥有一个共享对象池，其类名为Shader。我希望“客户端”能够从池管理器中请求具有特定参数的Shader，如果池中已经有一个参数，管理器将返回一个指针或对它的引用，否则它将创建一个新的Shader并在返回其引用之前将其添加到池中。到目前为止很容易。
不过，我也希望阴影自动删除时，所有客户已经完成了他们。通过将池实现为std::weak_ptr的容器并将std::shared_ptr返回给客户端，这是可能的吗？例如，如果我在同一个对象上多次调用weak_ptr::lock()，那么它返回的是它彼此正确链接的shared_ptrs，还是返回独立的shared_ptrs导致？，但他们没有明确指
浏览 4提问于2015-01-22得票数 0
回答已采纳
3回答
假设我正在开发一个小型电影数据库。在像python这样的动态语言中，我会写：
db = ConnectionFactory.get_connection(db_name) # (1) Create database connection
model = MovieModel(db) # (2) object-to-relational mapper
star_wars = Movie("Star Wars", ...)
model.store(star_wars) # (3) Sav
浏览 5提问于2014-04-16得票数 3
回答已采纳
给定这个类，即enable_shared_from_this
class connection : public std::enable_shared_from_this<connection>
{
//...
};
假设我从同一个std::shared_ptr创建了两个实例，如下所示：
std::shared_ptr<connection> rc(new connection);
std::shared_ptr<connection> fc(rc.get(), [](connection const * c) {
浏览 2提问于2017-11-13得票数 7
我正在做一个小型编译器。现在我有了一个层次系统来表示抽象语法树(AST)。
class Ast{
public:
// ...
}
class Expr : public Ast{
public:
// ...
}
using ExprNode = shared_ptr<Expr>;
class BinaryOp : public Expr{
public:
ExprNode lhs;
ExprNode rhs;
}
Ast层次结构系统中的所有类都使用shared_ptr来管理它们的成员(如果需要的话)，例如，BinaryOp持有两个成员来表示
浏览 0提问于2019-01-21得票数 4
回答已采纳
在使用shared_ptr时，我应该只使用一次shared_ptr声明，还是应该在传递它的地方声明shared_ptr？
所以在我新建实例的函数中，我将它包装在shared_ptr中，但是当我从函数返回它时，我也可以返回一个shared_ptr，或者在shared_ptr上使用get()，只返回一个普通的指针。
所以我的问题是，我应该在新建实例时只使用shared_ptr<myType>，然后传递普通指针，还是应该到处传递shared_ptr<myType>？
浏览 1提问于2012-02-06得票数 7
回答已采纳
1回答
我正在从我的c++代码中的几个不同位置推送一个指向userdata的c++对象指针。我希望lua管理c++对象(userdata)的生命周期。我的问题是，现在我有多个userdata实例指向lua环境中的同一个c++对象。因此，每个实例都会调用GC。
我在想，一种解决方案是在lua注册表(LUA_REGISTRYINDEX)中创建一些弱缓存表，将对象指针映射到实际的用户数据。然后，当我将userdata推送到环境中时，我会检查这个缓存以查看是否已经创建了userdata并推送该实例(否则创建userdata并添加到缓存中)。这样一来，环境中只存在一个userdata实例。
这是最好的解决方案吗
浏览 1提问于2019-07-08得票数 0
在C++中，我可以编写类似这样的代码：
shared_ptr<A> a_sp = someFunctionReturningSharedPtr();
if (a_sp) {
cout << a_sp->someData << endl;
} else {
cout << "Shared Pointer is NULL << endl;
}
为什么if (a_sp)检查是正确的？a_sp不是布尔值，但是如何检查它是真还是假？if条件如何知道检查a_sp.get()函数的结果？或者，如果没有，如何检查a_s
浏览 3提问于2011-08-29得票数 11
回答已采纳
我在下面的shared_ptr中查看实现。我不完全清楚的一个问题是，除了T*类型存储在shared_ptr类本身中的指针之外，作者还需要将托管对象的指针的第二份副本及其具体类型存储在控制块中(即auximpl中的U* p; )。我理解为什么我们需要这种自定义删除器，而不是实际指针。当我在页面中读取控制块描述时，它看起来符合标准的要求。作者对此作了如下评论
“这是正确管理所有的情况，T是一个基础，无论你有多个T在派生层次”
但我还是不能拿出一个例子来说明什么时候才是真正需要的。谁能举个例子来演示一下吗？
谢谢你，-Grigor
浏览 9提问于2022-07-10得票数 3
回答已采纳
1回答
我有一个带有自定义删除器的std::shared_ptr，在这个删除器中，我想临时复制原始的std::shared_ptr。以代码形式表示：
struct Foo : public std::enable_shared_from_this<Foo>
{};
void deleter(Foo *f)
{
{
std::shared_ptr<Foo> tmp = f->shared_from_this(); // Line A
}
delete f;
}
int main()
{
std::shared_ptr<Foo> foo
浏览 2提问于2017-10-09得票数 10
4回答
在这种情况下我会返回什么？
、、、、
我将发布我的代码，然后解释我的查询：
typedef std::shared_ptr<SEntity> Entity;
//Scene_Ids is an enum
static std::map<Scene_Ids, std::vector<Entity> > m_scene_entities;
std::shared_ptr<SEntity>& SEntityManager::getEntity(const std::string& entity_name)
{
int counter = 0;
for
浏览 2提问于2014-01-17得票数 0
回答已采纳
1回答
使用普通指针很简单，如下所示：
int* p = new int;
int* x = new int;
p=x;
但对于共享，有:交换、重置和更多
std::shared_ptr<int> x = NULL;
std::shared_ptr<int> y = NULL;
我知道reset是用来表示"new“的
x.reset(new int(5));
如果我想让x和y都指向这个新的整数5，我应该使用reset、swap还是=？我真的很困惑。
y = x;
y.swap(x);
y.reset(x);
有人能解释一下吗？
谢谢。
浏览 1提问于2015-05-23得票数 1
从我所做的研究来看，似乎是构建std::shared_ptr的首选方法。具体原因是：
与至少执行两个内存分配的new相比，它只执行一个内存分配。
如果ctor传递给make_shared抛出，那么它不会泄漏，就像新的一样。
我的问题是，假设我想要一个shared_ptr，我应该总是使用make_shared，还是在某些情况下new是首选的？
浏览 14提问于2013-10-07得票数 7
回答已采纳
2回答
我有一个带有指针成员的基类。我必须做一个有根据的猜测，才能确定它应该是unique_ptr还是shared_ptr。他们似乎没有解决我的特殊用例。
class Base
{
public:
Base(): pInt(std::unique_ptr<int>(new int(10))) {};
virtual std::unique_ptr<int> get() = 0;
//Base(): pInt(std::shared_ptr<int>(new int(10))) {}; // Alternate implementation
浏览 8提问于2015-02-16得票数 7
回答已采纳
我在C++中有以下简单的继承示例。
#include<bits/stdc++.h>
using namespace std;
class Animal{
public:
string mName;
Animal(string pName){
mName=pName;
}
virtual void printAnimal(){
cout<<"Animal "<<this->mName<<endl;
}
};
class Dog: pub
浏览 1提问于2016-11-02得票数 1
回答已采纳
当我使用boost::bind将参数绑定到一个函数时-什么时候将它们转换为函数所需的类型(如果可以进行隐式转换)？
它们是如何存储在bind_t对象中的？作为最初传递给bind的类型还是函数签名所需的类型？
具体地说：
如果我有一个签名的函数
void SomeFun(SmartPointer<SomeType>)
我使用bind作为
boost::bind(&SomeFun, somePtr)
当somePtr的类型为SomeType*时，bind_t对象是包含存储为简单指针的somePtr副本，还是将其强制转换为SmartPointer<SomeType>并
浏览 0提问于2011-01-12得票数 2
回答已采纳
我有一个库，它创建对象(类A的实例)，并将它们传递给python程序，该程序应该能够调用它们的方法。
基本上，我有C++类实例，我希望从python中使用它们。偶尔，该对象应该被传递回C++进行一些操作。
我创建了以下包装文件(假设New函数是在C++代码的某个地方调用的)：
#include <boost/python.hpp>
#include <iostream>
#include <boost/smart_ptr.hpp>
using namespace boost;
using namespace boost::python;
int call
浏览 4提问于2010-07-27得票数 14
回答已采纳
2回答
声明C++不可变类的惯用方法
、、、、
所以我有一些非常广泛的函数代码，其中的主要数据类型是不可变的结构/类。通过使成员变量和任何方法保持常量，我声明不可变性的方式“实际上是不可变的”。
struct RockSolid {
const float x;
const float y;
float MakeHarderConcrete() const { return x + y; }
}
这真的是C++中“我们应该这么做”的方式吗？还是有更好的方法？
浏览 1提问于2014-11-11得票数 39
回答已采纳
1回答
我试图在C++中实现一个对象持久性模型。其思想是，有一个数据库对象充当各种PersistentObjects的工厂，每个工厂都与数据库表中的一行相关联。数据库有如下方法：
PersistentObject *Database::GetObject(int ID);
这将返回一个指向具有ID号的对象的指针(如果ID不存在，则返回一个空指针)。在数据库类中，还有一个已创建的所有PersistentObjects的映射：
std::map<int, PersistentObject*> _objectMap;
在内部，GetObject做两件事之一：
如果这是第一次请求具有ID的Pe
浏览 3提问于2016-03-11得票数 3
回答已采纳
我正在(至少)将我的一些代码转换为使用shared_ptr。但是，我正在使用的观察者模式遇到了一个问题。
我有一个演示者类()，它实现了观察者模式，并在某些事件发生时得到通知。我编写了任何类都可以继承的通用主题/观察者类。update方法如下所示：
void MyPresenter::Update(Subject *subject)
{
if(subject == myService_)
{
DoSomething();
}
else if(subject == myOtherService_)
{
DoSomething
浏览 7提问于2011-10-31得票数 1
回答已采纳
3回答
派生类和智能指针
、、、
class Object { /* */ };
和一些派生出来的：
class Derived1 : public Object { /* */ };
class Derived2 : public Object { /* */ };
我有一个函数，它生成派生对象并返回Object的指针；
Object *make()
{
return new Derived1();
}
所以，这样我必须用智能指针包装返回的对象，但是使用什么返回类型呢？
TYPE? make()
{
return boost::shared_ptr<Derived1>(new Derived1());
浏览 5提问于2010-12-29得票数 2
回答已采纳
3回答
我不确定是文档错误还是头疼让我更痛苦，所以...
我想要做的是创建一个shared_ptr，它与另一个共享所有权，但它引用对象的一个成员，而不是整个对象。简单的例子，起点..。
struct s
{
int a, b;
};
shared_ptr<s> s1 (new s); // pointing to whole object
在中，shared_ptr的构造函数(8)是...
template< class Y >
shared_ptr( const shared_ptr<Y>& r, T *ptr );
描述提到“构造一个share
浏览 0提问于2012-11-13得票数 6
回答已采纳
我对智能指针很陌生，我正试图绕过我的头，为什么一个weak_ptr会在取消引用操作符之后过期。我用来测试的代码如下：
#include <memory>
#include <iostream>
#include <vector>
using namespace std;
struct node
{
weak_ptr<node> parent;
shared_ptr<node> child;
int val;
};
shared_ptr<node> foo()
{
shared_ptr&
浏览 1提问于2016-07-26得票数 4
回答已采纳
我有一个聪明的指针列表。我希望这些智能指针中的一些充当常规指针，这意味着它们只是对实例的引用，而不涉及实例的释放。例如，它们可能指向堆栈上分配的实例。列表中的其他智能指针应充当常规boost::shared_ptr。
下面是这个类的外观：
template<class T> smart_ptr {
private:
T *p;
boost::shared_ptr<T> sp;
public:
smart_ptr(T *p): p(p), shared(0) { } // p will not be deleted
smart_ptr(bo
浏览 2提问于2009-07-20得票数 4
回答已采纳
1回答
注意:我之前问过，它很快就被关闭为一个副本。这个新问题与实际设计有关，因此不应重复这个问题。
我有一个类B，它接受一个类型为C * (抽象基类)的参数。我控制着B的定义。
我有一个松散的对象集合(阅读:其他类中的一组成员变量)，它具有各种接口(有些接口我无法控制)。有些实现了C，有些则没有。我编写了一些适配器，它们扩展了C并提供了必要的功能。
现在，我想构建一个B对象的实际集合。就像这样：
vector<B> bvec;
bvec.emplace_back(&obj1.x); // obj.x implements C
bvec.emplace_back(new YCAd
浏览 2提问于2014-06-05得票数 0
我有一个关于C++11最佳实践的问题。在清除shared_ptr时，应该使用没有参数的reset()函数，还是应该将shared_ptr设置为nullptr？例如：
std::shared_ptr<std::string> foo(new std::string("foo"));
foo.reset();
foo = nullptr;
有什么真正的区别吗?或者这两种方法都有优缺点吗？
浏览 1提问于2013-04-22得票数 89
回答已采纳
5回答
智能指针使用
、、、
我有一个项目，我想让智能指针更好地使用。
其主要思想是在从函数返回新对象时使用它们。问题是使用什么智能指针？auto_ptr还是shared_ptr？正如我所知，auto_ptr速度较慢，但它可以回到“纯”指针。
如果我在不需要智能指针的地方使用智能指针，它会使性能变慢吗？
浏览 5提问于2010-12-29得票数 3
回答已采纳
我在修改类函数返回的智能指针的内容时遇到了一些问题。返回对指针的引用将是一种解决方案，但我担心这是一种糟糕的做法。
这是我的代码：
#include <memory>
#include <iostream>
class Foo
{
public:
Foo() : ptr_(new int(5)) {};
~Foo() {};
std::shared_ptr<int> bar()
{
return ptr_;
}
void print()
{
std::cout &l
浏览 0提问于2013-04-29得票数 2
回答已采纳
1回答
假设我有一个类Position
class Position{
public:
Position(int x, int y) : x(x), y(y) {}
int getX(void) { return x; }
int getY(void) { return y; }
private:
int x;
int y;
};
和一个类Floor
class Floor {
public:
Floor(Position p) : position(p) { }
private:
Position position;
};
如果我
浏览 1提问于2016-03-14得票数 2
回答已采纳
下面的代码可以用g++ 8.1.0和clang10.0.0编译。
#include <memory>
#include <iostream>
#include <functional>
int main() {
auto dereference = std::bind(
&std::shared_ptr<int>::operator*,
std::placeholders::_1);
std::shared_ptr<int> sp = std::make_shared<
浏览 5提问于2022-11-19得票数 0
回答已采纳
我有这些类型定义，问题是我需要传递一个安全套接字作为TSocket，从TSecureSocket到TSocket的直接转换是否有效？还是有其他的解决方案？根据端口的不同，我将确保套接字的安全，而在其他情况下则不会。我只需要返回类型为TSocket。
typedef boost::asio::ip::tcp::socket TBoostSocket;
typedef boost::asio::ssl::stream<TBoostSocket> TSLLSocket;
typedef boost::shared_ptr<TBoostSocket
浏览 2提问于2012-11-26得票数 1
回答已采纳
我认为这是一个标准问题，但我仍然无法找到解决方案或这个。我可能遗漏了一些非常基本的东西。 我所要做的就是访问(只读) std::shared_ptr<std::map<int, int>>中的数据。我能找到的唯一方法就是实际获取共享指针下的对象，并将其用作普通对象： shared_ptr<map<int, int>> tmap =
make_shared<const map<int,int>>(initializer_list<std::map<int,int>::value_type&
浏览 72提问于2020-11-09得票数 0
回答已采纳
3回答
我是C++的新手，我已经编写了下面的类和函数：
class Person {
public:
boost::shared_ptr<Details> GetDetails(const std::string& name) const;
...
private:
std::map<std::string, boost::shared_ptr<Details> > map;
...
};
inline
boost::shared_ptr<Details>
Pers
浏览 2提问于2011-08-25得票数 0
回答已采纳
当我运行这段代码时：
#include <iostream>
#include <memory>
struct Adaptee {
int value = 0;
};
class Adapter {
private:
Adaptee* adaptee;
public:
Adapter (Adaptee* a) : adaptee(a) {}
void increaseValueByOne() {adaptee->value++;}
};
int main() {
Adaptee*
浏览 5提问于2014-08-22得票数 0
回答已采纳
1回答
以下代码段运行良好：
#include <memory>
#include <cassert>
int main()
{
auto ptr1 = std::make_shared<int>(10);
assert(ptr1.use_count() == 1);
auto ptr2 = std::move(ptr1);
assert(ptr1 == nullptr);
auto ptr3 = static_cast<std::shared_ptr<int>&&>(ptr2);
浏览 8提问于2022-06-23得票数 0
回答已采纳
我希望我的构建器方法Class::create()返回unique_ptr
为什么？
1)此设计没有强制执行共享所有权(和原子锁)。unique_ptr非常高效，具有与void*相同的大小。
2)尽管如此，在类用户端移动到shared_ptr 还是很容易的(但只有当客户想要共享多个所有权的实例时)
所以。我只想为我所用的东西付钱
但。我需要一些类实例的方法来返回“这个”指针。如果我从enable_shared_from_this继承类，我只使用return shared_from_this，但我认为它与惟一的所有权无关
换句话说，在类中的某个地方创建的unique_ptr (当然不使用shar
浏览 2提问于2017-12-01得票数 4
回答已采纳
我有一个STL容器，其元素类型是const std::shared_ptr<MyClass>。
我想向用户提供两种迭代器类型：
MyContainer::iterator
类型为std::vector<const std::shared_ptr<MyClass>>::iterator (应与std::vector<const std::shared_ptr<const MyClass>>::const_iterator相同)
MyContainer::const_iterator
类型为std::vector&
浏览 0提问于2013-03-01得票数 2
回答已采纳
2回答
不久前，我还在练习设计模式，最近，我尝试实现了一个Factory Method模式。我的朋友告诉我应该始终使用智能指针，所以我尝试了一下，但是我的编译器抛出了一个称为“访问冲突”的异常。我做错了什么？有一个叫做"Shape“的接口，三个继承它的类，客户端类和main函数。我试着用智能指针做任何事情，但我有点不确定，如果我做得对的话。 #include <iostream>
#include <memory>
class Shape
{
public:
virtual void printShape() = 0;
static std::sha
浏览 17提问于2020-07-07得票数 2
回答已采纳
3回答
我正在制作一组类来表示图像。这个类的一个应用程序是在一组平铺图像上绘制一幅图片。抽象图像类如下所示：
class Image
{
public:
virtual Pixel* findPixel( Point p ) =0;
virtual bool isDrawable( Point p ) =0;
virtual bool contains( Point p ) =0;
};
我看到的问题是，如果我创建一个这样的类：
class TiledImage : public Image
{
std::vector<Image*> tiles;
pub
浏览 0提问于2012-06-04得票数 1
2回答
当我将shared_ptr传递给将该参数复制到成员shared_ptr中的构造函数时，是否应该通过值传递该参数？
示例：
struct MyClass {
MyClass(std::shared_ptr<MyDependency> dep)
: dep(dep)
{}
std::shared_ptr<MyDependency> dep;
};
如果使用临时(MyClass(std::make_shared<...>()))构造，编译器应该移动参数(一两次？)。
编译器能够“自动”将dep移动到dep，还是应该使用:
浏览 0提问于2018-07-27得票数 3
回答已采纳
5回答
我在类中有几个容器，例如，包含shared_ptr的向量或映射到堆上的对象。
例如
template <typename T>
class MyExample
{
public:
private:
vector<shared_ptr<T> > vec_;
map<shared_ptr<T>, int> map_;
};
我希望这个类有一个公共接口，这个接口有时会将shared_ptrs返回给const对象(通过shared_ptr<const T>)，有时还会返回shared_ptr<T>，其
浏览 9提问于2010-01-17得票数 47
我正在尝试将shared_ptr返回到Group类型的对象，该对象的声明中包含const (此项目中的一个要求)。Group对象存储在类属性mySet<Group> groups中，mySet只是std::set的一个实现(也是一个需求)。我试着从各个角度着手这项工作，但似乎找不到一个可行的解决办法。
我省略了不相关的方法和属性，以保持它的最小和清晰。
typedef std::shared_ptr<Group> GroupPointer;
typedef mySet<Group>::const_iterator cgIterator;
class Cla
浏览 1提问于2018-01-25得票数 0
回答已采纳
4回答
我一直在使用pimpl惯用法制作一些对象，但我不确定是使用还是。
我知道std::unique_ptr更高效，但这对我来说并不是什么大问题，因为这些对象无论如何都是相对重量级的，所以std::shared_ptr相对于std::unique_ptr的成本相对较小。
我现在使用std::shared_ptr只是因为它有额外的灵活性。例如，使用std::shared_ptr允许我将这些对象存储在散列映射中以便快速访问，同时仍然能够将这些对象的副本返回给调用者(因为我相信任何迭代器或引用都可能很快变得无效)。
然而，在某种程度上，这些对象确实没有被复制，因为更改会影响所有副本，所以我想知道，使用st
浏览 1提问于2011-04-07得票数 53
回答已采纳
我对指针相当缺乏经验，而且我在简单指针和std::shared_ptr之间的区别上有困难。我想使用shared_ptr，这样在没有指向对象的情况下，我就不必如此小心地删除对象。
我使用的库/头()有问题。我认为这不是外部库的问题，而是我使用指针的问题。库有一个函数，它返回指向对象的简单指针。我总是将简单的指针转换为shared_ptr，这就是问题发生的地方。
// Works fine---but I want a shared_ptr
Object* MyInstance(ReturnPointerToObject(...));
// Compiles fine, but crashe
浏览 3提问于2014-10-02得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
