By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
435,318 Members | 2,116 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 435,318 IT Pros & Developers. It's quick & easy.

Some problems with std::vector and nested templates

P: n/a
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.

Jun 17 '07 #1
Share this Question
Share on Google+
13 Replies


P: n/a
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
Jun 17 '07 #2

P: n/a
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??

Jun 17 '07 #3

P: n/a
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
Jun 17 '07 #4

P: n/a
On 17 Jun, 17:49, John Harrison <john_androni...@hotmail.comwrote:
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

Jun 17 '07 #5

P: n/a
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
Jun 17 '07 #6

P: n/a
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
Jun 17 '07 #7

P: n/a
>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
Jun 17 '07 #8

P: n/a
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
Jun 17 '07 #9

P: n/a
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.
Jun 17 '07 #10

P: n/a
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
Jun 17 '07 #11

P: n/a
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
Jun 17 '07 #12

P: n/a
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
Jun 17 '07 #13

P: n/a
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.
Jun 18 '07 #14

This discussion thread is closed

Replies have been disabled for this discussion.