从本地原始指针初始化std::unique_ptr是否安全？
从本地原始指针初始化std::unique_ptr是安全的。
std::unique_ptr是C++11引入的智能指针，用于管理动态分配的对象。它提供了独占所有权的语义，可以确保在不再需要对象时自动释放内存，避免内存泄漏。
在使用std::unique_ptr时，可以通过将本地原始指针传递给其构造函数来初始化它。这样做是安全的，因为std::unique_ptr会接管指针的所有权，并负责在适当的时候释放内存。
需要注意的是，一旦std::unique_ptr接管了指针的所有权，就不应该再手动释放指针。否则会导致双重释放的问题，可能引发程序崩溃或内存损坏。
std::unique_ptr的优势在于它提供了自动内存管理的能力，避免了手动释放内存的繁琐和容易出错的过程。它还可以与其他智能指针和标准库容器等进行良好的集成。
对于本地原始指针的初始化，腾讯云提供了一系列与内存管理相关的产品和服务，例如云服务器CVM、云数据库CDB、云函数SCF等。这些产品可以帮助开发者更方便地进行云计算和内存管理的工作。
更多关于std::unique_ptr的信息，可以参考腾讯云C++开发者文档中的相关章节：std::unique_ptr。
相关·内容
下面的程序使用std::unique_ptr<T>来避免手动内存管理。我有两种方法来实现它。问题是在第二种方法中，在分配给原始指针之前，正在调用析构函数。这将导致程序崩溃，因为以后的代码试图访问无效内存。
第二种方法是如何在现有的代码库中使用智能指针，以便利用智能指针提供的自动内存管理。因此，我没有更改声明中指针的类型(.i.e)。从Widget* w到std::unique_ptr<Widget> w)。
有人能详细解释一下吗?最好的做法是什么？还是我漏掉了什么？
#include<iostream>
#include<memory>
clas
浏览 9提问于2014-08-28得票数 0
回答已采纳
我正在学习智能指针，下面的示例是test.cpp
#include<iostream>
#include<vector>
#include<memory>
struct abstractShape
{
virtual void Print() const=0;
};
struct Square: public abstractShape
{
void Print() const override{
std::cout<<"Square\n";
}
};
int main(){
浏览 2提问于2022-04-02得票数 5
回答已采纳
一个代码片段：
std::unique_ptr<SDL_Renderer, decltype(&SDL_DestroyRenderer)>
cGraphics::Create_Renderer()
{
SDL_Renderer* temprenderer = SDL_CreateRenderer(m_Window.get(), -1, 0);
SDL_SetRenderDrawColor(temprenderer, 255, 255, 255, 0xff);
return std::unique_ptr<SDL_Renderer,
浏览 3提问于2018-06-21得票数 3
回答已采纳
5回答
我有以下代码：
class foo {
public:
foo();
void setMean(std::shared_ptr<std::valarray<double>> input);
private:
std::shared_ptr<std::valarray<double>> mean;
}
.cpp文件：
foo::foo() : mean(nullptr) {
}
void foo::setMean(std::shared_ptr<std::valarray
浏览 1提问于2016-05-17得票数 0
回答已采纳
2回答
使用std::unique_ptr依赖默认删除器安全吗？
我想这样用它：
uint8_t* binaryData = new uint8_t[binaryDataSize];
std::unique_ptr<uint8_t> binPtr(binaryData);
因此，std::unique_ptr中的默认删除器如下所示：
template<typename _Up>
typename enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type
operator()(_Up* __ptr
浏览 0提问于2018-03-21得票数 0
回答已采纳
我有一个函数，它创建一个指向动态分配对象"c“的唯一指针。
template<typename T, typename... TArgs> void addComponent(TArgs&&... MArgs) {
if(!components.count(typeid(T))) {
T* c = new T(std::forward<TArgs>(MArgs)...);
c->entity = this;
std::unique_ptr<Component> uPtr{
浏览 5提问于2022-01-29得票数 0
回答已采纳
3回答
考虑我下面的代码。我对唯一指针的理解是，只能使用一个唯一指针来引用一个变量或对象。在我的代码中，有多个unique_ptr访问同一个变量。
据我所知，这显然不是使用智能指针的正确方式，因为指针应该从创建时就拥有完全的所有权。但是，为什么这是有效的并且没有编译错误呢？谢谢。
#include <iostream>
#include <memory>
using namespace std;
int main()
{
int val = 0;
int* valPtr = &val;
unique_ptr <int> uniq
浏览 0提问于2018-03-17得票数 11
我有疑问。让我们使用以下代码：
#include <iostream>
#include <string>
#include <memory>
class Writable {
public:
virtual ~Writable() = default;
virtual void write(std::ostream& out) const = 0;
};
class String : public Writable {
public:
String(const std::string& str) : m_str(
浏览 0提问于2018-12-10得票数 0
回答已采纳
我对std：：列表中的unique_ptr有奇怪的看法。
类slFlyingMonster是从类slMonster派生的。
以下代码起作用：
std::unique_ptr<slMonster> ptr(new slFlyingMonster(md));
但是这个代码：
std::list<std::unique_ptr<slMonster>> mMonsters;
mMonsters.push_back(new slFlyingMonster(md));
抛出错误：
“错误1错误C2664：‘无效
std::list>，std::allocator
浏览 0提问于2014-09-29得票数 5
回答已采纳
我将C库的subscribe函数封装到一个更高级的C++类的方法中。在该方法中，调用底层C subscribe，其中传递一个本地char*变量(char key[10])作为引用。现在的问题是--我刚才已经知道了--因为key是一个局部变量，它的值不受保护。我可以传递它的引用，但是一旦范围保留，内存将是空闲的。我正在经历这种undefined行为，回调从来没有被调用过-在调试之后，我看到key的值被改变了。
我试过使用new char[10]，这似乎是可行的。但我想这不是我应该去的方式。
对此，正确的解决方案是什么？更新：现在通过用string替换来修复它。
更新
接口功能：
IoT_Erro
浏览 0提问于2018-09-13得票数 1
回答已采纳
1回答
我正在尝试使用智能指针来实现二进制搜索树，并且我已经读到，实现它的推荐方法是使用unique_ptr，因为父节点拥有子节点，并且二叉树中没有多个所有者。
以这棵树为例，
10
4 20
2 5 11 30
3
在这里，4是左，10和2是左，4和3是右，2，等等。
现在这个结构看起来，
template<typename T>
struct TreeNode {
T
浏览 4提问于2021-11-16得票数 0
回答已采纳
2回答
有人能告诉我，下面的unique_ptr初始化有什么问题吗？
int main()
{
unique_ptr<int> py(nullptr);
py = new int;
....
}
g++ -O2 xxx.cc -lm -o xxx -std=c++11说：
error: no match for ‘operator=’ (operand types are ‘std::unique_ptr<int>’ and ‘int*’)
py = new int;
^
正在做什么
unique_ptr<int> px(new
浏览 11提问于2015-03-04得票数 6
回答已采纳
我有一个函数，用于分配给定大小的缓冲区。缓冲区将在返回之前进行预处理/填充一些数据。此预处理可能会返回false来表示此缓冲区未正确处理。因此，我希望在这个缓冲区上应用RAII，以避免在没有delete[]的情况下提前返回。
通常我使用unique_ptr来帮助我自动释放本地分配的对象。在这种情况下，我需要返回这个分配的对象(由unique_ptr拥有)，将所有权传递给调用方。但编译器抱怨说，我不能将unique_ptr<T[]>转换为T*，而我只能将unique_ptr转换为unique_ptr。看起来，unique_ptr只能移动到另一个unique_ptr，而不是原始指针。
浏览 3提问于2015-10-22得票数 11
回答已采纳
1回答
我有一个关于指针的问题：
class CAppFramework : public IBaseApp
{
public:
CAppFramework( std::initializer_list< CClientApp* > input );
CAppFramework( );
~CAppFramework( );
void Create( ) override;
void Release( ) override;
template< class T > T** Request( std::string c_appna
浏览 0提问于2017-04-06得票数 1
注意:这是一个API设计问题，为了这个问题，它依赖于unique_ptr和share_ptr的构造函数的设计，但并不打算对它们当前的规范提出任何修改。
虽然使用make_unique和make_shared通常是可取的，但是unique_ptr和shared_ptr都可以从原始指针构建。
两者都按值获取指针并复制它。这两种方法都允许(即:不阻止)继续使用在构造函数中传递给它们的原始指针。
以下代码编译双空闲代码并获得结果：
int* ptr = new int(9);
std::unique_ptr<int> p { ptr };
// we forgot that ptr is
浏览 2提问于2020-03-04得票数 4
回答已采纳
2回答
我正在尝试创建一个智能指针(unique_ptr)，指向作为const int&返回的值，但我的问题可以简单地概括为：
const int value = 5;
const int * ptr{nullptr};
ptr = &value;
这是可行的，并按预期进行编译。使用智能指针尝试相同时：
const int value = 5;
std::unique_ptr<const int> ptr{nullptr};
ptr = &value;
这样我就得到了编译错误：
no operator "=" matches these
浏览 3提问于2020-08-14得票数 1
回答已采纳
我刚开始使用boost库并尝试使用boost::scoped_ptr，它指出这个智能指针不能被复制或移动。但是我在玩一些代码的时候发现了一个问题。我能够创建新的scoped_ptr实例，并使用现有的有效scoped_ptr对其进行初始化。因此，如果一个scoped_ptr的作用域结束并释放内存，其他scoped_ptr仍然认为它是有效的指针并尝试访问。它在运行时给我错误。
我正在使用1.66版本的boost库，使用cygwin g++编译器并在编译时使用std=c++03选项。
#include<boost/scoped_ptr.hpp>
#include<iostream&
浏览 0提问于2019-11-05得票数 0
我正在尝试将数据嵌入到std::map中。下面是我尝试过的内容(从原始源中删除，但确实给出了想法)：
template<typename T> class trie {
private:
std::map<typename T::value_type, std::unique_ptr<trie<T>>> children;
std::unique_ptr<trie<T>> parent;
// Later
public:
trie(const trie<T>& other, trie<T>
浏览 2提问于2013-10-13得票数 2
回答已采纳
我一直在研究std::unique_ptr，但在某种程度上对它的语义感到困惑。从，
No two unique_ptr instances can manage the same object
但是，即使很难，这很可能是一个愚蠢的例子，请考虑这样的代码。
std::unique_ptr<int> a(new int(10));
std::unique_ptr<int> b = std::unique_ptr<int>(a.get());
std::cout << *b << std::endl;
*a = 5;
std::cout &
浏览 1提问于2014-05-18得票数 2
回答已采纳
2回答
我开始和std::unique_ptr玩了，我只是不想把事情搞砸。
在我的代码中，我正在创建一个std::unique_ptr，将它存储在一个vector上，供以后在另一个上下文中使用，然后继续使用指针：
#include <iostream>
#include <string>
#include <memory>
#include <vector>
class MyClass {
public:
void doWhatever ()
{
std::cout <
浏览 0提问于2015-07-14得票数 0
回答已采纳
2回答
我在试着理解为什么
std::unique_ptr<MyClass> p = new MyClass;
不起作用，但是
std::unique_ptr<MyClass> p;
p.reset(new MyClass);
很好。我有点理解它们的不同之处，但我想知道为什么做出这样的选择是为了让它们不同。赋值不同于重置有什么危险？
浏览 95提问于2018-05-03得票数 11
回答已采纳
难道std::unique_ptr不应该防止出现这样的错误吗？
#include <iostream>
#include <vector>
#include <memory>
struct B {
int b;
};
int main()
{
std::vector<std::unique_ptr<B>> v; // unique_ptr can be stored in a container
B* p = new B;
v.emplace_back(p);
std::cout <
浏览 1提问于2021-04-07得票数 1
我一直在为我的std::vector of unique_ptrs这样做：
m_stuff.push_back(std::unique_ptr<Thing> (new DerivedThing()));
这为我提供了当向量中的元素被删除时自动删除内存的功能。
我还有另一个场景，其他东西通过new创建堆内存，因此通用指针已经存在。现在，假设我这样做：
m_stuff.push_back(std::unique_ptr<Thing> (thingy));
//thingy is Thing*
我是否可以安全地假设，一旦我这样做了，我的向量m_stuff现在就
浏览 0提问于2013-05-15得票数 0
回答已采纳
3回答
我有一个结构和功能，如下所示：
struct MYOVERLAPPED : public OVERLAPPED
{
//...
};
void func1(std::unique_ptr<MYOVERLAPPED> pBuf)
{
//...
};
我正在获得指向MYOVERLAPPED的指针，我想传递给函数1-函数。我遇到的问题是，无论我尝试什么，我都会遇到以下错误：
我已经尝试了以下内容: Try1：
std::unique_ptr<OVERLAPPED> pOver(//....)
HandleAcceptIndication(std::mov
浏览 13提问于2011-09-09得票数 1
回答已采纳
2回答
我在看一些arduino代码，上面写着：
std::unique_ptr<BearSSL::WiFiClientSecure>client(new BearSSL::WiFiClientSecure);
通常，使用make_unique创建唯一指针。
所以我想知道我需要做些什么来处理这个指针？
浏览 1提问于2019-11-19得票数 0
回答已采纳
2回答
C++智能指针是否没有锁？
、、、、
对于std::unique_ptr和/或std::shared_ptr，下列操作是无锁的
去引用，即read(*myPtr)或myPtr->getSomething()
删除引用，即使用std::move(myUniquePtr)或当std::shared_ptr超出作用域时。
在我的例子中，我不会同时从多个线程访问这些指针。我只是好奇我是否能在一个高优先级、无锁的线程上专门使用它们。指针管理的对象是在高优先级回调之前由主线程分配的，并且在回调停止之前不会被释放。
谢谢!
浏览 1提问于2014-04-08得票数 5
回答已采纳
2回答
从工厂返回指针
、、、
从工厂返回指针的最佳方法是什么？它应该是一个std::unique_ptr或std::shared_ptr，还是仅仅是一个原始指针？
另外，有人告诉我，如果有容器，就应该使用std::unique_ptr，如果有聚合，就应该使用std::shared_ptr。这是正确的方式吗？
浏览 1提问于2012-10-25得票数 4
回答已采纳
我有std::map of std::string和std::unique_ptr<BaseInt>。基本上，我希望有一个映射，类名为字符串key，惟一指针作为对应的value。并以map["Derived1"]等形式访问指针(在下面的代码中解释)。
当我遍历std::map并尝试将每个value推送到std::vector时，我会看到以下错误
Error C2280 'std::unique_ptr<BaseInt,std::default_delete<_Ty>>::unique_ptr(const std::unique_pt
浏览 4提问于2019-11-20得票数 0
回答已采纳
2回答
假设我们有以下内容：
//! SomeClass.hpp
class
{
public:
SomeClass( void );
~SomeClass( void )
{
delete mFoo;
delete mBar;
}
...
private:
Foo* mFoo;
Bar* mBar;
StackObj mStackFoo;
};
//! SomeClass.cpp
SomeClass::SomeClass( void )
{
mFoo = new Foo;
m
浏览 0提问于2013-03-07得票数 0
回答已采纳
2回答
我有一个向量，它包含来自基类"SceneObject“的派生类的对象。对于此任务，我发现必须使用独特的指针，如下所示：
vector<std::unique_ptr<SceneObject>> objects;
为了将我的对象放在这个向量中，我用新关键字在堆上分配内存：
objects.emplace_back(new Sphere(glm::vec3(0.9, -1.925, -6.69), 0.825, sphereMaterial));
我在循环中访问这些对象的函数，如下所示：
objects[k]->intersect(...);
但是我的问题是，
浏览 5提问于2016-03-27得票数 2
回答已采纳
在此MCVE中：
#include <memory>
int main()
{
std::unique_ptr<char[]> myChars = std::make_unique<char[]>(20);
const char* cs = to_address (myChars);
return 0;
}
g++不能处理将to_address应用于myChars --它抱怨unique_ptr<char[]>没有名为->的成员。我正在使用g++10，但是从g++8开始就支持to_address了。我
浏览 6提问于2020-07-31得票数 1
回答已采纳
首先，std::unique_ptr::get不是违背了拥有unique_ptr的目的吗？我原以为这个函数会改变它的状态，这样它就不再持有指针了。std::unique_ptr::get有没有真正有用的用途？
浏览 0提问于2012-05-29得票数 65
回答已采纳
1回答
我仍然是C++的新手，并且遇到了一个问题，我似乎不能将新的派生类插入到映射中。
我的代码简化如下：
std::map<int, std::unique_ptr<Base_Class> > m;
void func(){
for(int num = 0; num < 100; n++){
m.emplace(num, new Derived_Class() );
}
}
这给了我这样的结论：
error: no matching function for call to 'std::pair <const int, std::u
浏览 1提问于2018-12-09得票数 5
我在地图值中使用unique_ptr。我需要将这些值作为原始指针的列表/向量。到目前为止，我所做的工作如下。
#include <iostream>
#include <string>
#include <vector>
#include <memory>
#include <map>
class Foo {
public:
std::string val;
Foo(std::string v) : val(v) {
}
};
class Unique {
public:
std:
浏览 1提问于2016-07-06得票数 1
回答已采纳
为了向我的函数f提供更好的接口，我使用了一个模板：
#include <iostream>
#include <memory>
using namespace std;
using UPSTR = unique_ptr<char[]>;
void f(const initializer_list<UPSTR>& list){
// process strings, concatenate, excluding certain patterns..
for(auto& x:list) cout << x.ge
浏览 8提问于2022-09-09得票数 0
我很难将unique_ptr从我的方法参数推到共享指针向量上。
IFCCB.h：
private:
vector<shared_ptr<IFC>> m_shpVectorIFC;
public:
void addElementVectorIFC(unique_ptr<IFC> rupIFC);
IFCCB.cpp：
void IFCCB::addElementVectorIFC(unique_ptr<IFC> rupIFC)
{
m_shpVectorIFC.push_back(std::unique_ptr<IFC>(ne
浏览 3提问于2015-01-07得票数 1
回答已采纳
3回答
我最近一直在考虑这个问题，我能看到的唯一支持std::unique_ptr的相等操作符的理由是为了完整性，这样标准模板库中的所有智能指针都有它。但是，除非您做错了什么，否则我看不到任何可能返回true的示例。 很明显，这样做是可能的： int* a = new int(1);
std::unique_ptr<int> u_a1(a);
std::unique_ptr<int> u_a2(a);
if(u_a1 == u_a2)
{
std::cout << "I'm double deleting soon" <&l
浏览 10提问于2020-04-03得票数 5
回答已采纳
我正在学习std::unique_ptr，试图探索它所代表的意义。
给定返回unique_ptr的函数(超出我的控制范围)，是否暗示/很好地理解每次调用都返回指向新对象的unique_ptr (与以前的调用不同)？
例如，下面的代码在退出时产生一个双自由，我希望我能正确理解为什么：unique_ptr在销毁时删除它们的底层对象；因此，两个封装相同内存/对象的unique_ptr将在销毁第二个内存/对象时导致双释放。因此，以下函数getUniquePtr()的实现是否会被普遍/含蓄地理解为不合理？
// main.cpp
#include <memory>
#include <
浏览 6提问于2020-12-02得票数 1
回答已采纳
我有一个任务是复制linux shell命令(ls、mkdir等)，所以我使用的是通用的树结构。基本上，directory类有一个指向基类(file)或另一个派生类(directory)的指针向量。每当我尝试push_back一个指向新目录的唯一指针时，我都会得到以下错误。
/usr/include/c++/8/ext/new_allocator.h:136:4: error: no matching function
for call to ‘std::unique_ptr<FileData*>::unique_ptr(std::unique_ptr<Directory,
浏览 1提问于2019-09-06得票数 0
考虑以下代码：
#include <memory>
#include <vector>
class A {
public:
explicit A(std::vector<int> &&v) : v_(std::move(v)) {}
private:
std::vector<int> v_;
};
int main() {
// compilation error (no matching call to std::make_unique)
// compiler output: https://ideone
浏览 21提问于2017-07-16得票数 0
通常，如果使用std::shared_ptr指向对象，并且希望创建指向不共享所有权的对象的另一个指针，则将创建一个std::weak_ptr。
// Create a shared pointer to own the object
std::shared_ptr<int> p = std::make_shared<int>(42);
// Create a weak pointer (that does not own the object)
std::weak_ptr<int> q(p);
// Use the weak pointer some t
浏览 0提问于2019-03-06得票数 5
回答已采纳
2回答
我已经听过几次了，在存储原始指针时，std::vector不是异常安全的，应该使用unique_ptr或shared_ptr。
我的问题是，为什么std::vector不是异常安全的，这些类是如何解决这个问题的？
浏览 0提问于2012-04-11得票数 1
回答已采纳
我环顾了一下四周，却找不到答案。
我有一个函数返回一对指向对象的指针，这种情况可以简化为：
#include <iostream>
#include <utility>
#include <memory>
std::pair<int *, int *> shallow_copy()
{
int *i = new int;
int *j = new int;
*i = 5;
*j = 7;
return std::make_pair(i, j);
}
int main(int argc, char *argv
浏览 3提问于2014-11-28得票数 0
回答已采纳
2回答
我读过很多关于这方面的话题，到目前为止还没有解决办法，所以我肯定做错了什么。
这样做是可行的：
std::vector<CalendarDay*> calendarWeek;
calendarWeek.push_back(new CalendarDay(hWndParam, ctrlRc, timeParam, week * MY_CLDR_DAYS + day));
这是不起作用的(根据，它应该是这样的)：
std::vector<std::unique_ptr<CalendarDay>> calendarWeek;
calendarWeek.push_b
浏览 2提问于2020-05-08得票数 0
回答已采纳
我是C++新手，对于下面两个场景中发生的事情有些困惑。
使用新关键字创建变量，然后将该变量作为std::unique_ptr<>(x)传递给函数。当我这样做时，我仍然可以从我传递的类中访问这个->处理程序_。
注:y是X的超类
this->handler_ = new X(this);
auto res1 = root()->grpcStreamHandler(std::unique_ptr<Y>( this->handler_));
将变量创建为唯一指针，并直接传递它。
注:y是X的超类
this->handler_ = std::uni
浏览 0提问于2021-03-24得票数 0
回答已采纳
如果我有一个baseclass，Attribute，它有一个名为clone的方法，它返回一个Attribute，但是它的子类Direction在返回Direction时会得到一个错误。
Attribute Attribute::clone() {
if(this->currentValue) {
return Attribute(this->type, this->currentValue);
} else if (!this->param.empty()) {
return Attribute(this->type
浏览 4提问于2014-07-01得票数 1
回答已采纳
5回答
智能指针的效率如何？
、、、
我知道，std::shared_ptr使用引用计数，因此它具有复制和移动语义，而另一方面，std::unique_ptr (因此名称唯一)只有移动语义，因此试图复制它是编译错误。
然而，我不太清楚这到底有多大。在大多数情况下，我是否可以简单地使用std::shared_ptr over std::unique_ptr，或者应该尽可能地使用std::unique_ptr，因为它更高效，因为它不需要处理引用计数问题。
此外，我知道智能指针在处理异常安全时很有用，但它们是否通常是替代传统T*指针的一种手段？在可能的情况下，在传统的T*指针之上使用智能指针是一个好的编程实践吗？
浏览 4提问于2015-05-29得票数 3
回答已采纳
2回答
工厂返回智能指针的C++寿命
、、、、
我在C++11中使用一个工厂模式，它位于我的main()函数的范围内，调用如下所示：
histogram_requests -> AddNewPostfix( Postfix_factory :: get_postfix( "Layers", ntuple_reader ) );
Postfix_factory::get_postfix()是一个静态成员函数，返回一个std :：unique_ptr< Postfix>。一个示例返回值是：
return std :: move( std :: unique_ptr<Postfix>( new Lay
浏览 2提问于2015-11-07得票数 0
下面是一个示例代码：
class Interface
{
public:
virtual ~Interface(){}
virtual void fun() = 0;
};
class InterfaceImpl: public Interface
{
public:
void fun() override
{}
};
class B
{
public:
B(const std::shared_ptr<Interface>& impl /*std::unique_ptr<Interface>& impl* ?*
浏览 0提问于2019-07-31得票数 1
回答已采纳
1回答
我想在声明之后初始化类中的唯一指针，我尝试了几种方法，但都无法解决错误。 template <typename T>
struct Destroy
{
void operator()(T *t) const
{
t->destroy();
}
};
class Test
{
std::unique_ptr<IRuntime, Destroy<IRuntime>> runtime;
public:
Test()
{
/*
the functio
浏览 56提问于2021-10-22得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
