make_share

最新推荐文章于 2023-12-01 15:56:37 发布
最新推荐文章于 2023-12-01 15:56:37 发布
阅读量1.1k 收藏
点赞数
原文链接：https://blog.csdn.net/CPriLuke/article/details/79462791?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522159094106419195239860328%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=159094106419195239860328&biz_id=0
版权
本章所有内容均从C++ Primer摘录总结
1.为什么使用make_shared？

    make_shared函数的主要功能是在动态内存中分配一个对象并初始化它，返回指向此对象的shared_ptr;由于是通过shared_ptr管理内存，因此一种安全分配和使用动态内存的方法。

     如下为make_shared的使用:


   
   
  1. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       //p1指向一个值为"9999999999"的string
      
      
    
     
     
  2. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       shared_ptr<
       
       string> p1 = make_shared<
       
       string>(
       
       10, 
       
       '9');  
      
      
    
     
     
  3. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  4. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       shared_ptr<
       
       string> p2 = make_shared<
       
       string>(
       
       "hello");  
      
      
    
     
     
  5. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  6. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       shared_ptr<
       
       string> p3 = make_shared<
       
       string>();
从上述例子我们可以看出以下几点：
  1）make_shared是一个模板函数；
  2）make_shared模板的使用需要以“显示模板实参”的方式使用，如上题所示make_shared<string>(10, 9),如果不传递显示 模板实参string类型，make_shared无法从(10, '9')两个模板参数中推断出其创建对象类型。
  3）make_shared在传递参数格式是可变的，参数传递为生成类型的构造函数参数，因此在创建shared_ptr<T>对象的过程中调用了类型T的某一个构造函数。

2.make_shared模板实现
  如下为make_shared的库函数实现版本：


   
   
  1. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       template<
       
       typename _Tp, 
       
       typename... _Args>
      
      
    
     
     
  2. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       inline 
       
       shared_ptr<_Tp>
      
      
    
     
     
  3. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       make_shared(_Args&&... __args)
      
      
    
     
     
  4. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       {
      
      
    
     
     
  5. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       typedef 
       
       typename 
       
       std::remove_const<_Tp>::type _Tp_nc;
      
      
    
     
     
  6. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       return 
       
       std::allocate_shared<_Tp>(
       
       std::allocator<_Tp_nc>(),
      
      
    
     
     
  7. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    				   
       
       std::forward<_Args>(__args)...);
      
      
    
     
     
  8. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       }
      
      
    
     
     
  9. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  10. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       template<
       
       typename _Tp, 
       
       typename _Alloc, 
       
       typename... _Args>
      
      
    
     
     
  11. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       inline 
       
       shared_ptr<_Tp>
      
      
    
     
     
  12. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       allocate_shared(
       
       const _Alloc& __a, _Args&&... __args)
      
      
    
     
     
  13. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       {
      
      
    
     
     
  14. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       return 
       
       shared_ptr<_Tp>(_Sp_make_shared_tag(), __a,
      
      
    
     
     
  15. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    			 
       
       std::forward<_Args>(__args)...);
      
      
    
     
     
  16. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       }
我们依次分析上述的关键代码 

   
   
  1. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       //关键行1
      
      
    
     
     
  2. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       template<
       
       typename _Tp, 
       
       typename... _Args>
      
      
    
     
     
  3. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       inline 
       
       shared_ptr<_Tp> make_shared(_Args&&... __args)  
      
      
    
     
     
  4. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
      
      
    
     
     
  5. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       //关键行2
      
      
    
     
     
  6. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       std::forward<_Args>(__args)...
      
      
    
     
     
  7. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  8. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       //关键行3
      
      
    
     
     
  9. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       return 
       
       shared_ptr<_Tp>(_Sp_make_shared_tag(), __a,
      
      
    
     
     
  10. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    			 
       
       std::forward<_Args>(__args)...);
从上述关键代码可以看出： make_shared是组合使用可变参数模板与forward（转发）机制实现将实参保持不变地传递给其他函数。如最开始的string例子 。
1） 使用可变参数：是因为string有多个构造函数，且参数各不相同；

2）Args参数为右值引用(Args&&)和std::forward：是为了保持实参中类型信息的传递。这样当传递一个右值string&& 对象给make_shared时，就可以使用string的移动构造函数进行初始化。注意，两者必须结合使 用，缺一不可；

