Thank you, thank you, thank you, Joe.
Now it's beginning to make sense to me.
I will do some experimenting with it now.
On 4/1/2011 2:34 PM, Joseph M. Newcomer wrote:
std::map is a mapping between two objects of the pair specified in the template. It works
like this:
you declare a
std::map<T1, T2> something;
T1 is the "key type" and is some type for which operator< is defined
T2 is the "value type" and is some type you want to associate with the key
If you do
typedef std::map<T1, T2> MYMAP;
then the MYMAP type represents an instance of the std::map class for types T1->T2 (T1 maps
to T2). For your case, you would do something like
typedef std::map<CString, CString> CIP3Attributes;
or
typdef std::map<CStringA, CStringA> CIP3Attributes;
and the second parameter to ParseAttributes would be
CIP3Attributes& attributes
=======
Fundamental to the STL container classes is the concept of "iterator", which is a
reference into the object set defined by the collection. Iterators are really, really
important in STL. Think of them as the equivalent of the POSITION concept in MFC
collections, but more cleanly done (even if the syntax is weird)
So you can write
MYMAP things;
T1 key;
T2 value;
things.insert(std::pair<T1, T2>(key, value));
and you can look them up by
MYMAP::iterator iter = things.find(key);
if(iter == things.end())
{ /* not found */
... failed to find it
} /* not found */
else
{ /* found it */
// iter->first will be the key
// iter->second will be the value
}.* found it */
so if you do
things.insert(name, value); // the variables I used in my example, I think
then you can do things like
MYMAP::iterator iter = things.find("CIP3Whatever");
(or _T("CIP3Whatever") if you are doing this Unicode-aware and your key is CString, not
CStringA)
and you will find the value in
iter->second
so if you find it and do
_atoi(iter->second)
you will get the number converted to a string (or 0 if the value was not actually a valid
number, a string like "Hello world" or something like that), assuming your T2 was CStringA
and not CString (you would use _ttoi if it was CString)
The syntax is a bit bizarre, but the performance of maps is extremely high compared to
most alternatives (unordered_map of C++0x is faster, but otherwise similar), It is really
worth taking the time to learn about std::map (and std::unordered_map in C++0x). Study
examples on the Web (that's how I learned) or you can download the source of my PowerPoint
indexing program, which uses std::map all over the place.
Note that all those keywords you use should not be literal strings in your code, but
static const values so you can use them in multiple places without copy/paste, and you can
do things like
static const CStringA CIP3Whatever("CIP3Whatever");
or
#define CIP3Keyword(x) static const CStringA x(#x)
so using this macro you can write
CIP3Keyword(CIP3Whatever);
CIP3Keyword(CIP3Something);
CIP3Keyword(CIP3OtherThing);
this allows you to ask for things like CIP3Whatever.GetLength(), instead of hardwiring
weird numbers like "22" into your code
joe
On Fri, 01 Apr 2011 08:10:46 -0400, Ed<me@right.her> wrote:
I see that ParseAttributes() function takes two parameters.
If one is buffer what is the other (std::map<CStringA& CStringA) ?
Until now I never heard of std::map so I lookes it up and it seems quite
confusing.
On 3/31/2011 8:37 PM, Joseph M. Newcomer wrote:
See below...
On Thu, 31 Mar 2011 13:14:44 -0400, Ed<me@right.her> wrote:
// This is a bit over my head as I was originally a C programmer and
// I am still way behind on Visual C++
****
Actually, except for std::map, everything below is pure "C-style" code.
****
// It's gonna take me a while to get my head into understanding this.
// how do I get buffer(read CIP file) into this parse routine?
// how do I retrieve the parameters?
****
Note the first parameter. That is the pointer to the buffer you read in.
You retrive the parameters from the std::map. My error, that should have been a
reference:
std::map<CStringA, CStringA> & attributes
****
char * ParseAttributes(char * start, std::map<CStringA& CStringA>
attributes)
{
while(true)
{ /* scan attributes */
if(strncmp(start, CIP3PreviewImage, strlen(CIP3PreviewImage)) == 0)
{ /* at image */
start += strlen(CIP3PreviewImage);
while(*start != '\n')
start++;
return start;
} /* at image */
while(*start != '/')
{ /* scan to next dictionary entry */
start++;
} /* scan to next dictionary entry */
// /Name value def
// ^
// | We are here
char * begin = ++start;
while(*start != ' ')
{ /* scan past keyword */
start++;
} /* scan past keyword */
// /Name value def
// ^ ^
// | |
// begin start
CStringA name(begin, start-begin));
while(isspace(*start)) // skip past whitespace
start++;
char * def = strstr(start, "def");
if(def == NULL)
{ /* def not found */
//... deal with ill-formed expression
return NULL; // or value of your choice, or throw exception
} /* def not found */
def--;
while(isspace(*def))
--def;
CStringA val(start, def-start + 1);
attributes.insert(std::pair(name, val));
while(*def != '\n') // now skip to the EOL
def++;
start = ++def;
} /* scan attributes */
} // ParseAttibutes
Joseph M. Newcomer [MVP]
email: newcomer@flounder.com
Web: http://www.flounder.com
MVP Tips: http://www.flounder.com/mvp_tips.htm
Joseph M. Newcomer [MVP]
email: newcomer@flounder.com
Web: http://www.flounder.com
MVP Tips: http://www.flounder.com/mvp_tips.htm