Using std:.pair right

[desktop]

I have made this little test with std::pair:

test<intt1(1);
test<intt2(2);
std::pair<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]

desktop wrote:

I have made this little test with std::pair:

test<intt1(1);
test<intt2(2);
std::pair<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?

--
Ian Collins.

[Andre Kostur]

desktop <ff*@sss.comwro te in news:f4******** **@news.net.uni-c.dk:

I have made this little test with std::pair:

test<intt1(1);
test<intt2(2);
std::pair<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::pair 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]

On 6/15/07 4:30 PM, in article f4**********@ne ws.net.uni-c.dk, "desktop"
<ff*@sss.comwro te:

I have made this little test with std::pair:

test<intt1(1);
test<intt2(2);
std::pair<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<intt1(1);
test<intt2(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]

desktop wrote:

I have made this little test with std::pair:

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

std::pair<test< int>, test<int mypair(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?

[Rolf Magnus]

desktop wrote:

I have made this little test with std::pair:

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

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

MyPair mypair(t1, t2);

[Pete Becker]

desktop wrote:

I have made this little test with std::pair:

test<intt1(1);
test<intt2(2);
std::pair<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<Tobjects. 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]

Ian Collins wrote:

desktop wrote:

>I have made this little test with std::pair:

test<intt1(1);
test<intt2(2);
std::pair<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?

Using 'auto' in the upcoming standard?

[Baltimore]

On 17 juin, 11:40, Juha Nieminen <nos...@thanks. invalidwrote:

Ian Collins wrote:

desktop wrote:

I have made this little test with std::pair:

test<intt1(1);
test<intt2(2);
std::pair<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?

Using 'auto' in the upcoming standard?

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

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

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

[Rolf Magnus]

Juha Nieminen wrote:

Ian Collins wrote:

>desktop wrote:

>>I have made this little test with std::pair:

test<intt1(1);
test<intt2(2);
std::pair<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?

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.