此外std::forward<_Args>(__args)...是采用 包扩展形式调用的，原理如下： 

   
   
  1. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       shared_ptr<
       
       string> p1 = make_shared<
       
       string>(
       
       10, 
       
       '9'); 
      
      
    
     
     
  2. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  3. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       //扩展如下,对两个参数分别调用std::forward
      
      
    
     
     
  4. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       return 
       
       shared_ptr<
       
       string>(_Sp_make_shared_tag(), _a ,
      
      
    
     
     
  5. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    			  
       
       std::forward<
       
       int>(
       
       10),  
      
      
    
     
     
  6. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    			  
       
       std::forward<
       
       char>(c));
补充说明：
①模板参数为右值引用，采用引用折叠原理： 

   
   
  1. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
       
       1）参数为左值时，实参类型为普通的左值引用； T& &, T&& &,T& && =>T&
      
      
    
     
     
  2. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
       
       2）参数为右值时，实参类型为右值: T&& && => T&&
② std::forward:是一个模板，通过显示模板实参来调用，调用后forward返回显示实参类型的右值引用。即，forward<T>的返回类型为T&&，在根据上述引用折叠原理即可保存参数是左值还是右值类型；比如： 

   
   
  1. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       int i = 
       
       0;
      
      
    
     
     
  2. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       std::forward<
       
       int>(i), i将以
       
       int&传递
      
      
    
     
     
  3. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       std::forward<
       
       int>(
       
       42), 
       
       42将以
       
       int&&传递
std::forward实现代码： 

   
   
  1. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       /**
      
      
    
     
     
  2. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       *  @brief  Forward an lvalue.
      
      
    
     
     
  3. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       *  @return The parameter cast to the specified type.
      
      
    
     
     
  4. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       *
      
      
    
     
     
  5. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       *  This function is used to implement "perfect forwarding".
      
      
    
     
     
  6. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       */
      
      
    
     
     
  7. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       template<
       
       typename _Tp>
      
      
    
     
     
  8. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       constexpr _
       
       Tp&&
      
      
    
     
     
  9. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       forward
       
       (typename std::remove_reference<_Tp>::type& __t) 
       
       noexcept
      
      
    
     
     
  10. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       { 
       
       return 
       
       static_cast<_Tp&&>(
       
       __t); }
      
      
    
     
     
  11. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  12. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       /**
      
      
    
     
     
  13. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       *  @brief  Forward an rvalue.
      
      
    
     
     
  14. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       *  @return The parameter cast to the specified type.
      
      
    
     
     
  15. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       *
      
      
    
     
     
  16. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       *  This function is used to implement "perfect forwarding".
      
      
    
     
     
  17. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       */
      
      
    
     
     
  18. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       template<
       
       typename _Tp>
      
      
    
     
     
  19. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       constexpr _
       
       Tp&&
      
      
    
     
     
  20. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       forward
       
       (typename std::remove_reference<_Tp>::type&& __t) 
       
       noexcept
      
      
    
     
     
  21. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       {
      
      
    
     
     
  22. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       static_assert(!
       
       std::is_lvalue_reference<_Tp>::value, 
       
       "template argument"
      
      
    
     
     
  23. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    		
       
       " substituting _Tp is an lvalue reference type");
      
      
    
     
     
  24. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       return 
       
       static_cast<_Tp&&>(
       
       __t);
      
      
    
     
     
  25. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       }






