Some problems with std::vector and nested templates

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<Tfind_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.

jubelbrus wrote:
I'm assuming uint32_t might be typedefed somewhere.
What's T? This is not a template?
huh?
template <class T>
boost::shared_ptr<T>
list<T>::getitem(uint32_t id)
?
What's list?
typename std::vector<boost::tuple<uint32_t, boost::shared_ptr<TYou need typename here, because vector< ... is dependent on T.
*pos is a tuple, not a shared_ptr
--
rbh

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<Tboost::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_typeboost::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??

jubelbrus wrote:Perhaps you mean

m_vector.push_back( add_item );

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

john

On 17 Jun, 17:49, John Harrison <john_androni...@hotmail.comwrote:oh... :)

thanks

jubelbrus wrote:
There should be no typename here.
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>();
}
// beginning
//end

Shorter:
std::vector<...>::insert(tuple<...>)
//beginning
//end
shorter:
std::vector<...>::insert(std::vector<...>::iterato r, const tuple<...>&)
//beginning
//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

On Sun, 17 Jun 2007 15:22:52 -0000, jubelbrus wrote:[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

>Perhaps you meanThose 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

On Sun, 17 Jun 2007 16:00:40 GMT, John Harrison wrote:Obviously, there is 'something really significant wrong' with Boost.


--
Roland Pibinger
"The best software is simple, elegant, and full of drama" - Grady Booch

In article <4675619b.2363638@news.utanet.at>, rpbg123@yahoo.com says...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.

Roland Pibinger wrote: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

On Sun, 17 Jun 2007 11:07:57 -0600, Jerry Coffin wrote:Hardly. No one abuses templates the way Boost does.
The treatment of symptoms is not a cure.
You mean Stroustrup's where-clause? OMG, please no!


--
Roland Pibinger
"The best software is simple, elegant, and full of drama" - Grady Booch

Roland Pibinger wrote:What? Why not?

Do you like non-understandable error messages?

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

In article <4675a1c3.1072221@news.utanet.at>, rpbg123@yahoo.com says...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...
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.
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.