Question

I’ve got a program that populates a STL linked list with structs, and I’m trying to pass struct members from a node on the list (one that I’m currently on via an iterator). One of the things I’m trying to accomplish is a function that will calculate a running average. Rather than storing the count and total in the struct, and then computing the average upon output, I’d like to store the count and average in the struct, thus discarding my quantity value after the average has been recalculated. My struct looks like this:

struct mystruct 
{
    string item;
    long avg;
    short count;
} data;

These structs are stored in a list, with an iterator, it, that allows me to move through the list. Would this be the proper way to call my average function, provided I’ve traversed through the list and it equals the node who’s data I want to calculate the average with?

// prior to running the code below, the `count` and `avg` members for the 
// struct at iterator location `it` are both 1 and 100 respectively

long qty = 50;
calc_average(it->count, it->avg, qty);

cout << "The current count is " << it->count << endl; 
  // Outputs 'The current count is 2'
cout << "The current average is " << it->avg << endl; 
  // Outputs 'The current average is 75'


void calc_average(short &count, long &avg, long quant)
{
    avg = ( (avg * count) + quant ) / (count + 1);
    count++;
}

Does this seem correct? I’m trying to implement this using the STL list, but it seems more confusing than just implementing my own linked list class. I think I’m just getting confused with the structure and how the iterators actually work, and what/how things are actually being passed around. Coding is still fairly new to me so much of this is a learning process…

Thanks!

Answer 1

Assuming that X is the type of the objects in the list, then you can do something like this:

void DoSomething(X& object) {
  object.count, object.avg;
}
void DoSomethingElse(int& count, int& average) {
  ...
}

int main() {
   ...
   for(std::list<X>::iterator it=myList.begin(), end=myList.end(); it != end; ++it) {
     DoSomething(*it); // how I'd do it
     DoSomethingElse(it->count, it->avg); // Equally valid way that you did it
   }
   ...
}

Just remember:

• container.begin() is the a pointer to the first element
• container.end() is a pointer to one-past-the-last element
• *it is a reference to the pointed-to element
• it != container.end() is how you tell if you are at the end
• it->x is a member of the pointed-to element
• removing an object from a container might invalidate outstanding iterators, depending upon several factors.
• ++it is probably more efficient than it++

---

EDIT: OP asks:

I’m not iterating through the list and running calc_average on every single node, but rather iterating through the list looking for a specific item value. Once I find the one of interest, I’m calling the calc_average function on that specific node. I just don’t need to have the for loop. Instead I would arrive at my desired iterator, and pass that via *it to void DoSomething ?

I think you understand how it works now. You’d have some code to search for the indicated node, and then some other code to invoke your function:

   std::list<X>::iterator it, end;
   for(it=myList.begin(), end=myList.end(); it != end; ++it) {
     // Look for the special node:
     if( it->magicValue == 42 ) {
       // We found it!
       break;
     }
   }

    // Either it is equal to end (boo!) or it points to the special node (yay!)
   if( it == end ) {
      std::cerr << "Could not find special node!\n";
   }
   if( it != end ) {
      DoSomething(*it);
   }