Using std:.pair right

[desktop]

I have made this little test with std:air:

test<int> t1(1);
test<int> t2(2);
std:air<test<int>,test<int> > mypair = std::make_pair(t1,t2);

where test is a template class I wrote. It seems a bit cumbersome to
make a pair are there any better way to do it than the above procedure?

 

[Ian Collins]

I have made this little test with std:air:

test<int> t1(1);
test<int> t2(2);
std:air<test<int>,test<int> > mypair = std::make_pair(t1,t2);

where test is a template class I wrote. It seems a bit cumbersome to
make a pair are there any better way to do it than the above procedure?

What would you suggest?

 

[Andre Kostur]

I have made this little test with std:air:

test<int> t1(1);
test<int> t2(2);
std:air<test<int>,test<int> > mypair = std::make_pair(t1,t2);

where test is a template class I wrote. It seems a bit cumbersome to
make a pair are there any better way to do it than the above procedure?

How would you make it easier? std:air needs to know the type of each of
its halves, Your template class needs to know what type it's templated on.
Where do you see where it could be made easier?

 

[Greg Herlihy]

I have made this little test with std:air:

test<int> t1(1);
test<int> t2(2);
std:air<test<int>,test<int> > mypair = std::make_pair(t1,t2);

where test is a template class I wrote. It seems a bit cumbersome to
make a pair are there any better way to do it than the above procedure?

Yes:

test<int> t1(1);
test<int> t2(2);

auto mypair = std::make_pair(t1, t2);

Unfortunately, you will need a C++ compiler that has implemented this C++09
feature in order for this code to compile.

Greg

 

[benben]

I have made this little test with std:air:

test<int> t1(1);
test<int> t2(2);
std:air<test<int>,test<int> > mypair = std::make_pair(t1,t2);

 

[Rolf Magnus]

I have made this little test with std:air:

test<int> t1(1);
test<int> t2(2);
std:air<test<int>,test<int> > mypair = std::make_pair(t1,t2);

typedef std:air<test<int>,test<int> > MyPair;

MyPair mypair(t1, t2);

 

[Pete Becker]

I have made this little test with std:air:

test<int> t1(1);
test<int> t2(2);
std:air<test<int>,test<int> > mypair = std::make_pair(t1,t2);

where test is a template class I wrote. It seems a bit cumbersome to
make a pair are there any better way to do it than the above procedure?

It depends on what you're trying to accomplish. For your simple example,
the solution is to not use pair, but write a template class that holds
two test<T> objects. More generally, just as with iterators, creating
named objects of pair types often reflects a design mistake. make_pair
avoids having to write the types involved, which makes it easy to pass
its return value to a template function:

template <class T>
void f(T t);

f(make_pair(t1, t2));

Once you start naming objects you've lost the benefit of make_pair,
because you still have to name the type of the pair. While the new auto
syntax mentioned in another message can be used to evade this problem,
before doing that you need to ask why you're creating an auto object in
the first place.

--

-- Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com)
Author of "The Standard C++ Library Extensions: a Tutorial and
Reference." (www.petebecker.com/tr1book)

 

[Juha Nieminen]

What would you suggest?

Using 'auto' in the upcoming standard?

 

[Rolf Magnus]

Using 'auto' in the upcoming standard?

Best suggestion ever: Wait a few year until they add that feature to the
language. Then wait another few years until the majority of compilers
actually implement it. Then you can save a few keypresses.

 

[Baltimore]

Using 'auto' in the upcoming standard?

Using a typedef is the easier manner to do this with the current
standard.

typedef std:air<test<int>,test<int> > MyPair;

The implicit template utilisation is an other beautiful manner,
without writing the complete type.

 

[Juha Nieminen]

Best suggestion ever: Wait a few year until they add that feature to the
language. Then wait another few years until the majority of compilers
actually implement it. Then you can save a few keypresses.

Any better suggestion for saving the few keypresses?

 

[=?ISO-8859-1?Q?Erik_Wikstr=F6m?=]

Any better suggestion for saving the few keypresses?

Baltimore's suggestion about using a typedef.

 

[Rolf Magnus]

Baltimore's suggestion about using a typedef.

Which - btw- I already made a day before.

 

[Juha Nieminen]

Baltimore's suggestion about using a typedef.

That only saves keypresses if you have to create more than one
pair. With only one it requires more keypresses.

 

[Greg Herlihy]

Best suggestion ever: Wait a few year until they add that feature to the
language. Then wait another few years until the majority of compilers
actually implement it. Then you can save a few keypresses.

Deducing the type of variable from its initializer expression has
already been voted into C++, so as a feature it has already been
added. Moreover, I see little reason why the poster would have to wait
until the "majority" of C++ compilers supported a

 

[Greg Herlihy]

Best suggestion ever: Wait a few year until they add that feature to the
language. Then wait another few years until the majority of compilers
actually implement it. Then you can save a few keypresses.

Actually, deducing the type of variable from its initializer
expression has already been voted into C++, so it's only a matter of
lobbying C++ compiler vendors to support it in their compilers.
Furthermore, I see no reason why the original poster would have to
wait until the "majority" of C++ compilers support this feature -
instead of just the C++ compiler he happens to be using.

I would point out that the "auto" keyword saves a few keystrokes only
if you already know what those keystrokes should be. But figuring out
the return type of a function call may not always be easy (e.g.
boost::bind) or even be possible (in a portable way). What type, for
example, does std::tr1::mem_fn() return:

struct A
{
int f();
};

??? mf = std::tr1::mem_fn( &A::f);

Hint: it's unspecified.

Greg

 

[James Kanze]

Best suggestion ever: Wait a few year until they add that feature to the
language. Then wait another few years until the majority of compilers
actually implement it. Then you can save a few keypresses.

More than keystrokes, I think the point is maintainability.
Modify t1 and t2 to be test<long>, and everything works with
auto.

 

[Jerry Coffin]

That only saves keypresses if you have to create more than one
pair. With only one it requires more keypresses.

I haven't actually counted characters, but I believe this typedef should
save a few keystrokes even the first time around:

typedef test<int> ti;

ti t1(1), t2(2);

std:air<ti, ti> mypair=std::make_pair(t1, t2);

 

[Andrew Koenig]

I have made this little test with std:air:

test<int> t1(1);
test<int> t2(2); std:air<test<int>,test<int> > mypair =
std::make_pair(t1,t2);

where test is a template class I wrote. It seems a bit cumbersome to make
a pair are there any better way to do it than the above procedure?

How about

std:air<test<int>,test<int> > mypair(t1, t2);

? It might even be that you can write

std:air<test<int>,test<int> > mypair(1, 2);

depending on your definition of test.