problems accessing a structlist

Hi, i'm trying to access a list directly by using [position] on the listname.

Here is the code:

Code:

typedef struct {
	double dx;
	double dy;
	int ic;
} t_fingertip;

typedef struct{
	double dd;
	int ic;
	int ix;
	int iy;
}t_knnclassify;

typedef struct{
	int ix;
	int iy;
	int ic;
} t_knnclassified;

typedef list<t_knnclassify> CLASSIFYLIST;
typedef list <t_knnclassified> CLASSIFIEDFLIST;
typedef list<t_fingertip> FINGERLIST;

CLASSIFIEDFLIST final;
//filled final with some elements
//create an element with data from final-list for the flists (of type FINGERLIST)
//ipos is var given by methoddeclaration
t_fingertip ftx = {(int)final[ipos].ix, (int)final[ipos].iy, (int)final[ipos].ic};
//Adding to list
ptLocalVars->flists->push_back(ftx);

When i try to compile it i get this error:

fingerClassifier.cc:809: no match for `CLASSIFIEDFLIST &[int &]'
fingerClassifier.cc:809: no match for `CLASSIFIEDFLIST &[int &]'
fingerClassifier.cc:809: no match for `CLASSIFIEDFLIST &[int &]'


Anybody knows how to fix it?

Thanks in advance!

~jan

std::list does not overload the subscript operator [].

gg

so how can i access the data?

if you don't NEED to use an STL list, you could use an STL vector, and then you can use the [] operator to access the data. If you HAVE to use an STL list, then I would try a list iterator assigned to the beginning of the list and walk it down ipos number of nodes or you could walk it down until you came to a node with a particular value(s) or you could try using find() to find the first node in the list with a desired value(s).

If you want to use subscripts, something like this should do the trick:

Code:

template <typename T>
const T& ListPosition(std::list<T>::size_type Position, const std::list<T>& List)
{
         std::list<T>::const_iterator ListIter;
         for (std::list<T>::size_type i = 0; i < Position; ++i)
         {
		++ListIter;
         }
         return *ListIter;
}

I didn't test it, so there's bound to be an error or two.

Well, Eibro, that sort of defeats the whole reason there is no [] operator already -- it's very inefficient. Only vector and deque allow random access; list does not. That's because only for vector or deque is it efficient to find, say, the 234th element of the collection.

List is bad at accessing elements in random order (which is what the subscript does) and is good at iterating through the list (e.g. traverse the elements first to last). If you want guaranteed constant time insertion at any arbitrary location, list is good, but don't try to access a single element in the middle.

Originally posted by Cat
Well, Eibro, that sort of defeats the whole reason there is no [] operator already -- it's very inefficient. Only vector and deque allow random access; list does not. That's because only for vector or deque is it efficient to find, say, the 234th element of the collection.

List is bad at accessing elements in random order (which is what the subscript does) and is good at iterating through the list (e.g. traverse the elements first to last). If you want guaranteed constant time insertion at any arbitrary location, list is good, but don't try to access a single element in the middle.

Yes, I realize this. I'd never use something like that, but perhaps he has dug himself a hole and this is the easiest way out. I guess I should have posted a warning with that code.