Junoxiang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
test_share_ptr
03-07
在本项目"test_share_ptr"中，我们可以推断其主要关注的是C++中的智能指针`std::shared_ptr`。`std::shared_ptr`是C++标准库中的一个智能指针类型，属于弱所有者（weak ownership）的智能指针，用于管理动态分配的...
share_process_3
03-25
$ make create-project # Install the latest Laravel project $ make install-recommend-packages # Not required 阅读此 。 尖端 阅读此 。 容器结构 ├── app ├── web └── db 应用容器 基本图片 ：8.0-...
C++——智能指针——auto_ptr、shared_ptr、unique_ptr
勿在浮沙築高台
04-29 832
1.4、智能指针 智能指针是行为类似于指针的类对象。 C++11 中提供了三种智能指针，使用这些智能指针时需要引用头文件 ： ·shared_ptr; ·unique_ptr; ·auto_ptr; 这三个智能指针模板都定义了类似指针的对象，可意义将new获得（直接或者间接）的地址赋给这种对象。当智能指针过期时，其析构函数将使delete来释放内存。智能指针是存储指向动态分配（堆）对象指针的类，用于生存期的控制，能够确保在离开指针所在作用域时，自动地销毁动态分配的对象，防止内存泄露。 ·weak_ptr;
C++ make_shared使用
duringsummer的博客
01-16 2万+
C++内存分四大块 全局 主函数运行前使用，初始化 静态 变量第一次使用前，初始化 以上两块内存都会在程序结束后自动释放 堆区 由程序员管理，C++管理方法有new delete等关键字 栈区 由编译器管理，存放程序的局部变量和参数 因此我们需要关注堆区的内存管理。内存管理经常会碰到忘记释放造成的内存泄露。 在C++中引入了智能指针，有shared_ptr，unique_ptr和weak_ptr。 shared_ptr 工作中shared_ptr用得比较多，今天做个总结 使用智能指针，需
make_shared理解
热门推荐
CPriLuke的博客
03-06 7万+
本章所有内容均从C++ Primer摘录总结1.为什么使用make_shared？    make_shared函数的主要功能是在动态内存中分配一个对象并初始化它，返回指向此对象的shared_ptr;由于是通过shared_ptr管理内存，因此一种安全分配和使用动态内存的方法。     如下为make_shared的使用://p1指向一个值为"9999999999"的string shared_...
make_shared()
最新发布
weixin_56492465的博客
12-01 3053
是C++11引入的一种智能指针，它用于创建一个指向动态分配的对象的。函数确保在堆上分配内存，以容纳对象本身以及。
make_shared
weixin_45596153的博客
05-24 1091
1.为什么使用make_shared？ make_shared函数的主要功能是在动态内存中分配一个对象并初始化它，返回指向此对象的shared_ptr;由于是通过shared_ptr管理内存，因此一种安全分配和使用动态内存的方法。 如下为make_shared的使用: //p1指向一个值为"9999999999"的string shared_ptr p1 = make_shared(10, ‘9’); shared_ptr p2 = make_shared(“hello”); shared_ptr p3
share-make-public:通过文档库中的共享操作在外部共享 Alfresco 中的内容
06-21
要安装它，只需将 make-public-1.0.jar 文件放入 Alfresco 安装中的 tomcat/shared/lib 文件夹，将 share-make-public-1.0.amp 复制到 amps_share，运行 bin/apply_amps.sh 脚本并重启应用服务器。从源头构建提供了...
make-3.8.1
08-24
2. **share**：这个文件夹可能包含了make工具的一些共享资源，如配置文件、模板或语言特定的规则集。这些资源可以被多个项目共用，或者提供默认的构建行为。 3. **doc**：文档文件夹，通常包含关于make工具的使用...
make_shared剖析
bureau123的博客
11-13 5893
引言 关于make_shared，大家都知道可以用它来初始化shared_ptr: shared_ptr<string> sp = make_shared<string>(); 那为何要使用它呢，我们都知道，也可以直接通过shared_ptr的构造函数来生成shared_ptr对象： shared_ptr<string> sp1(new string()); 这两者有何区别呢？首先来看看make_shared源码： make_shared源码 template<
C++ make_shared
LIJIWEI0611的博客
12-05 2782
在使用std::shared_ptr时，有两种不同的构造方式，如： #include <iostream> #include <memory> int main(){ std::shared_ptr<int> sp1(new int(10)); std::shared_ptr<int> sp2 = std::make_shared<int>(10); return 0; } C++11 中引入...
c++ make_shared的使用及注意事项
开挂的熊猫
06-14 1万+
在 C++11 中，可以使用 make_shared 函数来创建共享指针，它是一个模板函数，可以接受任何类型的参数，并返回一个指向该类型对象的共享指针。它可以将控制块和对象一起分配在堆上，从而避免了两次内存分配，并减少了引用计数的内存开销，相对于直接使用。其中，T 表示指向的类型，Args 是类型 T 的构造函数所需的参数列表，在调用时需要传递给构造函数。是 C++11 提供的一种高效、安全的智能指针工厂函数，使用起来方便且实用。来创建一个较大的对象，可能会增加堆分配的消耗。在上面的代码中，我们使用。
关于C++11中的make_shared
iaibeyond的专栏
06-28 2812
我在读《C++Primer(第五版)》智能指针的章节时，看到书中有如下内容 可见作者非常推荐使用make_shared来生成shared_ptr，那么我的疑问就来了，为什么make_shared是更好的方法？经过查阅相关资料和阅读源码，找出原因：make_shared只申请了一次内存，而普通的先new一个raw_ptr，再调用shared_ptr(raw_ptr)是进行了两次内存分配，所以一次分配要比两次分配效率高。 为了下文叙述方便，我们称呼下图中使用make_shared的构造方法为1，先new
make_shared知识点
qq_42120843的博客
05-12 278
数量)有一个不为0，整个内存资源（托管资源和引用计数）就都不能释放；的内存空间分配或对象构造失败，此时就会造成内存泄漏问题。在uses为0时可以释放托管的内存资源。sp1所开辟的动态内存分为如下两部分。
C++ 学习系列 -- 智能指针 make_shared 与 make_unique
qq_33775774的博客
09-03 1604
c++ 11 中 引入了智能指针 shared_ptr，以及一个模板函数 make_shared 来生成一个制定类型的 shared_ptr。
share_ptr和make_share 的使用
weixin_38844714的博客
08-11 978
shared_ptr和make_share 的使用 智能指针的使用可以让我们省去很多自动释放的功夫，保持内存的干净整洁。 智能智能所管理的内存是如何自动释放的呢？我们写个简单的例子来测试一下。 #include <iostream> using namespace std; class test { public: test() { cout << "构造函数" << endl; } > 这里是引用 ~test() { cout <<
C++ Boost库：工厂函数 make_shared
超级大洋葱的博客
05-04 4963
文章目录1. 如何消除new2. 工厂函数3. 示例代码 1. 如何消除new shared_ptr消除了显式的 delete调用，很大程度上避免了程序员忘记 delete而导致的内存泄漏。但 shared_ptr的构造依然需要ηew，这导致了代码中的某种不对称性，它应该使用工厂模式来解决。 2. 工厂函数 Boost库提供了一个自由工厂函数 make shared<T>()，来消除显式的new调用，声明如下： template<class T,class... Args> shar
C++make_shared()函数模板（创建一个shared_ptr对象并在堆上初始化所指向的对象）
Dontla的博客
06-07 775
make_shared函数模板还会将所创建的对象和引用计数对象放在同一块内存中，这样可以减少内存分配的次数，提高程序的效率。在这个例子中，我们使用make_shared函数模板创建了一个MyClass对象，并将其赋值给一个shared_ptr对象ptr。make_shared函数模板的返回值是一个shared_ptr对象，它指向所创建的对象。在C++中，make_shared是一个函数模板，用于创建一个shared_ptr对象并初始化它所指向的对象。
pcl1.8 make_shared
08-18
在使用pcl1.8代码的CMakeLists.txt中，您可以添加以下内容来指定PCL的安装路径：set(PCL_DIR "/usr/local/pcl18/share/pcl-1.8")。这将帮助CMake在构建过程中找到正确的PCL库文件。 在安装pcl1.8时，可能会遇到各种问题。在Ubuntu16.04系统下安装pcl1.8时，可能会出现缺少libpclcommon.so的错误。为了解决这个问题，您可以按照以下步骤进行操作： 1. 首先，确保您已经安装了PCL库。您可以按照网上的教程进行安装，建议使用pcl1.8版本，因为它被认为是比较稳定和好用的版本。这将帮助您在需要兼容pcl1.10时找到正确的PCL库文件。 关于您提到的make_shared函数的问题，可以提供更多上下文信息吗？make_shared函数是C++中的一个模板函数，用于创建共享指针，它不直接与PCL相关。如果您有关于make_shared函数的具体问题，请提供更多详细信息，我将尽力为您解答。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *3* [Ubuntu20.04 编译 pcl1.8可能出现的问题](https://blog.csdn.net/dui845819593/article/details/128486864)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* [ubuntu20安装pcl1.8](https://blog.csdn.net/MintLab/article/details/128722334)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值