与C ++ 11中的普通指针相比，智能指针的开销是多少？换句话说，如果我使用智能指针，我的代码会变慢吗？如果这样，速度会慢多少？

具体来说，我在问C ++ 11 std::shared_ptr和std::unique_ptr。

显然，被压入堆栈的东西会更大（至少我认为是这样），因为智能指针还需要存储其内部状态（引用计数等），所以问题的实质是，这将要花费多少呢？会影响我的表现吗？

例如，我从函数而不是普通指针返回智能指针：

std::shared_ptr<const Value> getValue();
// versus
const Value *getValue();

或者，例如，当我的函数之一接受智能指针作为参数而不是普通指针时：

void setValue(std::shared_ptr<const Value> val);
// versus
void setValue(const Value *val);

std::unique_ptr 仅在为它提供一些非平凡的删除器时才具有内存开销。

std::shared_ptr 尽管它很小，但始终有用于引用计数器的内存开销。

std::unique_ptr 仅在构造函数期间（如果必须复制提供的删除器和/或对指针进行null初始化）和析构函数期间（销毁拥有的对象）会有时间开销。

std::shared_ptr在构造函数（用于创建引用计数器），析构函数（用于减小引用计数器并可能破坏对象）和赋值运算符（用于增大引用计数器）中具有时间开销。由于的线程安全保证std::shared_ptr，这些增量/减量是原子的，因此增加了更多开销。

请注意，它们在取消引用（获取对拥有的对象的引用）时都没有时间开销，而对于指针，此操作似乎是最常见的。

总而言之，这会有一些开销，但是除非您不断创建和销毁智能指针，否则它不会使代码变慢。

与所有代码性能一样，获取硬信息的唯一真正可靠的方法是测量和/或检查机器代码。

也就是说，简单的推理就是

• 您可能会期望在调试版本中产生一些开销，因为例如operator->必须作为函数调用执行，以便您可以进入它（这又是由于普遍缺乏将类和函数标记为非调试的支持）。

• 因为shared_ptr您可以预期初始创建时会产生一些开销，因为这涉及到控制块的动态分配，并且动态分配比C ++中的任何其他基本操作要慢得多（请make_shared在实际可行的情况下使用，以最大程度地减少开销）。

• 同样，shared_ptr在维护引用计数方面有一些最小的开销，例如，在传递shared_ptr按值时，但没有这样的开销unique_ptr。

在进行测量时，请牢记上面的第一点，以进行调试和发布。

国际C ++标准化委员会已经发布了有关性能的技术报告，但这是在2006年，在此之前，unique_ptr并将shared_ptr其添加到标准库中。尽管如此，智能指针在那时仍然是旧帽子，因此该报告也对此进行了考虑。引用相关部分：

“如果通过普通智能指针访问值比通过普通指针访问值明显慢，则编译器将无法有效地处理抽象。过去，大多数编译器都有大量的抽象惩罚，而目前的几个编译器仍然有。然而，据报道，至少有两个编译器的抽象惩罚低于1％，另外的惩罚为3％，因此消除这种开销在现有技术水平之内”

明智的猜测是，截至2014年初，当今最受欢迎的编译器已实现了“最先进的”。

我的答案与其他答案不同，我真的很想知道他们是否曾经分析过代码。

shared_ptr的创建开销很大，因为它为控制块分配了内存（保留了ref计数器和指向所有弱引用的指针列表）。因此，它还有巨大的内存开销，而且std :: shared_ptr始终是2指针元组（一个指向对象，一个指向控制块）。

如果将shared_pointer作为值参数传递给函数，则它将比普通调用至少慢10倍，并在代码段中创建大量代码以展开堆栈。如果通过引用传递它，则会获得其他间接访问，这在性能方面也可能会更差。

因此，除非该功能确实涉及所有权管理，否则您不应该这样做。否则，请使用“ shared_ptr.get（）”。它不能确保在正常的函数调用期间不会杀死您的对象。

如果您发疯并在诸如编译器中的抽象语法树之类的小对象上或在任何其他图形结构中的小节点上使用shared_ptr，您将看到性能下降和内存增加。我看到了一个解析器系统，该系统在C ++ 14投放市场之后以及程序员学会正确使用智能指针之前不久就被重写了。重写比旧代码慢了一个数量级。

这不是灵丹妙药，根据定义，原始指针也不错。糟糕的程序员是坏人，不良的设计是坏人。谨慎设计，设计时要明确所有权，并尝试主要在子系统API边界上使用shared_ptr。

