Was ist der Zweck von std :: make_pair gegenüber dem Konstruktor von std :: pair?

Was ist der Zweck von std::make_pair?

Warum nicht einfach tun std::pair<int, char>(0, 'a')?

Gibt es einen Unterschied zwischen den beiden Methoden?

Der Unterschied besteht darin, dass std::pairSie die Typen beider Elemente angeben müssen, während std::make_pairein Paar mit dem Typ der Elemente erstellt wird, die an das Element übergeben werden, ohne dass Sie es angeben müssen. Das könnte ich sowieso aus verschiedenen Dokumenten entnehmen.

Siehe dieses Beispiel unter 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>

Abgesehen vom impliziten Conversion-Bonus müssten Sie dies tun, wenn Sie make_pair nicht verwenden würden

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

jedes Mal, wenn Sie einem zugewiesen haben, was mit der Zeit ärgerlich wäre ...

Wie @MSalters oben geantwortet hat, können Sie jetzt in C ++ 11 geschweifte Klammern verwenden (dies wurde gerade mit einem C ++ 11-Compiler überprüft):

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

Klassenvorlagenargumente konnten vor C ++ 17 nicht vom Konstruktor abgeleitet werden

Vor C ++ 17 konnte man so etwas nicht schreiben:

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

da dies Vorlagentypen aus den Konstruktorargumenten ableiten würde.

C ++ 17 macht diese Syntax möglich und daher make_pairredundant.

Vor C ++ 17 std::make_pairdurften wir weniger ausführlichen Code schreiben:

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

statt der ausführlicheren:

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

Das wiederholt die Typen und kann sehr lang sein.

Die Typinferenz funktioniert in diesem Fall vor C ++ 17, da make_paires sich nicht um einen Konstruktor handelt.

make_pair ist im Wesentlichen gleichbedeutend mit:

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

Das gleiche Konzept gilt für insertervs insert_iterator.

Siehe auch:

• Warum nicht den Vorlagenparameter vom Konstruktor ableiten?
• https://en.wikibooks.org/wiki/More_C++_Idioms/Object_Generator

Minimales Beispiel

Um die Dinge konkreter zu machen, können wir das Problem minimal beobachten mit:

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);
}

dann:

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

kompiliert gerne, aber:

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

schlägt fehl mit:

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

und erfordert stattdessen zu arbeiten:

MyClass<int> my_class(1);

oder der Helfer:

auto my_class = make_my_class(1);

die eine reguläre Funktion anstelle eines Konstruktors verwendet.

Unterschied für `std :: reference_wrapper

In diesem Kommentar wird erwähnt, dass das std::make_pairEntpacken erfolgt, std::reference_wrapperwährend der Konstruktor dies nicht tut. Das ist also ein Unterschied. TODO Beispiel.

Getestet mit GCC 8.1.0, Ubuntu 16.04 .

Es gibt keinen Unterschied zwischen der Verwendung make_pairund dem expliziten Aufruf des pairKonstruktors mit angegebenen Typargumenten. std::make_pairDies ist praktischer, wenn die Typen ausführlich sind, da eine Vorlagenmethode eine Typableitung basierend auf den angegebenen Parametern aufweist. Beispielsweise,

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));

Es ist erwähnenswert, dass dies eine gängige Redewendung in der C ++ - Vorlagenprogrammierung ist. Es ist als Objektgenerator-Sprache bekannt. Weitere Informationen und ein schönes Beispiel finden Sie hier .

Bearbeiten Wie in den Kommentaren vorgeschlagen (seitdem entfernt), ist das Folgende ein leicht modifizierter Auszug aus dem Link, falls er kaputt geht.

Ein Objektgenerator ermöglicht die Erstellung von Objekten, ohne deren Typ explizit anzugeben. Es basiert auf einer nützlichen Eigenschaft von Funktionsvorlagen, die Klassenvorlagen nicht haben: Die Typparameter einer Funktionsvorlage werden automatisch aus ihren tatsächlichen Parametern abgeleitet. std::make_pairist ein einfaches Beispiel, das std::pairabhängig von den tatsächlichen Parametern der std::make_pairFunktion eine Instanz der Vorlage zurückgibt .

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

make_pair erstellt eine zusätzliche Kopie über den direkten Konstruktor. Ich tippe meine Paare immer ein, um eine einfache Syntax bereitzustellen.
Dies zeigt den Unterschied (Beispiel von 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;
}

Verwenden Sie ab C ++ 11 nur eine einheitliche Initialisierung für Paare. Also statt:

std::make_pair(1, 2);

oder

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

benutz einfach

{1, 2};