hello all, i need to store a map iterator in order to know which element of map is being used ,i already tried simple assignment stuff but well as its plain as day, didnt work!
how can i achieve such a thing ?
Printable View
hello all, i need to store a map iterator in order to know which element of map is being used ,i already tried simple assignment stuff but well as its plain as day, didnt work!
how can i achieve such a thing ?
What did you try?
Quote:
Originally Posted by laserlight
Code:map<int,string>::iterator declaration_iter;
map<int,string> declaration;
~~~~;
~~~~;
if (declaration_iter != map2.end())
{
variable_declaration_position = declaration_iter;
}
How about declaration_iter->first?
--
Mats
You might want to post the smallest and simplest compilable program that demonstrates the problem. Speaking of which, you did not state what exactly was the problem.
Ok lets say it this way :Quote:
Originally Posted by laserlight
i have a map which is called declaration , this map holds variables and their value
i have another map that has the variable name , i use that map , to retrieve the name, and then search the name in declaration map, then when it is found , i wan to retrieve both the variable value and the index inwhich the variable was stored at!
look :
Code:
map<int,string>::iterator declaration_iter;
map<int,string> declaration;
map(value + name)
____________________________________________
____________________________________________
index | | |
______________|______0_______|_______1______|
| | |
Declaration | (5) Num | (0) sum |
______________|______________|______________|
actually iterator is indicating the index( it is index used to point to different pairs used in a map, so i want this index! to be stored somewhere else so that i can use some calculations on it) !
tanx Mats, but i think this will give me the first element of the pair stored in the map, meaning if i have declaration[5] = "sum", this will give me , 5! but i want the index which this pair is located in the map! and cuz iterator is referring to there i want to use that iter!Quote:
Originally Posted by matsp
You know, it would be much easier if you just showed the code, or at least told us the types of certain variables in your example.
As it stands, matsp is probably correct. variable_declaration_position is probably an int, so you want to write:
EDIT:Code:variable_declaration_position = declaration_iter->first;
What you do mean by "index which this pair is located in the map"? A map is an associative container; it has no concept of indices as with sequential containers.Quote:
Originally Posted by Masterx
And even if you find out where it is right now, if you add/remove an element it may well have moved.Quote:
Originally Posted by laserlight
You will probably have to explain what you intend to do with such an information, should you be able to get it...
--
Mats
sorry for the vague explanation ,Quote:
Originally Posted by laserlight
but before that would you tell me what is the function of an iterator in a typical map?
i say , its used to indicate a specific pair stored in the container,
i mean a map is actually a container that can hold pair of variables like " name and phone number " (phone[Alex]=12545678 ) so , when there are more than one pair of data ( information such as above) in order to access on of those pairs , you actually use the iterator ! and find what you want!
in my case after find a typical element( lets say varibale) i want to know how many iterations are being done to reach this element .
there is no way those maps get changed ! and here is the whole function which i use to search and get the information i want ( here iterator ).Quote:
Originally Posted by matsp
Code:#include <map>
#include <string>
#include <cstring>
#include <cctype>
#include <iostream>
#include <sstream>
#include <bitset>
using namespace std;
template<typename K1, typename V1>
class matchSecond1
{
public:
matchSecond1(const V1& value) : value(value) {}
bool operator()(const std::pair<K1,V1>& element) const
{
return element.second == value;
}
private:
V1 value;
};
///search in declaration
using namespace std;
int Get_Variable_info(const map<int,string>& map1, const map<int,string>& map2, string token)
{
int variable_declaration_position =0;
string typestr;
map<int,string>::const_iterator iter = find_if(map1.begin(), map1.end(), matchSecond1<int,string>(token));
if (iter != map1.end())
{
typestr = "Label";
variable_declaration_position = 0;//dont need this
}
//else if you couldnt find it in label,search the token in declaration until you find it
map<int,string>::const_iterator iter2 = find_if(map2.begin(), map2.end(), matchSecond1<int,string>(token));
if (iter2 != map2.end())
{
variable_declaration_position = iter2;
}
return variable_declaration_position;
}//end of function
It depends. You could use an iterator to iterate over the entire map, or perhaps the iterator is returned by a function.Quote:
Originally Posted by Masterx
You can do that with an iterator, but you can also do that with a key, since keys in a std::map are unique.Quote:
Originally Posted by Masterx
Yes, using an iterator would be one way, the other being to use operator[].Quote:
Originally Posted by Masterx
There is no way to determine that, though you can estimate it as log_2(n), where n is the number of elements in the map.Quote:
Originally Posted by Masterx
EDIT:
Must you really find the element based on the mapped object? The typical use of a map is to find the value based on the key.
Purpose of an iterator is the same as any other iterator: To walk through the contents of a container class. It is a pseudo-pointer into the stored data - it is not really a pointer, but it behaves like one (sort of).
I still don't quite follow what you want to do.
If you want to know how many iterations you need to iterate to get to a particular location, then I suggest you just add a counter in your loop.
If you want something else, then you have to explain what you want to achieve a bit better.
--
Mats
unfortunately i happened to do this, actually i used the maps in their usual wayQuote:
Originally Posted by laserlight
but an error turned up in my project and the only way to get rid of it is to find out the index of the variable in declaration map which tells me where exactly in the program source code it is written.
to tell you the truth, im trying to place the variable in its true address in memory!(emulated memory) and for that i must know the order the variables are declared (which one is first , which one is second and etc) and using this
i can be able to find out and calculate the exact line number they are being declared and then place them in memory
at first i thought , well i have the declaration map, and simply when i want to specify which came first and which came afterwards, i just look at the iterator!
i though the elements is map( variables and their value) are sorted secquentialy so that i can just know which one is come firs!
or at least using the map iterator, would let me know which one came first and tell me the place of the element in map!
it seems i was wrong! and well i dont know how to go about it!
as dear Mats told me , i tried this but its not workinG! i just get 0!
any help!?
Code:#include <map>
#include <string>
#include <iostream>
using namespace std;
//map searcher
template<typename K1, typename V1>
class matchSecond1
{
public:
matchSecond1(const V1& value) : value(value) {}
bool operator()(const std::pair<K1,V1>& element) const
{
return element.second == value;
}
private:
V1 value;
};
int GET(const map<int,string>& map1, const map<int,string>& map2, string token);
int main()
{
map<int,string>::iterator lab_it;
map<int,string> LABEL; //is used to store/save the list of labels used so far with regards of the current line number
map<int,string>::iterator dec_it; //variable[value]=variable name
map<int,string> declaration;//variable name and its value
LABEL[65] = "label1";
LABEL[12] = "label2";
LABEL[987] = "label3";
declaration[5] = "number1";
declaration[96] = "number12";
declaration[65] = "number13";
declaration[36] = "number14";
declaration[15] = "number15";
declaration[46] = "number16";
declaration[55] = "number17";
declaration[54] = "number18";
int answer = GET(LABEL,declaration,"number14");
cout<<"\nindex is "<<answer;
return 0;
}
int GET(const map<int,string>& map1, const map<int,string>& map2, string token)
{
int variable_declaration_position =0;
string typestr;
map<int,string>::const_iterator iter = find_if(map1.begin(), map1.end(), matchSecond1<int,string>(token));
//till you havent found the token in label, go on .
if (iter != map1.end())
{
typestr = "Label";
variable_declaration_position = 0;//dont need this
}
map<int,string>::const_iterator iter2 = find_if(map2.begin(), map2.end(), matchSecond1<int,string>(token));
int counter =0;
if (iter2 != map2.end())
{
typestr = "found";
variable_declaration_position = counter++;
}//end of declaraion if
return variable_declaration_position;
}//end of function
And what else besides 0 do you expect it to return?Code:int variable_declaration_position =0;
//...
int counter =0;
if (iter2 != map2.end())
{
typestr = "found";
variable_declaration_position = counter++;
}//end of declaraion if
return variable_declaration_position;
I still suspect that the whole approach must be wrong if you search in a map like that.
i think i found another solution for the problem.Quote:
Originally Posted by anon
by the way tanx, so whats your suggestion in this case?
i came up wrtting this code , i used another map to store all of the statements ( lines) entered by user with its line number, now i can finally get rid of that stupid map element index!
anyways , when i try to compile this i get an error, i dont know why! maybe because i m trying to use a function im getting it !( proly im not doing it right)
the error im getting is :
would anyone help me correct this ?Quote:
error: no match for 'operator=' in 'iter = (+InputtedLines)->std::map<_Key, _Tp, _Compare, _Alloc>::begin [with _Key = int, _Tp = std::string, _Compare = std::less<int>, _Alloc = std::allocator<std::pair<const int, std::string> >]()'|
Code:#include <map>
#include <string>
#include <iostream>
using namespace std;
int main()
{
~~;
~~;
index = variable_location = Get_Variable_Location(StringCollector,tokenstr);
return 0;
}
Code://in the name of God
#include <map>
#include <string>
#include <iostream>
using namespace std;
int Get_Variable_Location(const map<int,string>& InputtedLines, string token)
{
int index = 0;
map<int,string>::iterator iter;
iter = InputtedLines.begin();
while ( iter != InputtedLines.end() )
{
if ( (*iter).second == token )
{
index = (*iter).first;
}
else
{
iter++;
}
}
return index;
}//end of function
What kind of error?
I don't see you including the header with the declaration of that function.
Error message:Quote:
Originally Posted by anon
( this indicates this line:Code:error: no match for 'operator=' in 'iter = (+InputtedLines)->std::map<_Key, _Tp, _Compare, _Alloc>::begin [with _Key = int, _Tp = std::string, _Compare = std::less<int>, _Alloc = std::allocator<std::pair<const int, std::string> >]()'|
)Quote:
iter = InputtedLines.begin();
and about declaration! its just pseudo main! i just forgot to add that!
the actual function is placed in a separate headerfile
so in main i have
there is a problem with function! what could be the cause?Code:#include <iostream>
#include "Get_variable_index.h"
int main()
{
~~;
~~;
index = variable_location = Get_Variable_Location(StringCollector,tokenstr);
return 0;
}
The map is passed as const reference, and so the iterator should be
Code:map<int,string>::const_iterator iter;
thank you dear anon , thank you very much. by the way why is it obligatory to use const with iterator! should it not be optional in this case? i mean i cant figure it why the iterator must be declared as const as the map!Quote:
Originally Posted by anon
anyone can help me get this one? why do we have to declare a const iterator when we are dealing with a const map!? why is it obligatory ?
The difference between const_iterator and iterator is that the first allows only read access, which makes sense if the map is const and not meant to be modified.
When the map instance is const, begin() and end() methods return a const_iterator. If the container is non-const, these methods return iterator. iterator can be implicitly converted to const_iterator (you can always assign the result of begin() and end() to a const_iterator) but not the other way round.