如果您想了解更多信息，可以观看Nicolai M. Josuttis关于“ C ++中共享指针的实际价格”的精彩演讲，网址为https://vimeo.com/131189627
。锁等。一旦您聆听，您将永远不会谈论此功能便宜。如果只想证明幅度更慢，请跳过前48分钟，看看他运行的示例代码在任何地方使用共享指针时，运行速度都要慢180倍（与-O3编译）。

换句话说，如果我使用智能指针，我的代码会变慢吗？如果这样，速度会慢多少？

慢点？很有可能不是这样，除非您使用shared_ptrs创建一个巨大的索引，并且您没有足够的内存使计算机开始起皱，就像一个老太太被远方的无法承受的力量猛烈地摔倒在地。

使您的代码变慢的是缓慢的搜索，不必要的循环处理，庞大的数据副本以及对磁盘的大量写操作（如数百个）。

智能指针的优点都与管理有关。但是开销是否必要？这取决于您的实现。假设您要遍历3个阶段的数组，每个阶段都有1024个元素的数组。smart_ptr为此过程创建一个可能会过大，因为一旦完成迭代，您就会知道必须删除它。因此，您可以通过不使用smart_ptr... 获得更多的内存。

一次内存泄漏可能会使您的产品出现时间故障（假设您的程序每小时泄漏4兆字节，需要花数月的时间才能破坏计算机，但是，由于存在泄漏，它会崩溃，您知道的） 。

就像说“您的软件有3个月的保修期，然后致电我寻求服务”。

因此，最后实际上是...您可以应对这种风险吗？使用原始指针来处理数百个不同对象的索引确实值得失去对内存的控制。

如果答案是肯定的，则使用原始指针。

如果您甚至不想考虑它，a smart_ptr都是一个很好的，可行的，很棒的解决方案。

乍一看，仅对[]运算符而言，它比原始指针慢大约5倍，如以下代码所示，该代码使用gcc -lstdc++ -std=c++14 -O0并输出了以下结果：

malloc []:     414252610                                                 
unique []  is: 2062494135                                                
uq get []  is: 238801500                                                 
uq.get()[] is: 1505169542
new is:        241049490 

我开始学习c ++，我已经想到了这一点：您总是需要知道自己在做什么，并花更多的时间来了解其他人在c ++中所做的事情。

编辑

根据@Mohan Kumar的方法，我提供了更多详细信息。gcc版本是7.4.0 (Ubuntu 7.4.0-1ubuntu1~14.04~ppa1)，使用时获得了以上结果-O0，但是，当我使用'-O2'标志时，得到了以下结果：

malloc []:     223
unique []  is: 105586217
uq get []  is: 71129461
uq.get()[] is: 69246502
new is:        9683

然后转移到clang version 3.9.0，-O0是：

malloc []:     409765889
unique []  is: 1351714189
uq get []  is: 256090843
uq.get()[] is: 1026846852
new is:        255421307

-O2 是：

malloc []:     150
unique []  is: 124
uq get []  is: 83
uq.get()[] is: 83
new is:        54

lang的结果-O2是惊人的。

#include <memory>
#include <iostream>
#include <chrono>
#include <thread>

uint32_t n = 100000000;
void t_m(void){
    auto a  = (char*) malloc(n*sizeof(char));
    for(uint32_t i=0; i<n; i++) a[i] = 'A';
}
void t_u(void){
    auto a = std::unique_ptr<char[]>(new char[n]);
    for(uint32_t i=0; i<n; i++) a[i] = 'A';
}

void t_u2(void){
    auto a = std::unique_ptr<char[]>(new char[n]);
    auto tmp = a.get();
    for(uint32_t i=0; i<n; i++) tmp[i] = 'A';
}
void t_u3(void){
    auto a = std::unique_ptr<char[]>(new char[n]);
    for(uint32_t i=0; i<n; i++) a.get()[i] = 'A';
}
void t_new(void){
    auto a = new char[n];
    for(uint32_t i=0; i<n; i++) a[i] = 'A';
}

int main(){
    auto start = std::chrono::high_resolution_clock::now();
    t_m();
    auto end1 = std::chrono::high_resolution_clock::now();
    t_u();
    auto end2 = std::chrono::high_resolution_clock::now();
    t_u2();
    auto end3 = std::chrono::high_resolution_clock::now();
    t_u3();
    auto end4 = std::chrono::high_resolution_clock::now();
    t_new();
    auto end5 = std::chrono::high_resolution_clock::now();
    std::cout << "malloc []:     " <<  (end1 - start).count() << std::endl;
    std::cout << "unique []  is: " << (end2 - end1).count() << std::endl;
    std::cout << "uq get []  is: " << (end3 - end2).count() << std::endl;
    std::cout << "uq.get()[] is: " << (end4 - end3).count() << std::endl;
    std::cout << "new is:        " << (end5 - end4).count() << std::endl;
}