std::pair<,>

[Neil Zanella]

Hello,

I would like to ask how come the design of C++ includes
std:air. First of all I don't think many programmers
would use it. For starters, what the first and second
members are depends on what you are using the pair
for. For instance if I am using coordinates in two
dimensional space then I like to use x and y. So
I might as well define my own struct with x and
y members in it and create a constructor so
that I can easily instantiate pairs.

I wonder if there is a way to create a pair class
using std:air but typedef its first and second
to x and y using C++. The only way I can think
of is to subclass std:air<,>.

Suggestions and reccomendation on the best
practices and conventions for using std:air<,>
are most welcome.

Thanks,

Neil

 

[Neil Zanella]

Here is my way of making use of std:air<class T1, class T2>:

#include <iostream>
#include <utility>

template<class T1, class T2>
class Coordinate: public std:air<T1, T2> {
public:
Coordinate(T1 x, T2 y): std:air<T1, T2>(x, y), x(first), y(second) { }
T1 &x;
T2 &y;
};

int main() {
Coordinate<int, int> foo(1, 2);
std::cout << "x = " << foo.x << "\ny = " << foo.y << std::endl;
}

 

[Jonathan Mcdougall]

I would like to ask how come the design of C++ includes

std:air.

I think primarly for std::map and the map-like containers.

First of all I don't think many programmers
would use it.

Depends on the programmer, I think. I use it quite
often.

For starters, what the first and second
members are depends on what you are using the pair
for. For instance if I am using coordinates in two
dimensional space then I like to use x and y. So
I might as well define my own struct with x and
y members in it and create a constructor so
that I can easily instantiate pairs.

I wonder if there is a way to create a pair class
using std:air but typedef its first and second
to x and y using C++. The only way I can think
of is to subclass std:air<,>.

That would be one way if you want your struct to be
compatible with std:air<>. If not, make it
a private member or, as you said, create a new
struct.

Suggestions and reccomendation on the best
practices and conventions for using std:air<,>
are most welcome.

There are none, imho.


Jonathan

 

[Default User]

Hello,

I would like to ask how come the design of C++ includes
std:air. First of all I don't think many programmers
would use it.

I generally use std::make_pair().




Brian Rodenborn

 

[David Rubin]

Hello,

I would like to ask how come the design of C++ includes
std:air. First of all I don't think many programmers
would use it. For starters, what the first and second
members are depends on what you are using the pair
for. For instance if I am using coordinates in two
dimensional space then I like to use x and y. So
I might as well define my own struct with x and
y members in it and create a constructor so
that I can easily instantiate pairs.

I wonder if there is a way to create a pair class
using std:air but typedef its first and second
to x and y using C++. The only way I can think
of is to subclass std:air<,>.

Suggestions and reccomendation on the best
practices and conventions for using std:air<,>
are most welcome.

I think you can start by doing something like

template <typename T>
class Point : public std:air<T,T>
{
public:
T& x,y;
Point(const T& a, const T& b) : std:air<T,T>(a,b), x(first),
y(second) {}
/* ... */
};

This gives you more of a pointy interface while also modeling a
container.

/david

 

[WW]

Here is my way of making use of std:air<class T1, class T2>:

#include <iostream>
#include <utility>

template<class T1, class T2>
class Coordinate: public std:air<T1, T2> {
public:
Coordinate(T1 x, T2 y): std:air<T1, T2>(x, y), x(first),
y(second) { } T1 &x;
T2 &y;
};

The above class cannot be assigned, or copy constructed. Plus: do not use
inheritance when composition suffices:

template<class T1, class T2>
struct Coordinate {
Coordinate():
store(T1(),T2()), x(store.first), y(store.second) { }
Coordinate(T1 px, T2 py):
store(px,py), x(store.first), y(store.second) { }
Coordinate(Coordinate const &o):
store(o.store), x(store.first), y(store.second) { }
Coordinate operator=(Coordinate const &o)
{ store = o.store; }
T1 &x;
T2 &y;
private:
std:air<T1, T2> store;
};

Also note that the above class will be bigger than the pair. In case of
int, on a usual architecture it will be twice as big. So IMHO you are
better off having accessor functions - if you must access the elements from
the outside.

template<class T1, class T2>
struct Coordinate {
Coordinate(): store(T1(),T2()) { }
Coordinate(T1 px, T2 py): store(px,py) { }
Coordinate(Coordinate const &o): store(o.store) { }
Coordinate operator=(Coordinate const &o) { store = o.store; }
T1 &x() {return store.first; }
T2 &y() {return store.second; }
private:
std:air<T1, T2> store;
};

But to be honest I would just leave std:air out of this completely and
make a little template struct of my own, with the right names.

 

[Mike Wahler]

Hello,

I would like to ask how come the design of C++ includes
std:air.

It's useful for some things. If you don't find it
useful, don't use it.

Also note that the standard container types 'std::map'
and 'std::multimap' use type 'std:air' objects to represent
their elements. If you use a map or multimap, you're
(at least indirectly) using 'std:air' objects.
Also e.g. one of the overloads of 'std::map::insert()'
returns a 'std:air' object (not an element value,
but a pair of values, the first of which is an iterator
object pointing to the inserted element (if one was inserted),
and the other a type 'bool' indicating whether or not
the insertion occurred.)

'std:air' can also be used as a 'general purpose'
set of two values.

First of all I don't think many programmers
would use it.

I do.

For starters, what the first and second
members are depends on what you are using the pair
for.

