วัตถุประสงค์ของ std :: make_pair เทียบกับนวกรรมิกของ std :: pair คืออะไร?

มีจุดประสงค์std::make_pairอะไร?

ทำไมไม่ทำอย่างนั้นstd::pair<int, char>(0, 'a')?

มีความแตกต่างระหว่างสองวิธีหรือไม่?

ความแตกต่างคือเมื่อstd::pairคุณจำเป็นต้องระบุประเภทขององค์ประกอบทั้งสองในขณะที่std::make_pairจะสร้างคู่ที่มีประเภทขององค์ประกอบที่ส่งผ่านไปโดยที่คุณไม่จำเป็นต้องบอก นั่นคือสิ่งที่ฉันสามารถรวบรวมได้จากเอกสารต่าง ๆ อย่างไรก็ตาม

ดูตัวอย่างนี้จากhttp://www.cplusplus.com/reference/std/utility/make_pair/

pair <int,int> one;
pair <int,int> two;

one = make_pair (10,20);
two = make_pair (10.5,'A'); // ok: implicit conversion from pair<double,char>

นอกเหนือจากโบนัสการแปลงโดยนัยแล้วหากคุณไม่ได้ใช้ make_pair คุณต้องทำ

one = pair<int,int>(10,20)

ทุกครั้งที่คุณกำหนดให้กับหนึ่งซึ่งจะน่ารำคาญตลอดเวลา ...

ดังที่ @MSalters ตอบกลับด้านบนตอนนี้คุณสามารถใช้เครื่องมือจัดฟันแบบหยิกเพื่อทำสิ่งนี้ใน C ++ 11 (เพิ่งยืนยันด้วยคอมไพเลอร์ C ++ 11):

pair<int, int> p = {1, 2};

อาร์กิวเมนต์เทมเพลตคลาสไม่สามารถอนุมานจากตัวสร้างได้ก่อน C ++ 17

ก่อน C ++ 17 คุณไม่สามารถเขียนสิ่งที่ชอบ:

std::pair p(1, 'a');

ตั้งแต่นั้นจะอนุมานประเภทแม่แบบจากการสร้างข้อโต้แย้ง

C ++ 17 ทำให้ไวยากรณ์นั้นเป็นไปได้และmake_pairซ้ำซ้อน

ก่อน C ++ 17 std::make_pairอนุญาตให้เราเขียนโค้ด verbose น้อยกว่า:

MyLongClassName1 o1;
MyLongClassName2 o2;
auto p = std::make_pair(o1, o2);

แทน verbose เพิ่มเติม:

std::pair<MyLongClassName1,MyLongClassName2> p{o1, o2};

ซึ่งทำซ้ำประเภทและสามารถยาวมาก

การอนุมานประเภททำงานได้ในกรณีพรี C ++ 17 เนื่องจากmake_pairไม่ใช่ตัวสร้าง

make_pair โดยพื้นฐานแล้วเทียบเท่ากับ:

template<class T1, class T2>
std::pair<T1, T2> my_make_pair(T1 t1, T2 t2) {
    return std::pair<T1, T2>(t1, t2);
}

แนวคิดเดียวกันกับVSinserterinsert_iterator

ดูสิ่งนี้ด้วย:

• ทำไมไม่อนุมานพารามิเตอร์แม่แบบจากตัวสร้าง?
• https://en.wikibooks.org/wiki/More_C++_Idioms/Object_Generator

ตัวอย่างที่น้อยที่สุด

ในการทำให้สิ่งต่าง ๆ เป็นรูปธรรมมากขึ้นเราสามารถสังเกตปัญหาได้น้อยที่สุดด้วย:

main.cpp

template <class MyType>
struct MyClass {
    MyType i;
    MyClass(MyType i) : i(i) {}
};

template<class MyType>
MyClass<MyType> make_my_class(MyType i) {
    return MyClass<MyType>(i);
}

int main() {
    MyClass<int> my_class(1);
}

แล้ว:

g++-8 -Wall -Wextra -Wpedantic -std=c++17 main.cpp

รวบรวมอย่างมีความสุข แต่:

g++-8 -Wall -Wextra -Wpedantic -std=c++14 main.cpp

ล้มเหลวด้วย:

main.cpp: In function ‘int main()’:
main.cpp:13:13: error: missing template arguments before ‘my_class’
     MyClass my_class(1);
             ^~~~~~~~

และต้องการทำงานแทน:

