make pair usuage


The behavior of this function template is the same as if defined as:
1
2
3
4
5
template <class T1,class T2>
  pair<T1,T2> make_pair (T1 x, T2 y)
  {
    return ( pair<T1,T2>(x,y) );
  }
// make_pair example
#include <utility>      // std::pair
#include <iostream>     // std::cout

int main () {
  std::pair <int,int> foo;
  std::pair <int,int> bar;

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

  std::cout << "foo: " << foo.first << ", " << foo.second << '\n';
  std::cout << "bar: " << bar.first << ", " << bar.second << '\n';

  return 0;
}
The difference is that with std::pair you need to specify the types of both elements, whereas std::make_pair will create a pair with the type of the elements that are passed to it, without you needing to tell it. That's what I could gather from various docs anyways.
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>
Aside from the implicit conversion bonus of it, if you didn't use make_pair you'd have to do
one = pair<int,int>(10,20)
every time you assigned to one, which would be annoying over time..
There is no difference between using make_pair and explicitly calling the pair constructor with specified type arguments. std::make_pair is more convenient when the types are verbose because a template method has type deduction based on its given parameters. For example,
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));

Comments

Post a Comment

Popular posts from this blog

Number theory Part-2

Image
Introduction Problems in competitive programming which involve Mathematics are are usually about number theory, or geometry. If you know number theory, that increases your ammo heavily in solving a lot of tougher problems, and helps you in getting a strong hold on a lot of other problems, too. Problems in competitive programming require insight, so just knowing some topics is not enough at all. All of the problems requires more or less math tough. For instance, solving large systems of equations and approximating solutions to differential equations.  Set Theory Before we proceed, let us get through the some common set operations. Q.) What is a Set? -In mathematics, a set is a collection of distinct objects, considered as an object in its own right. For example, the numbers 2, 4, and 6 are distinct objects when considered separately, but when they are considered collectively they form a single set of size three, written {2,4,6}. Sets are one of the most fundamental con...
Read more

Number Theory Part-1

Image
Introduction: Problems in competitive programming which involve Mathematics are are usually about number theory, or geometry. If you know number theory, that increases your ammo heavily in solving a lot of tougher problems, and helps you in getting a strong hold on a lot of other problems, too. Problems in competitive programming require insight, so just knowing some topics is not enough at all. All of the problems requires more or less math tough. For instance, solving large systems of equations and approximating solutions to differential equations. Modulo: Modulo operation gives the remainder after division, when one number is divided by another. It is denoted by % sign. Example: We have two numbers 5 and 2, then 5%2 is 1 as when 5 is divided by 2, it leaves 1 as remainder. Properties: Some of the properties of modulo are: (a+b)%c = (a%c + b%c )%c. (a * b)%c = ((a%c) * (b%c))%c. Example: Let’s say a = 5, b = 3, c = 2. Then: 1) (5+3)%2 = 8%2 = 0. Similarly (5%2 ...
Read more
HOT UPDATE: Added tricks about REGEX, Raw Strings, User-defined Literals. As a whole new section! WARNING: Many of these things belong to C++11 so use C++11 in order to test anything here :) I just write a short version for this article, because it's now in the main page. I recommend you to click on "Read more »" and read more :) Here is a short trick for the short version: I see lots of programmers write code like this one: pair < int , int > p ; vector <int> v ; // ... p = make_pair ( 3 , 4 ); v . push_back ( 4 ); v . push_back ( 5 ); while you can just do this: pair < int , int > p ; vector <int> v ; // ... p = { 3 , 4 }; v = { 4 , 5 }; 1. Assign value by a pair of {} to a container I see lots of programmers write code like this one: pair < int , int > p ; // ... p = make_pair ( 3 , 4 ); while you can just do this: pair < int , int > p ; // ... p = { 3 , 4 }; even a more complex ...
Read more