精华内容
下载资源
问答
  • make_shared和make_pair

    2021-07-20 08:35:34
    make_shared和make_pair

    make_shared和make_pair系列函数

    make_shared

    shared_ptr很好地消除了显式的delete调用,但这还不够,因为shared_ptr的构造还需要new调用,这导致了代码中的某种不对称性。虽然shared_ptr很好地包装了new表达式,但过多的显式new操作符也是个问题,用make_shared()来消除显式的new调用。

    make_shared()函数可以接受最多10个参数,然后把它们传递给类型T的构造函数,创建一个shared_ptr的对 象并返回。make_shared()函数要比直接创建shared_ptr对象的方式快且高效,因为它内部仅分配一次内存,消除了shared_ptr 构造时的开销。

      /**
       *  @brief  Create an object that is owned by a shared_ptr.
       *  @param  __a     An allocator.
       *  @param  __args  Arguments for the @a _Tp object's constructor.
       *  @return A shared_ptr that owns the newly created object.
       *  @throw  An exception thrown from @a _Alloc::allocate or from the
       *          constructor of @a _Tp.
       *
       *  A copy of @a __a will be used to allocate memory for the shared_ptr
       *  and the new object.
       */
      template<typename _Tp, typename _Alloc, typename... _Args>
        inline shared_ptr<_Tp>
        allocate_shared(const _Alloc& __a, _Args&&... __args)
        {
          return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{__a},
    			     std::forward<_Args>(__args)...);
        }
    
      /**
       *  @brief  Create an object that is owned by a shared_ptr.
       *  @param  __args  Arguments for the @a _Tp object's constructor.
       *  @return A shared_ptr that owns the newly created object.
       *  @throw  std::bad_alloc, or an exception thrown from the
       *          constructor of @a _Tp.
       */
      template<typename _Tp, typename... _Args>
        inline shared_ptr<_Tp>
        make_shared(_Args&&... __args)
        {
          typedef typename std::remove_cv<_Tp>::type _Tp_nc;
          return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
    				       std::forward<_Args>(__args)...);
        }
    

    通过源码可以看出,make_shared采用的是placement new 而非operator new。

    make_pair

      /**
       *  @brief A convenience wrapper for creating a pair from two objects.
       *  @param  __x  The first object.
       *  @param  __y  The second object.
       *  @return   A newly-constructed pair<> object of the appropriate type.
       *
       *  The standard requires that the objects be passed by reference-to-const,
       *  but LWG issue #181 says they should be passed by const value.  We follow
       *  the LWG by default.
       */
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 181.  make_pair() unintended behavior
    #if __cplusplus >= 201103L
      // NB: DR 706.
      template<typename _T1, typename _T2>
        constexpr pair<typename __decay_and_strip<_T1>::__type,
                       typename __decay_and_strip<_T2>::__type>
        make_pair(_T1&& __x, _T2&& __y)
        {
          typedef typename __decay_and_strip<_T1>::__type __ds_type1;
          typedef typename __decay_and_strip<_T2>::__type __ds_type2;
          typedef pair<__ds_type1, __ds_type2> 	      __pair_type;
          return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
        }
    #else
      template<typename _T1, typename _T2>
        inline pair<_T1, _T2>
        make_pair(_T1 __x, _T2 __y)
        { return pair<_T1, _T2>(__x, __y); }
    #endif
    

    从make_pair实现上看,效率应该和std::pair对象构造差不多。make_pair内部调用pair构造函数,把模板参数通过std::forward转发。

    reference:

    [1]. placement new与operator new

    展开全文
  • C++11 make_pairpair

    2021-09-01 10:10:35
    先看这段代码: ... auto error = std::make_pair<int, std::string>(0, str); // error auto success = std::pair<int, std::string>(0, str); return 0; } 在`make_pair`时会报错: err

    先看这段代码:

    #include <iostream>
    
    int main() {
      std::string str = "hello world";
      auto error = std::make_pair<int, std::string>(0, str);  // error
      auto success = std::pair<int, std::string>(0, str);
      return 0;
    }

    在`make_pair`时会报错:

    error: no matching function for call to ‘make_pair<int, std::__cxx11::string>(int, std::__cxx11::string&)’

    让我们看看`make_pair`在c++11中的实现:

      /**
       *  @brief A convenience wrapper for creating a pair from two objects.
       *  @param  __x  The first object.
       *  @param  __y  The second object.
       *  @return   A newly-constructed pair<> object of the appropriate type.
       *
       *  The standard requires that the objects be passed by reference-to-const,
       *  but LWG issue #181 says they should be passed by const value.  We follow
       *  the LWG by default.
       */
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 181.  make_pair() unintended behavior
    #if __cplusplus >= 201103L
      // NB: DR 706.
      template<typename _T1, typename _T2>
        constexpr pair<typename __decay_and_strip<_T1>::__type,
                       typename __decay_and_strip<_T2>::__type>
        make_pair(_T1&& __x, _T2&& __y)
        {
          typedef typename __decay_and_strip<_T1>::__type __ds_type1;
          typedef typename __decay_and_strip<_T2>::__type __ds_type2;
          typedef pair<__ds_type1, __ds_type2> 	      __pair_type;
          return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
        }
    #else
      template<typename _T1, typename _T2>
        inline pair<_T1, _T2>
        make_pair(_T1 __x, _T2 __y)
        { return pair<_T1, _T2>(__x, __y); }
    #endif

    可以看到`make_pair`在不同版本有两种实现,最新版本中使用的是 `make_pair(_T1&& __x, _T2&& __y)`,`_T2&&`只能采用Rvalues,而`std::string str`中的`str`为左值,所以会error。

    可参考`#else`中的代码,在原本使用到`std::make_pair`的地方,换成`std::pair`即可。

    展开全文
  • C++pairmake_pair

    2020-08-14 17:47:10
    int main(void) { PAIR_IF pair1=make_pair(18,3.14f); cout << pair1.first << " " << pair1.second ; pair1.first=10; pair1.second=1.0f; cout << pair1.first << " " << pair1.second ; } 总结来说: ...

    在做leetcode102 分组输出二叉树层序遍历结果时,想在队列中存放<Treenode*,int>来记录该节点所在层次。

    /**
     * Definition for a binary tree node.
     * struct TreeNode {
     *     int val;
     *     TreeNode *left;
     *     TreeNode *right;
     *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
     * };
     */
    class Solution {
    public:
        vector<vector<int>> levelOrder(TreeNode* root) {
            if(root == NULL) return {};
            queue<pair<int,TreeNode*>> store;
            int i=0;
            vector<vector<int>> res;
            vector<int> del;
            store.push(make_pair(i,root));
            while(!store.empty()){
                TreeNode* temp=store.front().second;
                if(store.front().first == i)
                    del.push_back(temp->val);
                else{
                    res.push_back(del);
                    del.clear();
                    del.push_back(temp->val);
                    i++;
                }
                if(temp->left != NULL) store.push(make_pair(i+1,temp->left));
                if(temp->right != NULL) store.push(make_pair(i+1,temp->right));   
                store.pop();         
            }
            res.push_back(del);
            return res;  
        }
    };
    

    一开始用make_pair(TreeNode*,int)总是报错,改成<TreeNode*,int>也不可以,去查了下两个的用法才知道;
    Pairs
    C++标准程序库中凡是“必须返回两个值”的函数, 也都会利用pair对象
    class
    pair可以将两个值视为一个单元。容器类别map和multimap就是使用pairs来管理其健值/实值(key/value)的成对元素。
    pair被定义为struct,因此可直接存取pair中的个别值.
    两个pairs互相比较时, 第一个元素正具有较高的优先级.
    例:
    namespace std{
    template <class T1, class T2>
    bool operator< (const pair<T1, T2>&x, const pair<T1, T2>&y){
    return x.first<y.first || ((y.first<x.first)&&x.second<y.second);
    }
    }

    make_pair():
    无需写出型别, 就可以生成一个pair对象
    例:
    std::make_pair(42, ‘@’);
    而不必费力写成:
    std::pair<int, char>(42, ‘@’)

    当有必要对一个接受pair参数的函数传递两个值时, make_pair()尤其显得方便,
    void f(std::pair<int, const char*>);

    void foo{
    f(std::make_pair(42, ‘@’)); //pass two values as pair
    }

    1 pair的应用

    pair是将2个数据组合成一个数据,当需要这样的需求时就可以使用pair,如stl中的map就是将key和value放在一起来保存。另一个应用是,当一个函数需要返回2个数据的时候,可以选择pair。 pair的实现是一个结构体,主要的两个成员变量是first second 因为是使用struct不是class,所以可以直接使用pair的成员变量。

    2 make_pair函数

    template pair make_pair(T1 a, T2 b) { return pair(a, b); }

    很明显,我们可以使用pair的构造函数也可以使用make_pair来生成我们需要的pair。 一般make_pair都使用在需要pair做参数的位置,可以直接调用make_pair生成pair对象很方便,代码也很清晰。 另一个使用的方面就是pair可以接受隐式的类型转换,这样可以获得更高的灵活度。灵活度也带来了一些问题如:

    std::pair<int, float>(1, 1.1);

    std::make_pair(1, 1.1);

    是不同的,第一个就是float,而第2个会自己匹配成double。

    make_pair (STL Samples)
    Illustrates how to use the make_pair Standard Template Library (STL) function in Visual C++.

     #include <utility> 
     #include <iostream>  
     using namespace std;  
     /* STL pair data type containing int and float */  
     typedef struct pair<int,float> PAIR_IF;  
     int main(void) 
     {   
    	 PAIR_IF pair1=make_pair(18,3.14f);    
    	 cout << pair1.first << "  " << pair1.second << endl;   
    	 pair1.first=10;   pair1.second=1.0f;   
    	 cout << pair1.first << "  " << pair1.second << endl; 
     }
    

    总结来说:

    C++ map.insert: pair和make_pair区别
    *********************************
    map<uint32_t, string> temp;
    1. temp[1] = “template”;
    2.temp.insert(pair<uint32_t, string>(1, “template”));
    3.temp.insert(make_pair(1, “template”));
    pair实质上是一个结构体,其主要的两个成员变量是first和second,所以可以调用构造函数来返回一个实例,或者不调用构造函数,这样就变成了一种类型
    因此有了     
    for(const auto& i : temp) {
    cout << "first = " << i.first; // i 也就是一个pair;
    cout << "second = " << i.second;
    }
    pair需要指定构造的类型,make_pair可以隐式转换,即将1 转成uint32_t, template转成string类型

    展开全文
  • pair std::pair主要的作用是将两个数据组合成一个数据,两个数据可以是同一类型或者不同类型。 C++标准程序库中凡是“必须返回两个值”的函数, 也都会利用pair对象。 class pair可以将两个值视为一个单元。容器...

    pair

    std::pair主要的作用是将两个数据组合成一个数据,两个数据可以是同一类型或者不同类型。
    C++标准程序库中凡是“必须返回两个值”的函数, 也都会利用pair对象。
    class pair可以将两个值视为一个单元。容器类别map和multimap就是使用pairs来管理其健值/实值(key/value)的成对元素。

    1.构造函数

    1. pair<T1, T2> p1; //创建一个空的pair对象(使用默认构造),它的两个元素分别是T1和T2类型,采用值初始化。

    2. pair<T1, T2> p1(v1, v2);//创建一个pair对象,它的两个元素分别是T1和T2类型,其中first成员初始化为v1,second成员初始化为v2。

    如: pair<string, int> name_age("Tom", 18);    //需要声明类型

    2.pair对象的操作

    访问两个元素操作可以通过first和sencond访问:

    pair<int ,double> p1;

    p1.first = 1;

    p1.second = 2.5;

    make_pair函数

    template pair make_pair(T1 a, T2 b) { return pair(a, b); }

    特点就是无需写出型别, 就可以生成一个pair对象。所以可以使用pair的构造函数也可以使用make_pair来生成我们需要的pair。

    std::make_pair(42, '@');
    而不必费力写成:
    std::pair<int, char>(42, '@')

    如: pair<int, double> p1;

             p1 = make_pair(1, 1.2);

    延伸:在c++ 17 ,不需要特殊指定,直接可以推导出类型

    pair p(1, 2.2); // c++17 自动推导

    tuple

    tuple是C++11新标准里的类型。它是一个类似pair类型的模板。pair类型是每个成员变量各自可以是任意类型,但是只能有俩个成员,而tuple与pair不同的是它可以有任意数量的成员。但是每个确定的tuple类型的成员数目是固定的。

    和pair一样,可以通过构造函数和make_tuple进行定义初始化。

    tuple<int,int,float> tp(1,2,3.1);

    std::tuple<std::string, std::string, int> t2 = std::make_tuple("Caroline", "Wendy", 1992);

    C++17就不需要特殊指定,直接可以推导出类型,代码如下:std::tuple eee(64, 128.0, "Caroline");

    1. 访问元素使用"get<>()"方法, 注意get里面的位置信息, 必须是常量表达式(const expression);

    如: cout<<"第一个元素为:"<<get<0>(tp)<<endl;

    2.std::tuple_element<0, decltype(t)>::type获取元素类型;

    如 std::tuple_element<1, decltype(t)>::type cnt = std::get<1>(t);

    3.通过"std::tuple_size<decltype(t)>::value"获取元素数量

    如:size_t num = std::tuple_size<decltype(t)>::value;

    展开全文
  • C++ pairmake_pair的用法

    千次阅读 2019-10-16 12:21:27
    pair 的用法 std::pair主要的作用是将两个数据组合成一个数据,两个数据可以是同一类型或者不同类型。 C++标准程序库中凡是“必须返回两个值”的函数, 也都会利用pair对象。 class pair可以将两个值视为一个单元...
  • C++ pair&make_pair

    2021-05-28 14:20:07
    pair pair是一种模板类型,其中包含两个数据值,两个数据的类型可以不同。 pair <int,string>a; pair a("James", "Joy"); 由于pair类型的使用比较繁琐,因为如果要定义多个形同的pair类型的时候,可以时候...
  • pair 的用法 std::pair主要的作用是将两个数据组合成一个数据,两个数据可以是同一类型或者不同类型。 C++标准程序库中凡是“必须返回两个值”的函数, 也都会利用pair对象。 class pair可以将两个值视为一个单元。...
  • make_pair函数

    2020-11-20 19:13:06
    std::pair主要的作用是将两个数据组合成一个数据,两个数据可以是同一类型或者...初始化一个pair可以使用构造函数,也可以使用std::make_pair函数,make_pair函数的定义如下: template pair make_pair(T1 a, T2 b)
  • make_pair用法

    千次阅读 2020-08-05 11:38:13
    make_pair用来拼接2个参数,合并为1个,不能再多了 可以用来接收两个返回值,如果有多个返回值,可以直接拼接到struct里面返回。 #include <iostream> // for make_pair #include <memory> // for ...
  • 首先make_pair Pairs C++标准程序库中凡是“必须返回两个值”的函数, 也都会利用pair对象 class pair可以将两个值视为一个单元。容器类别map和multimap就是使用pairs来管理其健值/实值(key/va lue)的成对元素。 ...
  • C++中 pairmake_pair 的用法

    千次阅读 2019-04-25 11:20:42
    参见大佬博客:...另外我再补充一点: pair是二元组类模版,make_pair实际上是创建二元组的函数模版,在C++中,函数模版可省略参数,make_pair也是利用这一特性。 ...
  • C++ pairmake_pair

    2019-02-26 18:21:33
    1、 std::pair主要的作用是将两个数据组合成一个数据,两个数据可以是同一类型或者不同类型。 例如std::pair&lt;int,float&gt; 或者 std::pair&lt;double,double&gt;等。 2、pair实质上是一个...
  • C++ make_pair和map用法

    2020-10-11 17:34:16
    make_pair不需要指定参数类型,如pair<int,int>; 见代码: #include<iostream> #include<map> #include<vector> #include<ctime> #include<string> #include<sstream> ...
  • C++11make_pair问题

    千次阅读 2018-10-26 14:17:38
    在C++11中使用make_pair一定不要显式给出类型参数,不然会报错 #include <utility> using namespace std; int main() { int n=0,m=0; auto x=make_pair...
  • 关于C++ pairmake_pair的用法

    万次阅读 多人点赞 2018-08-10 23:57:53
    pair 的用法 std::pair主要的作用是将两个数据组合成一个数据,两个数据可以是同一类型或者不同类型。 C++标准程序库中凡是“必须返回两个值”的函数, 也都会利用pair对象。 class pair可以将两个值视为一个单元...
  • 文章目录概述参考链接 概述 pair 对组将2个数据组合,如 stl 中的 map 就是将 key 和 value 放在一起来保存。...pair是二元组类模版,make_pair实际上是创建二元组的函数模版,在C++中,函数模版可省略参数,ma
  • map class Solution { public: ... make_pair的用法 无需写出型别, 就可以生成一个pair对象 例: std::make_pair(42, ‘@’); 而不必费力写成: std::pair(42, ‘@’) 参考链接: 关于C++ pairmake_pair的用法
  • make_pair 简单使用

    千次阅读 2019-05-16 10:17:54
    code : #include <iostream> using namespace std;... auto pair_1 =make_pair(1,"2"); cout << pair_1.first << endl; cout << pair_1.second << endl; auto pair_...
  • C++基础——C++ make_pair用法

    千次阅读 2018-10-10 17:53:15
    std::pair主要的作用是将两个数据组合成一个数据,两个数据可以是同一类型或者不同类型。 例如std::pair&lt;int,float&gt; 或者 std::pair&lt;double,double&gt;等。 pair实质上是一个结构体,其...
  • 一般make_pair都使用在需要pair做参数的位置,可以直接调用make_pair生成pair对象很方便,代码也很清晰。 另一个使用的方面就是pair可以接受隐式的类型转换,这样可以获得更高的灵活度。灵活度也带来了一些问题如:...
  • map容器插入数据的4种方法 ...第一种:用insert函数插入pair数据:在VC下请加入这条语句,屏蔽4786警告#pragmawarning(disable:4786)) map&lt;int,string&gt;mapStudent; mapStudent.insert(pair...
  • C++学习(五)pairmake_pair

    千次阅读 2019-05-27 06:51:09
    pair 的用法 std::pair主要的作用是将两个数据组合成一个数据,两个数据可以是同一类型或者不同类型。 C++标准程序库中凡是“必须返回两个值”的函数, 也都会利用pair对象。 class pair可以将两个值视为一个单元。...
  • pairmake_pair的主要作用都是将两个数据组合成一个数据,两个数据可以是同一个类型或者不同类型。 二、区别 pair实际上是一个结构体,其主要的两个成员变量是first和second,这两个变量可以直接使用。 伪代码...
  • C++ make_pair()用法

    千次阅读 2019-03-08 11:46:17
    #include &... pair &lt;string,double&gt; p1 ("zhang",8.8); pair &lt;string,double&gt; p2; pair &lt;string,double&gt; p3; p2.first = "wang"; ...
  • std::pair主要的作用是将两个数据组合成一个数据,两个数据可以是同一类型或者不同类型。例如std::pair&lt;int,float&...初始化一个pair可以使用构造函数,也可以使用std::make_pair函数,...
  • 这样做非常方便我们的开发,减少了代码量 ... 1 bool strict_weak_ordering(const std::pair<int, std::string> a, const std::pair<int, std::string> b) 2 { 3 return a.first < b.first; ...
  • C++中的pair,make_pair学习

    千次阅读 2017-06-20 09:18:34
    std::pair主要的作用是将两个数据组合成一个数据,两个数据可以是同一类型或者不同类型。...初始化一个pair可以使用构造函数,也可以使用std::make_pair函数,make_pair函数的定义如下: template pair make_pa
  • std::pair主要的作用是将两个数据组合成一个数据,两个数据可以是同一类型或者不同类型。例如std::pair<int,float> 或者 std::pair<...初始化一个pair可以使用构造函数,也可以使用std::make_pa...
  • 注意:pair是类模板,所以需要模板参数列表,而make_pair是函数,则不需要。 三、map的遍历  用迭代器遍历:则根据key的有序遍历 用key值遍历:是在已知key的基础上 map,int> m; int value = 1;...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 149,972
精华内容 59,988
关键字:

make_pair