Well of course.

For instance if I am using coordinates in two
dimensional space then I like to use x and y.

But what are their types? Are the types the same?
The already existing template 'std:air' will
handle them whatever they are.

So
I might as well define my own struct with x and
y members in it and create a constructor so
that I can easily instantiate pairs.

This can already be done with 'std:air', which
has three constructors defined (one of them a
template). "Don't reinvent the wheel" and all that.

I wonder if there is a way to create a pair class
using std:air but typedef its first and second
to x and y using C++.

Are 'x' and 'y' types or values? In either case,
std:air can handle it.

The only way I can think
of is to subclass std:air<,>.

IMO no reason to.

std:air<T,T>(x,y);

Done.

Also see 'std::make_pair()'

Suggestions and reccomendation on the best
practices and conventions for using std:air<,>
are most welcome.

Use it if useful, don't use it if not.

-Mike

 

[David Rubin]

I wonder if there is a way to create a pair class
using std:air but typedef its first and second
to x and y using C++. [snip]
The only way I can think
of is to subclass std:air<,>.

IMO no reason to.

std:air<T,T>(x,y);

The question is, is a Point a pair? From the description of pair, it
seems like the answer is yes. So, if you want a Point with members x and
y, why not subclass?

/david

 

[David Rubin]

David Rubin wrote:

[snip]

This gives you more of a pointy interface while also modeling a
container.

Not true; std:air does not model a Container.

/david

 

[Mike Wahler]

I wonder if there is a way to create a pair class
using std:air but typedef its first and second
to x and y using C++. [snip]
The only way I can think
of is to subclass std:air<,>.

IMO no reason to.

std:air<T,T>(x,y);

The question is, is a Point a pair? From the description of pair, it
seems like the answer is yes.
Agreed.

So, if you want a Point with members x and
y, why not subclass?

Why not simply:

std:air<int,int> coord(x,y);

or if you like:

typedef std:air<int,int> Point;

Point coord(x,y);

??

-Mike

 

[Jonathan Mcdougall]

So, if you want a Point with members x and

Why not simply:

std:air<int,int> coord(x,y);

or if you like:

typedef std:air<int,int> Point;

Point coord(x,y);

The thig is

coord.first = 2;

is not quite representative, as opposed to

coord.x = 2;


Jonathan

 

[WW]

The question is, is a Point a pair? From the description of pair, it
seems like the answer is yes. So, if you want a Point with members x
and y, why not subclass?

A point is not a pair. A point can be in 1 or 2 dimensions. A pair is
always a pair. They do look similar, but that is all.

 

[Mike Wahler]

The thig is

coord.first = 2;

is not quite representative, as opposed to

coord.x = 2;

Ah, ok I misunderstood. He wants specific member
names.

"Ne-e-e-e-e-ver Mind!"
-Gilda Radner

-Mike

 

[Neil Zanella]

The thing is

coord.first = 2;

is not quite representative, as opposed to

coord.x = 2;

Jonathan

That was exactly my point. As other posters have pointed out, there is a
function called std::make_pair(,) but that does not improve things much. Rather,
the main purpose of std:air in the STL is so that in an associative container
such as an std::map or std::multimap you can use the .first notation to access
the key stored for a particular value (also accessed with .second). This is
quite handy since if you're iterating over a map you will need .first
to access the keys, and .second to access the values.

So, in conclusion, when dealing with points in two dimensional space (or other
dimensions for that matter) it's not very nice to use std:air: that's not
what it was meant to. I don't think std:air supports arithmetical operations
on points, and besides, using first and second instead of something like x and
y leads to poor naming. The names first and second are not suitable for all
applications from a semantical point of view: they make things harder to
interpret. The real use of std:air is for providing first and second
to std::map and std::multimap.

Regards,

Neil

 

[Cy Edmunds]

The above class cannot be assigned, or copy constructed. Plus: do not use
inheritance when composition suffices:

template<class T1, class T2>
struct Coordinate {
Coordinate():
store(T1(),T2()), x(store.first), y(store.second) { }
Coordinate(T1 px, T2 py):
store(px,py), x(store.first), y(store.second) { }
Coordinate(Coordinate const &o):
store(o.store), x(store.first), y(store.second) { }
Coordinate operator=(Coordinate const &o)
{ store = o.store; }
T1 &x;
T2 &y;
private:
std:air<T1, T2> store;
};

Also note that the above class will be bigger than the pair. In case of
int, on a usual architecture it will be twice as big. So IMHO you are
better off having accessor functions - if you must access the elements from
the outside.

template<class T1, class T2>
struct Coordinate {
Coordinate(): store(T1(),T2()) { }
Coordinate(T1 px, T2 py): store(px,py) { }
Coordinate(Coordinate const &o): store(o.store) { }
Coordinate operator=(Coordinate const &o) { store = o.store; }
T1 &x() {return store.first; }
T2 &y() {return store.second; }
private:
std:air<T1, T2> store;
};

But to be honest I would just leave std:air out of this completely and
make a little template struct of my own, with the right names.

This thread is kind of an unintentional parody of going massively overboard
with reuse. Perhaps you should ask yourselves why the designers of the
standard library didn't derive std::complex from std:air. The answer: they
weren't nuts. lol

If you want a class with an x and a y, just write one from scratch. It's
about 10 lines of code depending on how you format it. And anybody will be
able to understand it in a glance without wondering why you were standing on
your head to reuse std:air.