MyClass<int> my_class(1);

หรือผู้ช่วย:

auto my_class = make_my_class(1);

ซึ่งใช้ฟังก์ชั่นปกติแทนนวกรรมิก

ความแตกต่างสำหรับ `std :: reference_wrapper

ความคิดเห็นนี้พูดถึงว่าไม่ได้std::make_pairห่อหุ้มstd::reference_wrapperในขณะที่ตัวสร้างไม่ได้ดังนั้นจึงเป็นข้อแตกต่าง ตัวอย่างสิ่งที่ต้องทำ

ทดสอบกับGCC 8.1.0, อูบุนตู 16.04

ไม่มีความแตกต่างระหว่างการใช้make_pairและการเรียกคอนpairสตรัคเตอร์อย่างชัดเจนด้วยอาร์กิวเมนต์ชนิดที่ระบุ std::make_pairสะดวกยิ่งขึ้นเมื่อชนิดเป็น verbose เนื่องจากวิธีการแม่แบบมีการหักประเภทตามพารามิเตอร์ที่กำหนด ตัวอย่างเช่น,

std::vector< std::pair< std::vector<int>, std::vector<int> > > vecOfPair;
std::vector<int> emptyV;

// shorter
vecOfPair.push_back(std::make_pair(emptyV, emptyV));

 // longer
vecOfPair.push_back(std::pair< std::vector<int>, std::vector<int> >(emptyV, emptyV));

เป็นที่น่าสังเกตว่านี่เป็นสำนวนทั่วไปในการเขียนโปรแกรมเทมเพลต C ++ เป็นที่รู้จักกันเป็นวัตถุปั่นไฟสำนวนคุณสามารถหาข้อมูลเพิ่มเติมและตัวอย่างที่ดีที่นี่

แก้ไขตามที่มีคนแนะนำในความคิดเห็น (ตั้งแต่ลบ) ต่อไปนี้เป็นสารสกัดที่แก้ไขเล็กน้อยจากลิงค์ในกรณีที่มันแตก

เครื่องสร้างวัตถุช่วยให้การสร้างวัตถุโดยไม่ต้องระบุประเภทของพวกเขาอย่างชัดเจน มันขึ้นอยู่กับคุณสมบัติที่มีประโยชน์ของฟังก์ชั่นเทมเพลตซึ่งเทมเพลตของคลาสไม่มี: พารามิเตอร์ประเภทของเทมเพลตฟังก์ชั่นนั้นจะถูกอนุมานโดยอัตโนมัติจากพารามิเตอร์จริง std::make_pairเป็นตัวอย่างง่ายๆที่คืนค่าอินสแตนซ์ของstd::pairเทมเพลตโดยขึ้นอยู่กับพารามิเตอร์จริงของstd::make_pairฟังก์ชัน

template <class T, class U>
std::pair <T, U> 
make_pair(T t, U u)
{
  return std::pair <T, U> (t,u);
}

make_pair สร้างสำเนาเพิ่มเติมบนตัวสร้างโดยตรง ฉันพิมพ์คู่ของฉันเสมอเพื่อให้ไวยากรณ์ที่เรียบง่าย
สิ่งนี้แสดงให้เห็นถึงความแตกต่าง (ตัวอย่างโดย Rampal Chaudhary):

class Sample
{
    static int _noOfObjects;

    int _objectNo;
public:
    Sample() :
        _objectNo( _noOfObjects++ )
    {
        std::cout<<"Inside default constructor of object "<<_objectNo<<std::endl;
    }

    Sample( const Sample& sample) :
    _objectNo( _noOfObjects++ )
    {
        std::cout<<"Inside copy constructor of object "<<_objectNo<<std::endl;
    }

    ~Sample()
    {
        std::cout<<"Destroying object "<<_objectNo<<std::endl;
    }
};
int Sample::_noOfObjects = 0;


int main(int argc, char* argv[])
{
    Sample sample;
    std::map<int,Sample> map;

    map.insert( std::make_pair( 1, sample) );
    //map.insert( std::pair<int,Sample>( 1, sample) );
    return 0;
}

เริ่มต้นจาก c ++ 11 เพียงใช้การเริ่มต้นที่เหมือนกันสำหรับคู่ ดังนั้นแทนที่จะ:

std::make_pair(1, 2);

หรือ

std::pair<int, int>(1, 2);

เพียงแค่ใช้

{1, 2};