智能指针的概念
智能指针是一种用于管理动态分配内存的工具，它通过自动化内存的生命周期管理来减少内存泄漏和悬挂指针等问题。智能指针是一个封装了原始指针的对象，它提供了类似于指针的行为，同时还负责处理内存的释放。
智能指针的分类：
- 唯一指针（unique_ptr）：unique_ptr是C++11引入的智能指针，它提供了独占所有权的语义。只能有一个unique_ptr指向同一块内存，它在析构时会自动释放内存。unique_ptr可以转移所有权，也可以与原始指针进行交换。
推荐的腾讯云相关产品和产品介绍链接地址：
- 腾讯云C++ SDK：https://cloud.tencent.com/document/product/876
- 共享指针（shared_ptr）：shared_ptr允许多个智能指针指向同一块内存，它使用引用计数来跟踪内存的使用情况。只有当所有shared_ptr都释放了对内存的引用，才会释放内存。shared_ptr可以通过复制来共享所有权，也可以通过reset()函数重新指定内存块。
推荐的腾讯云相关产品和产品介绍链接地址：
- 腾讯云C++ SDK：https://cloud.tencent.com/document/product/876
- 弱指针（weak_ptr）：weak_ptr是一种特殊的共享指针，它不会增加内存的引用计数。它通常用于解决共享指针之间的循环引用问题，避免内存泄漏。weak_ptr可以通过lock()函数获取一个可用的shared_ptr，如果所指向的内存已被释放，则返回空指针。
推荐的腾讯云相关产品和产品介绍链接地址：
- 腾讯云C++ SDK：https://cloud.tencent.com/document/product/876
智能指针的优势：
- 自动内存管理：智能指针通过封装原始指针，自动在适当的时机释放内存，避免了手动管理内存的麻烦和潜在的内存泄漏问题。
- 安全性：智能指针可以减少悬挂指针和野指针的风险，提高代码的安全性和稳定性。
- 便利性：智能指针的使用类似于原始指针，可以使用箭头操作符和星号操作符来操作指向的对象。
智能指针的应用场景：
- 动态分配内存：智能指针可以用于管理动态分配的内存，确保内存的及时释放，避免内存泄漏。
- 异常安全性：智能指针在异常发生时也能正确释放内存，提高程序的异常安全性。
- 循环引用处理：智能指针可以解决共享资源之间的循环引用问题，避免内存泄漏。
总结：智能指针是一种用于管理动态分配内存的工具，通过自动化内存的生命周期管理来减少内存泄漏和悬挂指针等问题。主要包括唯一指针、共享指针和弱指针三种类型。腾讯云提供了C++ SDK用于支持智能指针的相关操作。智能指针具有自动内存管理、安全性和便利性等优势，适用于动态分配内存、异常安全性和循环引用处理等场景。
相关·内容
如果设置如下，将使用什么适当的智能指针类型？还是在这种情况下应该使用原始指针？
void factory (some_ptr_type_here<A> a)
{
a = some_type_of_new<A>(...,..);
}
some_ptr_type_here<A> a;
factory(a);
浏览 0提问于2016-05-26得票数 0
回答已采纳
3回答
除了STL，我只在C++窗口编程中找到了CComPtr。在windows SDK中有没有其他类型的智能指针？谢谢。
浏览 0提问于2011-04-17得票数 1
我希望屏幕上出现一个QDockWidget，所以我使用了以下代码：
QDockWidget *dock = new QDockWidget("Title-1", this) //'this' is the main window
dock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
this->addDockWidget(Qt::LeftDockWidgetArea, dock);
它的工作原理如我所料:屏幕上出现了一个QDockWidget。
但是当我试图重
浏览 5提问于2017-04-22得票数 1
回答已采纳
3回答
对我来说，这两者的区别还不清楚。我所读到的关于它们的内容非常庞大和复杂(就像C++一样)。例如，属于多年前，也来自WikiPedia。也许这个问题本身就很复杂。
我对他们的看法是，RAII是一种机制，我们使用它作为智能指针，但我不确定这一点。我需要一个简单明了的答案。
你能用一种简单的语言用一个小的示例代码解释一下吗？请记住，我在C++的水平很低。
浏览 7提问于2016-03-08得票数 5
回答已采纳
1回答
我认为我对正常(功能)设计模式有相当丰富的经验，如在中描述的，我主要使用在java和C#中。在这些“管理”语言中，这几乎是完成工作所需要知道的一切。
然而，在C++世界中，开发人员还控制着如何分配、传递和删除所有对象。我理解这些原则(我在其他文本中读过 )，但我仍然需要很大的努力来决定哪种机制最适合于给定的场景--而这正是与内存相关的设计模式组合将是有用的。
例如，昨天我不得不创建一个类Results，它是几个对象的容器，还有另一种类型的对象的集合(std::vector )。因此，有几个设计问题我无法真正回答：
是按值还是按智能指针返回该类？
在类中，向量和对象是普通成员，还是应该再
浏览 1提问于2013-01-26得票数 9
回答已采纳
3回答
在C++中，如果您将匿名对象作为参数传递给命名对象方法，那么当您删除命名对象时，匿名对象是否会被删除？
项目的希望它自己的大多数对象的方法都指向对象的指针，比如：
WContainerWidget::addWidget(WContainerWidget* widget) {/*...*/}
在他们的示例中，当构造这些对象时，他们经常使用new运算符。
WContainerWidget* aFoo = new WConainerWidget(/*args*/);
aFoo->addWidget(new WText(/*args*/));
如果我执行delete aFoo，匿名WText()
浏览 0提问于2012-04-16得票数 1
回答已采纳
2回答
智能指针内存池
、、、
我正在开发一个大型的旧代码库，它使用内存池来获得巨大的速度优势。然而，问题是通过内存池分配和释放内存很复杂。我想尝试使用智能指针，但有人建议我在性能上的损失将是一个问题。
目前出现的解决方案似乎是一种智能指针实现，它继续使用幕后的原始内存池。我找不到任何正在使用的智能指针/内存池组合。有没有人能给我举一个这样的例子呢？在尝试之前，有什么我应该注意的陷阱/注意事项吗？
浏览 5提问于2015-02-21得票数 1
如果我有一个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
回答已采纳
为什么C++标准不包括比较操作符来比较智能指针(unique_ptr，shared_ptr，.)有规则指针(T*)？
汤姆
更新--我并不是想了解它是如何实现的。问题是为什么不将其定义为C++标准的一部分？对于unique_ptr和shared_ptr来说，这样的定义将是微不足道的。
这方面的用例如下:A类有一个带有unique_ptr键的映射。unique_ptr用于内存管理。当A类的用户传递一个常规指针时，将在此映射中执行查找。不幸的是，标准没有定义比较操作符。
浏览 2提问于2013-08-05得票数 22
回答已采纳
1回答
我正在尝试完成以下代码中出现错误的语句。
每当执行这条语句时，我都会收到一个分段错误。
这句话有什么问题吗？
假设，
struct StructX
{
int ** dblPtrArray;
}
int main()
{
StructX * obj;
int i = 0;
int j = 0;
obj[i].dblPtrArray[i][j] = 0; // error here
return 0;
}
浏览 8提问于2020-04-16得票数 0
今天有人问我关于C++中的智能指针，我找不到任何关于它的有用信息。
有人能告诉我:什么是智能指针吗？您什么时间需要?你有没有什么例子说明智能指针是很有用的？
谢谢!
浏览 1提问于2011-02-15得票数 7
回答已采纳
1回答
我知道，进入规则是始终使用shared_ptr或其他智能指针。但是，我不知道如何在不使用std::make_shared复制控件的情况下实现它。我将详细说明：
问题所在
我想要创建一个类似树的表达式，比如：
struct foo{
std::vector<foo*> v;
};
这使我可以做以下工作：
foo add(foo& f1, foo& f2){
return foo {&f1, &f2};
}
这很好，因为这样两个节点就会成为一个新节点的子节点。
我希望正确评估以下几点：
foo x, y;
auto z = add(x,y
浏览 6提问于2017-09-04得票数 2
回答已采纳
我在我的C++代码和一些Lua脚本中使用了一个类。该类的相关部分如下所示：
typedef boost::shared_ptr<Thing> ThingPtr; // convenient
class Thing
{
public:
Thing() { /* do some stuff */ }
~virtual Thing() { }
ThingPtr createThing()
{
ThingPtr thing(new Thing);
// initialization can't be done i
浏览 0提问于2013-10-02得票数 3
回答已采纳
3回答
据我所理解，动态内存分配可以用来控制对象的生存期。当我将一个对象"new“时，它会留在内存中，堆中，直到我删除为止。
有时候事情没那么简单。在这种情况下，我希望保留某些内存块，直到我释放它为止，以防止对该内存块中的数据的破坏。例如，我希望将指向在堆栈上分配的对象的指针插入到向量中。每当指向对象的指针位于该向量中时，指针所指向的对象就不能被销毁。这是出于安全原因。如何才能做到这一点，使用动态内存分配预留一个内存块？
浏览 4提问于2013-04-30得票数 1
1回答
考虑一下
map <char,node*> mp;，其中节点是一个类
如果我们使用mp.clear();，那么是否需要显式地释放内存？
浏览 0提问于2018-07-17得票数 2
2回答
我在文章中读到了关于智能指针的文章：
"scoped_ptr适用于原始指针，而scoped_array则适用于动态数组。“
但我不明白他们所谓的“原始指针”是什么意思，所以这句话也不明白。
你们中有人能跟我解释一下吗？谢谢
浏览 7提问于2013-08-07得票数 1
3回答
智能指针和复制构造函数
、、、、
根据我的理解，提供用户定义的复制构造函数的主要原因是，我们需要确保数据成员指针是深度复制的。
这是否意味着如果我们用智能指针替换原始指针数据成员，那么提供用户定义的副本构造函数的频率就会降低吗？
浏览 9提问于2014-04-01得票数 0
我有一个接受std::shared_ptr参数的函数，我想把派生类型的对象从python传递给这个函数。下面是我的类定义：
struct AbstractBase {
virtual void foo() = 0;
};
struct Derived : public AbstractBase {
virtual void foo(){
std::cout<<"Derived's foo!"<<std::endl;
}
};
struct Unrelated {
void bar(std::sh
浏览 1提问于2013-05-31得票数 1
回答已采纳
我有以下代码
#include <bits/stdc++.h>
struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode() : val(0), left(nullptr), right(nullptr) {}
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(
浏览 3提问于2022-09-03得票数 0
回答已采纳
3回答
我即将完成Koenig &Moo的加速C++，在第13章和第14章中，他们阐述了一些句柄类(简单、共享、引用计数)的思想和实现。
这些类封装一个原始指针，并将动态对象的分配/去分配从客户端代码中抽象出来，以避免原始指针的所有危险，并允许用户取消对它们访问指向对象的引用。基本上，这是一种与原始内存资源进行接口的“更安全”的方法。
这些章节中的类本质上是智能指针的实现吗？对于我来说，智能指针仍然是非常新的，但据我所知，这些句柄类正在执行相同的功能。
这两者之间是有区别的，还是只是同一事物的另一个名称呢？
假设它们在功能上是等价的，那么在实践中，像这样的类是否会从头开始编写，而不是使
浏览 9提问于2010-08-02得票数 5
回答已采纳
1回答
我对智能指针完全是新手，更不用说C++了，所以在这里请容忍我。我的程序试图用唯一的序列号来构造类。它通过将已经制造的序列号放入shared_ptr来实现这一点。理论上，这个指针应该共享到所有类的集合，但是它失败了。这是我的课堂代码：
#include <iostream>
#include <cstdlib>
#include <set>
#include <memory>
#include <algorithm>
struct numbered{
numbered();
int mysn;
std::sha
浏览 1提问于2021-02-04得票数 0
回答已采纳
8回答
在使用智能指针(如"this"？)的C++项目中，关于使用boost::shared_ptr的好设计理念是什么？
考虑到这一点：
存储包含在任何智能指针中的原始指针是危险的，以供以后使用。您已经放弃了对对象删除的控制，并信任智能指针在正确的time.Non-static类成员处使用this指针进行操作。它是一个原始指针，不能更改。
如果我将this存储在另一个变量中，或者将它传递给另一个函数，该函数可能会将其存储起来供以后使用，或者将其绑定到回调中，那么当任何人决定创建指向类的共享指针时，我都会创建引入的bug。
考虑到这一点，我什么时候才能显式地使用一个this 指针呢？是否
浏览 15提问于2008-12-19得票数 11
回答已采纳
返回一个std::pair，它保存一个指针，指向分配的存储开始和分配的对象数，其对应对象的唯一目的是：是释放以前用std::get_temporary_buffer分配的内存。
这两个函数都位于<memory>头上，其主要目的是提供工具来增强内存管理(顾名思义)，并使内存管理更加安全。
关于内存管理的安全性，<memory>报头还提供了智能指针实用程序，允许以-like方式管理内存，从而使内存管理异常安全。
C++14还添加了助手函数，因此在很多情况下我们可以避免使用原始指针。
通过所有这些减少原始指针使用的努力，意识到std::get_temporary_buffer
浏览 7提问于2015-07-21得票数 0
回答已采纳
1回答
一种极简式的读拷贝更新类。
、、、、
这是一个非常简单的阅读-复制-更新(区域协调股)-inspired同步类：
#include <atomic>
template<typename T>
class RCU
{
private:
std::atomic<T*> curr;
std::atomic<T*> prev;
std::atomic<int> readers;
public:
RCU()
: curr (new T),
prev (nullptr),
readers(0)
浏览 0提问于2019-07-15得票数 1
4回答
内存管理和C++容器类
、、、、
我在使用std容器类(列表、映射等)时遇到了一些问题。在C++中。这个问题似乎与移除容器的项有关。我尝试在容器中存储指向对象的指针，然后当我想从容器中删除该项时，我使用erase或remove。当我这样做时，容器是真的删除了容器中的对象，还是简单地从容器中移除了指针？
我希望它只是移除指针，因为我正在使用容器对对象进行分组，并且对象可能在多个组中，所以我不希望它在从容器中移除时被删除！
谢谢!
浏览 3提问于2012-03-01得票数 0
回答已采纳
6回答
假设我想实现一个智能指针a_ptr，它可以与其他智能指针进行比较。
然后，我需要实现比较操作符的所有排列：
template<class T, class U>
bool operator==(const a_ptr<T>& a, const a_ptr<U>& b)
{
return a.get() == b.get();
}
template<class T, class U>
bool operator==(const std::shared_ptr<T>& a, const a_ptr<
浏览 5提问于2012-01-03得票数 3
回答已采纳
下面的代码是，但我不明白为什么会这样。
#include <functional>
#include <iostream>
#include <memory>
struct foo
{
int get_val() const
{
return 42;
}
};
int main()
{
foo obj;
std::shared_ptr<foo> ptr = std::make_shared<foo>();
const auto getter = std::mem_f
浏览 1提问于2017-01-10得票数 2
回答已采纳
我会举几个例子来解释一下。首先，我声明一些对象，比如
CString* param = new CString[100]
当我声明这个的时候，我的内存会增加一点，因为它是一些实现的字符串。然后我将这个对象存储在某个CString列表中，就像这样
List<CString> myList = new List<CString>; // new list of CString
myList.add(param);
这是我的问题:我想知道，当我删除myList时，我的参数不会被删除，对吧？参数中的记忆仍然存在。
我是不是误解了？
浏览 0提问于2012-09-17得票数 1
假设我有一个由对象层次结构表示的丰富数据模型。
我还有一个视图层次结构，它可以从模型对象中提取所需的数据并显示数据(并允许用户操作数据)。
实际上，可以有多个视图层次结构来表示和操作模型(例如，概述详细视图和直接操作视图)。
我目前的方法是让控制器层在View对象中存储对底层模型对象的引用。视图对象随后可以从模型中获取当前数据以供显示，并可以发送模型对象消息来更新数据。视图对象实际上是模型对象的观察者，当属性发生变化时，模型对象广播通知。
这种方法允许所有视图在任何视图更改模型时同时更新。
仔细执行，这一切都是有效的。但是，要确保没有视图或模型对象保存对模型对象的任何陈旧引用，确实需要做大量工
浏览 0提问于2013-07-26得票数 6
在C++11和boost中，智能指针都可以是nullptr。我想知道为什么。这意味着，每次从不受控制的客户端代码传递到接口方法时，都必须检查智能指针是否为nullptr。显然，这样的检查是在运行时执行的。
如果智能指针只能通过make_shared或make_unique创建，并且不能重置或重新分配给nullptr或原始指针，怎么办？这种方法允许确保指针在编译时不是nullptr。
例如，在Java中，我们总是必须检查对象是否为空(坏)。但是在Swift中，我们可以显式地确保参数(或变量)在编译时不为空(很好)。
UPD:嗯，非常感谢您的回答和评论。我有主意了。但是，是否有支持非无效编译时间保
浏览 1提问于2015-03-06得票数 5
回答已采纳
我使用-fsanitize=address编译了我的代码，并得到了以下错误：
==53702==ERROR: AddressSanitizer: new-delete-type-mismatch on 0x60300000efe0 in thread T0:
object passed to delete has wrong type:
size of the allocated type: 24 bytes;
size of the deallocated type: 1 bytes.
#0 0x7fd544b7b0a0 in operator delete(void
浏览 1提问于2017-01-09得票数 17
回答已采纳
2回答
我正在用C++编写一个智能指针实现，我在常量正确性方面遇到了一些问题。下面是代码的摘录：
template <class T> class Pointer {
T* pointee;
public:
Pointer(const Pointer<T>& other) { // must be const Pointer& for assignments
pointee = other.getPointee();
}
T* getPointee() const {
return pointee;
}
};
这是一
浏览 4提问于2011-10-27得票数 2
回答已采纳
1回答
假设你做了一个游戏引擎，你有几个GameObjects，每个GameObject都有一个你可以添加或删除的组件列表。
假设有一个具有顶点、法线等的MeshComponent。如果多个GameObjects具有相同的MeshComponent，将会有大量的内存浪费。当然，有很多方法可以实现这一点，但我想要一些好的建议，如何解决这个问题？组件如何共享不会被修改的数据？
浏览 0提问于2011-05-22得票数 0
回答已采纳
我的问题是，我需要能够创建一个包含100个对象的数组。但是，这些对象可以是四个不同对象中的一个，所有这些对象最终都派生自一个抽象类。我可以使用4个独立的数组，但似乎我的老师只想让我们使用一个数组。
类结构是: DVD和VHS派生自视频，CD和卡带派生自音频，音频和视频派生自媒体。音频、视频和媒体都是抽象的。
浏览 1提问于2012-12-03得票数 2
3回答
我正在使用c++上的and浏览器主机，我设法接收事件，并在DISPID_DOCUMENTCOMPLETE上运行此void：
void DocumentComplete(LPDISPATCH pDisp, VARIANT *url)
{
READYSTATE rState;
iBrowser->get_ReadyState(&rState);
if(rState == READYSTATE_COMPLETE)
{
HRESULT hr;
IDispatch *pHtmlDoc = NULL;
IHT
浏览 0提问于2010-10-04得票数 1
回答已采纳
在整个应用程序中，我都有一个对象的共享指针。以下是一个例子：
std::shared_ptr<MyTexture> texture = loadImageFromFile("someFile.png");
我使用一个名为ImGui的UI库，这个库有一个纹理ID的概念，它是一个空指针。我正在通过以下操作将数据传递给这个库：
ImGui::Image(texture.get());
我的后端将这些纹理存储在指向Graphics相关数据类型(它是一个Vulkan描述符集，但)的映射中，以便能够呈现纹理。现在，我有一个特别的问题。我想用一个智能指针来处理这个问题。但是，我将
浏览 2提问于2021-12-31得票数 0
考虑两个类
class A{
public:
int i;
A(){}
explicit A(const int ii):i(ii){}
virtual ~A(){
cout<<"~A - "<< i <<endl;
}
virtual void inc(){
i++;
cout<<"i: "<<i<<endl;
}
};
class B: public A{
public:
i
浏览 0提问于2012-09-10得票数 0
回答已采纳
2回答
智能指针的概念
、、
给定一个如下所示的类模板： template<typename T>
struct foo
{
T data;
}; 如何使用C++20概念来确定T是否是像std::shared_ptr<T_underlying>这样的智能指针？ 我想基于这个标准向foo<T>添加功能。例如，我希望使用新的概念系统，而不是使用SFINAE。 我想要达到这样的效果： template<typename T>
struct foo
{
T data;
void func()
requires is_shared_ptr_v<
浏览 56提问于2021-01-17得票数 2
回答已采纳
1回答
我在Mac上使用g++从命令行编译代码，但在运行导致EXC_BAD_ACCESS的代码时出现错误
我已经看到，调试这类错误最有帮助的方法是使用僵尸对象，这些对象在释放时不释放，然后在代码试图释放它们时发出警告。
然而，似乎NSZombie选项在Xcode/Objective C中是可用的。
所以我的问题是，有什么方法可以在简单编译的程序代码中使用这种功能/等效功能
g++ file1.cpp -g -o executable
已使用
gdb executable
谢谢。
浏览 2提问于2014-11-28得票数 0
3回答
最近，我开始为自己研究Qt，并有以下问题：
假设我有一些QTreeWidget* widget。在某个时候，我想向它添加一些项目，这是通过以下调用完成的：
QList<QTreeWidgetItem*> items;
// Prepare the items
QTreeWidgetItem* item1 = new QTreeWidgetItem(...);
QTreeWidgetItem* item2 = new QTreeWidgetItem(...);
items.append(item1);
items.append(item2);
widget->addTopL
浏览 3提问于2010-06-08得票数 9
回答已采纳
1回答
下面的代码导致运行时错误。
每个shared_ptr拥有相同的内存，但每个one的计数仍然是1。
因此，每个共享指针都是不同的，所以当它们超出作用域时，它们会尝试释放块，这会导致堆损坏。我的问题是如何避免这种情况？
我只想像这样添加声明
shared_ptr<int> x(p);
是没有商量余地的我必须声明。
#include <iostream>
#include <memory>
using namespace std;
int main ()
{
int* p = new int (10);
shared_ptr<int> a (p
浏览 1提问于2016-04-11得票数 4
2回答
我经常使用一段旧代码，其中原始指针与智能指针混合在一起，我没有时间将所有原始指针都更改为smart。
还有一些情况，比如指向对象的静态原始指针，这可能已经被破坏了，一开始使用weak_ptr保存引用似乎是一种情况，但是出现了问题，因为带有原始指针的位置没有任何关于shared_ptrs已经指向同一个对象的信息。
所以：
1)是否有更智能的智能指针来跟踪指向对象的所有指针(包括原始指针和智能指针)？
2)是否有任何智能指针至少跟踪所有shared_ptrs到一个对象？
我不想讨论一个实现，如果可能的话，我想把它作为一个黑匣子。
编辑:我问了2)，因为例如，对一个对象调用两次make_shared
浏览 3提问于2019-11-20得票数 0
回答已采纳
2回答
下面是我一直在读的一本C++书中的一些代码，展示了如何创建您自己的智能指针：
template <typename T>
class SuperSmartPointer
{
public:
explicit SuperSmartPointer(T* inPtr);
virtual ~SuperSmartPointer();
SuperSmartPointer(const SuperSmartPointer<T>& src);
SuperSmartPointer<T>& o
浏览 4提问于2013-12-12得票数 1
回答已采纳
我正在尝试使用
WifiConfig.h
#include "DHT.h"
class WifiConfig
{
public:
WifiConfig();
std::unique_ptr<DHT> dht;
void initialize(char const *ssid, char const *psk);
}
WifiConfig.cpp
#include "WifiConfig.h"
WifiConfig::WifiConfig() {}
void WifiConfig::initialize(char con
浏览 0提问于2019-04-23得票数 0
我在一家使用自定义DSL的公司工作，我的工作是将VM移植到C++。
我试图按照C++11标准来实现这一点，所以我在适当的时候使用auto，新的语法等等。但是我在试图“移植”代码中使用原始指针到新的智能指针的一部分时遇到了问题。
在这个DSL中，每个对象都是从一个名为MObject的基类派生出来的，例如，数字由这个类处理：
class MNumber : public MObject {
...
}
负责处理VM内存的类如下所示：
class Mallocator {
...
std::vector<MObject*> memory; //where all objects go..
浏览 0提问于2014-11-29得票数 2
回答已采纳
4回答
我对C++智能指针非常陌生，在函数参数中使用它们时，我很难理解这个建议。
"C++编码标准:101个规则、准则和最佳实践“指出，这些都是传递智能指针的原因。
更喜欢经过(智能)指针
如果参数是可选的(因此调用方可以将null传递为“not available”或“not‘t”值)
或者该函数存储指针的副本。
或者以其他方式操纵论点的所有权。
有人能给我举个例子吗?为什么不使用智能指针在这种情况下是个坏主意？
浏览 11提问于2012-10-01得票数 4
2回答
我使用了一个C# COM的在线示例，并通过C++调用它。下面是Calc COM代码，只有一个接口"ICalc“和一个类"Calc”。
namespace COMLib
{
[Guid("F40D7BC9-CF53-4613-AA5E-F269AD73808F")]
[InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
public interface ICalc
{
[DispId(1)]
long Factorial(int n);
}
[Guid("8EE38F2E-75BE-
浏览 0提问于2013-05-05得票数 3
回答已采纳
我考虑在C++11中重载，以便为生成true，因为后者的行为非常类似于T*。
#include <type_traits>
namespace std {
template <typename T> struct is_pointer<shared_ptr<T>> : std::true_type {};
template <typename T> struct is_pointer<shared_ptr<T const>> : std::true_type {};
}
我想知道为什么这个重载还没有包含在
浏览 0提问于2013-06-12得票数 15
回答已采纳
1回答
关于C++中的析构函数，我有一个有点特别的问题。通过代码来解释我要求的内容要容易得多。基本上，我想做一些类似的事情(但不完全是这样)：
foo( bar().ptr );
在本例中，指针指向从'bar()‘返回的对象中的动态内存。我们可以假设指针是简单的char*。我想确定'ptr‘在’foo()‘执行过程中指向生命的数据。
foo( char* ptr )
{
// do stuff with *ptr
}
obj bar()
{
obj thing;
return thing;
}
struct obj
{
char* ptr;
浏览 7提问于2016-05-06得票数 1
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
云直播活动推荐
腾讯云开发者
