Some problems with std::vector and nested templates

[jubelbrus]

Hi

I'm trying to do the following.

#include <vector>
#include <boost/thread/mutex.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/tuple/tuple.hpp>

class {
boost::mutex m_lock;
std::vector<boost::tuple<uint32_t, boost::shared_ptr<T >
m_vector;

template <class Tboost::shared_ptr<Tlist::<T>getitem(uint32_t id)
{
boost::mutex::scoped_lock lock(m_lock);

std::vector< boost::tuple<uint32_t, boost::shared_ptr<T

>::iterator pos =

find_if(m_vector.begin(), m_vector.end(), compare_list<T>(id),
m_vector.begin());

if (pos != m_vector.end())
return *pos;

return boost::shared_ptr(NULL);
};

but I get the following error
error: expected ';' before 'pos'

I don't understand why I'm getting this error because the definition
of std::vector works, it's just the iterator statement that doesn't.

[Robert Bauck Hamar]

jubelbrus wrote:

Hi

I'm trying to do the following.

#include <vector>
#include <boost/thread/mutex.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/tuple/tuple.hpp>

class {
boost::mutex m_lock;
std::vector<boost::tuple<uint32_t, boost::shared_ptr<T >
m_vector;

I'm assuming uint32_t might be typedefed somewhere.
What's T? This is not a template?

template <class Tboost::shared_ptr<Tlist::<T>getitem(uint32_t id)

huh?
template <class T>
boost::shared_ptr<T>
list<T>::getitem(uint32_t id)
?
What's list?

{
boost::mutex::scoped_lock lock(m_lock);

std::vector< boost::tuple<uint32_t, boost::shared_ptr<T

>>::iterator pos =

find_if(m_vector.begin(), m_vector.end(), compare_list<T>(id),
m_vector.begin());

typename std::vector<boost::tuple<uint32_t, boost::shared_ptr<T

>::iterator pos = find_if(...)

You need typename here, because vector< ... is dependent on T.

if (pos != m_vector.end())
return *pos;

*pos is a tuple, not a shared_ptr

return boost::shared_ptr(NULL);
};

but I get the following error
error: expected ';' before 'pos'

I don't understand why I'm getting this error because the definition
of std::vector works, it's just the iterator statement that doesn't.

--
rbh

[jubelbrus]

Sorry about the misspellings...

This is what I'm trying to do:
Write a template class that stores a list of boost::shared_ptr<Twith
a index and is thread safe, where T would be that template <class T>
stuff..

I got the getitem function compiling by using typename, tanks.. but
I've discovered some compile problems with my insert code.

#include <stdint.h>
#include <vector>
#include <boost/thread/mutex.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/tuple/tuple.hpp>

template <class T>
class list{
boost::mutex m_lock;
std::vector<boost::tuple<uint32_t, boost::shared_ptr<T >
m_vector;

uint32_t m_nextid;

uint32_t insert(boost::shared_ptr<T>);
}

template <class T>
uint32_t list<T>::insert(boost::shared_ptr<T>)
{
typename boost::tuples::tuple<uint32_t, boost::shared_ptr<T
add_item(m_nextid, item);
typename std::vector<boost::tuple<uint32_t, boost::shared_ptr<T

m_vector;

boost::mutex::scoped_lock lock(m_lock);

m_vector.insert( add_item );
return m_nextid++;

};

I get the following error:
list.h: In member function 'uint32_t
stdtools::list<T>::insert(boost::shared_ptr<T>) [with T = int]':
tester_a.cpp:10: instantiated from here
list.h:90: error: no matching function for call to
'std::vector<boost::tuples::tuple<uint32_t, boost::shared_ptr<int>,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type>,
std::allocator<boost::tuples::tuple<uint32_t, boost::shared_ptr<int>,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type

>::insert(boost::tuples::tuple<uint32_t, boost::shared_ptr<int>,

boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type>&)'
/usr/include/c++/4.0.0/bits/vector.tcc:93: note: candidates are:
typename std::vector<_Tp, _Alloc>::iterator std::vector<_Tp,
_Alloc>::insert(__gnu_cxx::__normal_iterator<typen ame _Alloc::pointer,
std::vector<_Tp, _Alloc, const _Tp&) [with _Tp =
boost::tuples::tuple<uint32_t, boost::shared_ptr<int>,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type>, _Alloc =
std::allocator<boost::tuples::tuple<uint32_t, boost::shared_ptr<int>,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type]
/usr/include/c++/4.0.0/bits/stl_vector.h:657: note:
void std::vector<_Tp,
_Alloc>::insert(__gnu_cxx::__normal_iterator<typen ame _Alloc::pointer,
std::vector<_Tp, _Alloc, size_t, const _Tp&) [with _Tp =
boost::tuples::tuple<uint32_t, boost::shared_ptr<int>,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type>, _Alloc =
std::allocator<boost::tuples::tuple<uint32_t, boost::shared_ptr<int>,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type]

Anybody??

[John Harrison]

jubelbrus wrote:

Sorry about the misspellings...

This is what I'm trying to do:
Write a template class that stores a list of boost::shared_ptr<Twith
a index and is thread safe, where T would be that template <class T>
stuff..

I got the getitem function compiling by using typename, tanks.. but
I've discovered some compile problems with my insert code.

#include <stdint.h>
#include <vector>
#include <boost/thread/mutex.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/tuple/tuple.hpp>

template <class T>
class list{
boost::mutex m_lock;
std::vector<boost::tuple<uint32_t, boost::shared_ptr<T >
m_vector;

uint32_t m_nextid;

uint32_t insert(boost::shared_ptr<T>);
}

template <class T>
uint32_t list<T>::insert(boost::shared_ptr<T>)
{
typename boost::tuples::tuple<uint32_t, boost::shared_ptr<T
add_item(m_nextid, item);
typename std::vector<boost::tuple<uint32_t, boost::shared_ptr<T

>m_vector;

boost::mutex::scoped_lock lock(m_lock);

m_vector.insert( add_item );

Perhaps you mean

m_vector.push_back( add_item );

There is no method of vector called insert that takes a single argument.

john

[jubelbrus]

On 17 Jun, 17:49, John Harrison <[e-mail]:

jubelbrus wrote:

Sorry about the misspellings...

This is what I'm trying to do:
Write a template class that stores a list of boost::shared_ptr<Twith
a index and is thread safe, where T would be that template <class T>
stuff..

I got the getitem function compiling by using typename, tanks.. but
I've discovered some compile problems with my insert code.

#include <stdint.h>
#include <vector>
#include <boost/thread/mutex.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/tuple/tuple.hpp>

template <class T>
class list{
boost::mutex m_lock;
std::vector<boost::tuple<uint32_t, boost::shared_ptr<T >
m_vector;

uint32_t m_nextid;

uint32_t insert(boost::shared_ptr<T>);
}

template <class T>
uint32_t list<T>::insert(boost::shared_ptr<T>)
{
typename boost::tuples::tuple<uint32_t, boost::shared_ptr<T
add_item(m_nextid, item);
typename std::vector<boost::tuple<uint32_t, boost::shared_ptr<T

m_vector;

boost::mutex::scoped_lock lock(m_lock);

m_vector.insert( add_item );

Perhaps you mean

m_vector.push_back( add_item );

There is no method of vector called insert that takes a single argument.

john

oh... :)

thanks

[Robert Bauck Hamar]

jubelbrus wrote:

Sorry about the misspellings...

This is what I'm trying to do:
Write a template class that stores a list of boost::shared_ptr<Twith
a index and is thread safe, where T would be that template <class T>
stuff..

I got the getitem function compiling by using typename, tanks.. but
I've discovered some compile problems with my insert code.

#include <stdint.h>
#include <vector>
#include <boost/thread/mutex.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/tuple/tuple.hpp>

template <class T>
class list{
boost::mutex m_lock;
std::vector<boost::tuple<uint32_t, boost::shared_ptr<T >
m_vector;

uint32_t m_nextid;

uint32_t insert(boost::shared_ptr<T>);
}

template <class T>
uint32_t list<T>::insert(boost::shared_ptr<T>)
{
typename boost::tuples::tuple<uint32_t, boost::shared_ptr<T
add_item(m_nextid, item);

There should be no typename here.

typename std::vector<boost::tuple<uint32_t, boost::shared_ptr<T

>m_vector;

nor here.

typename are needed in:
T::something
or
someclass<T>::something
To put it very short.

This is because the compiler cannot possibly know what something is. The
first is obvious. The second:

template <class T>
class someclass {
public:
typedef T something;
};

int p;

template <class T>
void foo() {
someclass<T>::something * p; /*Missing typename and definition of local p
or multiplication? Standard says multiplication */
}

template <>
class someclass<int{
public:
int something;
};

int someclass<int>::something = 3;

int main() {
p = 42;
foo<int>();
}

boost::mutex::scoped_lock lock(m_lock);

m_vector.insert( add_item );
return m_nextid++;

};

I get the following error:
list.h: In member function 'uint32_t
stdtools::list<T>::insert(boost::shared_ptr<T>) [with T = int]':
tester_a.cpp:10: instantiated from here
list.h:90: error: no matching function for call to

// beginning

'std::vector<boost::tuples::tuple<uint32_t, boost::shared_ptr<int>,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type>,
std::allocator<boost::tuples::tuple<uint32_t, boost::shared_ptr<int>,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type

>>::insert(boost::tuples::tuple<uint32_t, boost::shared_ptr<int>,

boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type>&)'

//end

Shorter:
std::vector<...>::insert(tuple<...>)

/usr/include/c++/4.0.0/bits/vector.tcc:93: note: candidates are:

//beginning

typename std::vector<_Tp, _Alloc>::iterator std::vector<_Tp,
_Alloc>::insert(__gnu_cxx::__normal_iterator<typen ame _Alloc::pointer,
std::vector<_Tp, _Alloc, const _Tp&) [with _Tp =
boost::tuples::tuple<uint32_t, boost::shared_ptr<int>,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type>, _Alloc =
std::allocator<boost::tuples::tuple<uint32_t, boost::shared_ptr<int>,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type]

//end
shorter:
std::vector<...>::insert(std::vector<...>::iterato r, const tuple<...>&)

/usr/include/c++/4.0.0/bits/stl_vector.h:657: note:
void std::vector<_Tp,

//beginning

_Alloc>::insert(__gnu_cxx::__normal_iterator<typen ame _Alloc::pointer,
std::vector<_Tp, _Alloc, size_t, const _Tp&) [with _Tp =
boost::tuples::tuple<uint32_t, boost::shared_ptr<int>,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type>, _Alloc =
std::allocator<boost::tuples::tuple<uint32_t, boost::shared_ptr<int>,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type]

//end

shorter:
std::vector<...>::insert(std::vector<...>::iterato r, size_t, const
tuple<...>&)

Read the messages. They're long and hairy, but it's possible. Matching
parens is a good start.

--
rbh

[Roland Pibinger]

On Sun, 17 Jun 2007 15:22:52 -0000, jubelbrus wrote:

>I get the following error:
list.h: In member function 'uint32_t
stdtools::list<T>::insert(boost::shared_ptr<T>) [with T = int]':
tester_a.cpp:10: instantiated from here
list.h:90: error: no matching function for call to
'std::vector<boost::tuples::tuple<uint32_t, boost::shared_ptr<int>,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type,
boost::tuples::null_type, boost::tuples::null_type>,

[snipped template jumble]

Why don't you ask Boost when you've got a Boost problem?
http://www.boost.org/more/mailing_lists.htm#users
--
Roland Pibinger
"The best software is simple, elegant, and full of drama" - Grady Booch

[John Harrison]

>Perhaps you mean

>>
m_vector.push_back( add_item );

There is no method of vector called insert that takes a single argument.

john

oh... :)

thanks

Those super long error messages make you think there must be something
really significant wrong with your code. But sometimes it's just the
obvious stuff.

john

[Roland Pibinger]

On Sun, 17 Jun 2007 16:00:40 GMT, John Harrison wrote:

>Those super long error messages make you think there must be something
really significant wrong with your code. But sometimes it's just the
obvious stuff.

Obviously, there is 'something really significant wrong' with Boost.
--
Roland Pibinger
"The best software is simple, elegant, and full of drama" - Grady Booch

[Jerry Coffin]

In article <46**************@news.utanet.at>, rp*****@yahoo.com says...

On Sun, 17 Jun 2007 16:00:40 GMT, John Harrison wrote:

Those super long error messages make you think there must be something
really significant wrong with your code. But sometimes it's just the
obvious stuff.

Obviously, there is 'something really significant wrong' with Boost.

Hardly -- you can get the same sort of problems without using Boost. The
problem is sufficiently widespread that Leor Zolman has put quite a bit
of work into stlfilt, to try to make error messages more readable. As I
understand it, lousy error messages from templated code also provided
the motivation for the work that led to Concepts.

--
Later,
Jerry.

The universe is a figment of its own imagination.

[John Harrison]

Roland Pibinger wrote:

On Sun, 17 Jun 2007 16:00:40 GMT, John Harrison wrote:

>Those super long error messages make you think there must be something
really significant wrong with your code. But sometimes it's just the
obvious stuff.

Obviously, there is 'something really significant wrong' with Boost.

At least one compiler I know would quote typedefs that you use back to
you in error messages. So if the OP had written

typedef typename boost::tuple<uint32_t, boost::shared_ptr<T item_type;

he might have got a considerably shorter error message.

john

[Roland Pibinger]

On Sun, 17 Jun 2007 11:07:57 -0600, Jerry Coffin wrote:

>In article <46**************@news.utanet.at>, rpbg123@...com says...

>Obviously, there is 'something really significant wrong' with Boost.

Hardly -- you can get the same sort of problems without using Boost.

Hardly. No one abuses templates the way Boost does.

>The
problem is sufficiently widespread that Leor Zolman has put quite a bit
of work into stlfilt, to try to make error messages more readable.

The treatment of symptoms is not a cure.

>As I
understand it, lousy error messages from templated code also provided
the motivation for the work that led to Concepts.

You mean Stroustrup's where-clause? OMG, please no!
--
Roland Pibinger
"The best software is simple, elegant, and full of drama" - Grady Booch

[Thomas J. Gritzan]

Roland Pibinger wrote:

>As I
understand it, lousy error messages from templated code also provided
the motivation for the work that led to Concepts.

You mean Stroustrup's where-clause? OMG, please no!

What? Why not?

Do you like non-understandable error messages?

--
Thomas
http://www.netmeister.org/news/learn2quote.html

[Jerry Coffin]

In article <46**************@news.utanet.at>, rp*****@yahoo.com says...

On Sun, 17 Jun 2007 11:07:57 -0600, Jerry Coffin wrote:

In article <46**************@news.utanet.at>, rpbg123@...com says...

Obviously, there is 'something really significant wrong' with Boost.

Hardly -- you can get the same sort of problems without using Boost.

Hardly. No one abuses templates the way Boost does.

Actually, everybody else who wants to accomplish the same sorts of
things tends to write fairly similar code -- there are only so many ways
to skin a cat...

The
problem is sufficiently widespread that Leor Zolman has put quite a bit
of work into stlfilt, to try to make error messages more readable.

The treatment of symptoms is not a cure.

I didn't say it was a cure -- but note the "stl" in its name -- it's for
fixing messages that arise from the standard library, NOT Boost.

As I
understand it, lousy error messages from templated code also provided
the motivation for the work that led to Concepts.

You mean Stroustrup's where-clause? OMG, please no!

I mean Concepts. For the formal paper see:

http://www.open-std.org/jtc1/sc22/wg...2007/n2193.pdf

If you care, you can find quite a bit more at:

http://conceptgcc.wordpress.com/

There will probably be at least a few more minor changes by the time the
standard is finalized, but most of it seems nearly certain to be in C++
0x.

--
Later,
Jerry.

The universe is a figment of its own imagination.