Figuring Out What's Going on This Code (Recursive Descent Case Study) - c++

Question

I am reading a Data Structures and Algorithms book and there is a case study on recursion, specifically a parser that uses recursive descent. I'm a bit new to C++ (I'm learning it on the side and as I go with Stanley B. Lippman's C++ Primer 5th edition).
I'm a bit stuck on code and am trying to make sense of it. Is what I've written at the bottom (bulleted points) accurate descriptions of what is happening in the functions? I would post the header, but it's a bit too long, you can probably find it online if you search "Data Structures
and Algorithms in C++ by Adam Drozdek - interpreter.h".
double Statement::findValue(char* id) {
IdNode tmp(id);
list<IdNode>::iterator i = find(idList.begin(), idList.end(), tmp);
if (i != idList.end())
return i->value;
else
issueError("Unknown variable");
return 0;
}
void Statement::processNode(char* id, double e) {
IdNode tmp(id, e);
list<IdNode>::iterator i = find(idList.begin(), idList.end(), tmp);
if (i != idList.end())
i->value = e;
else
idList.push_front(tmp);
}
findValue()
Looks for a value for a certain variable
Uses an iterator i so that it can traverse the list
Looks for tmp using find()
If i doesn't equal the value at the end of the list, return it
Other wise, the variable cannot be found
processNode()
Processes nodes by using an iterator i
Looks for a variable that matches tmp
Finds the variable and sets it's value to the value of e
Other wise, store variable on to idList to be evaluated later

Answer 1

Define a function that accepts a pointer to char (likely it's an array) and returns a double:
double Statement::findValue(char* id) {
Create a temporary (will die at 'return') of type IdNode based on that pointer:
IdNode tmp(id);
Use a (std:: I guess, but it could be any function with the same features) function that looks for tmp inside the container idList. The result is an interator i, which must be of the same type of that one used by the container:
list<IdNode>::iterator i = find(idList.begin(), idList.end(), tmp);
Check if something is found. idList.end() means "one past end", beyond the last item in the container:
if (i != idList.end())
Return the member value (which is part of IdNode) for the item found. If value is not a double then convert to it.
return i->value;
Otherwise, call issueError function.
else
issueError("Unknown variable");
Exit function, returning a double with value = 0:
return 0;
}
Same, but: this function accepts two parameters and returns nothing:
void Statement::processNode(char* id, double e) {
Same, but: IdNode constructor uses two parameters:
IdNode tmp(id, e);
Same
list<IdNode>::iterator i = find(idList.begin(), idList.end(), tmp);
Same
if (i != idList.end())
Now, modify the item found. Just update value member:
i->value = e;
Otherwise, add tmp, insert it at the very begining of idList container.
else
idList.push_front(tmp);
Exit function:
}

Answer 2

Your understanding is mostly right. I'll describe it statement by statement
in somewhat more precise terms.
double Statement::findValue(char* id) {
IdNode tmp(id);
This constructs a variable named tmp using the string passed in. (Well, I presume id is a string. In C, it's common to pass a pointer to the beginning of a zero-terminated array of characters when you want to pass a string. In C++, the same thing was common, but it's becoming less common now that we have better string and range types in the standard library. But not every char * is a string. It might just be a pointer to a single character. Here though, the context strong suggests it's a string.)
list<IdNode>::iterator i = find(idList.begin(), idList.end(), tmp);
Uses the std::find algorithm to search the range of elements from the beginning of the idList to the end for an element that equals tmp.
Note the idList.end() is an iterator that indicates the actual end of the list rather than the last item in the list. You can think of it as one element beyond the last element in the list. Iterator ranges (and array indices) in C and C++ are typically inclusive of the first value and exclusive of the second. So find will start with the first element and continue up to (but not through) the end of the list.
It's not shown here, but I assume there's an overload for operator==(const idNode &, const idNode &) that returns true if the names of the two idNodes match, regardless of whether the value fields match.
If there's no match in the range, then std::find is going to return the end iterator. If there is a match, it's going to return an iterator that references the matching element. So ...
if (i != idList.end())
return i->value;
else
issueError("Unknown variable");
This returns the value field of the match (if there is one) or it calls issueError if there isn't.
return 0;
}
In the latter case, assuming issueError returns and doesn't terminate the program or throw an exception, the function will return a value of 0 (which, because the return type is a double, will be implicitly converted to 0.0).
processNode is nearly identical except that it sets the value in the found node rather than returning it.