instantiate pair object in C++ - c++11

Question

I have a vertex class with many objects, e.g.
class Vertex{
int i;
public:
Vertex(const int & a):i(a){}
};
Vertex v1(1),v2(2)...v100(100);
Now I want to make 50 pairs, each pair linking two vertices. What is the best way to achieve this? I definitely don't want to do the following:
std::pair<const Vertex &, const Vertex &> p1(v1,v2);
...
std::pair<const Vertex &, const Vertex &> p50(v99,v100);
std::make_pair seems to be a better choice. But it only accept values, not references, if I understand correctly. Thanks a lot.

Answer 1

std::make_pair can be used to create pairs of references through the use of std::ref. std::ref stores a reference in a std::reference_wrapper, which through template type deduction, reduces back to the reference. For a const reference, use std::cref.
As the other answers suggest, I'd recommend storing your Vertexes in a std::vector, and initialize them in a for loop. Similarly, store your std::pairs of Vertex references in a vector and construct them in a loop as well.
constexpr auto num_vertices = 100;
std::vector<Vertex> v;
v.reserve(num_vertices);
for (auto i = 0; i < num_vertices; ++i)
v.emplace_back(i);
std::vector<std::pair<const Vertex&, const Vertex&>> p;
p.reserve(num_vertices/2);
for (auto i = 0; i < num_vertices; i += 2)
p.emplace_back(v[i], v[i+1]);
Notice that emplace_back is used to construct the Vertexes and std::pairs in-place.
However, if you are tied to 50 lines of pair initialization, and want to use the type deduction offered by std::make_pair, use:
auto p1 = std::make_pair(std::cref(v1), std::cref(v2)),
p2 = std::make_pair(std::cref(v3), std::cref(v4)),
// ...
p50 = std::make_pair(std::cref(v99), std::cref(v100));
But in this case, it's simpler to just use uniform initialization:
std::pair<const Vertex&, const Vertex&> p1 = {v1, v2},
p2 = {v2, v3},
// ...
p50 = {v99, v100};
Here's a live example on ideone.com.

Answer 2

Why not use a std::vector to store your pairs of Vertex's?
std::vector<std::pair<Vertex, Vertex>> v;
v.reserve(50); // Reserve memory to avoid unnecessary allocations.
for (int i = 1; i < 100; i += 2) {
v.emplace_back(i, i + 1); // Create 50 pairs in vector.
}
Later access individual vertices like so:
auto& p1 = v[0];
/* ... */
auto& p50 = v[49];
If you really want to keep 100 variables for all the vertices then you can store constant references to Vertex in std::pair using std::reference_wrapper:
auto p1 = std::make_pair(std::cref(v1), std::cref(v2));