IRC Volunteer Work

Here is an example of my "work" volunteering as a helper on Freenode's ##C++ IRC channel.

In this instance I refactored a visitor's code so that it would be:

more legible
comments are on their own lines;
more robust
the code is now cross-platform;
more understandable
the comments are more meaningful than simply more verbose versions of the code, and actually explain what we intend to accomplish from the code;
easier to maintain
thanks to the use of constants rather than sprinkling literals throughout the code.

Original code:

#include <cstdlib> // include stdlib.h headers in order to use rand
#include <ctime> // include time.h headers in order to use time as the seed for rand
#include <iostream>
using namespace std;
 
int dieroll(){ // defines the dieroll() function
	return rand()%6; // returns a random number from 0 to 5
}
 
int main (){
	int counter[6]={0,0,0,0,0,0}; // defines array 'counter' to be used and initializes each index with a value of 0
	srand (time(NULL)); // creates a seed for the random number using the current clock time
	for (int i=0;i<5000;i++){ // starts the for-loop that will simulate the 5000 die rolls
		counter[dieroll()]++; // adds 1 to the counter array using the return of dieroll() as the index
	}
	cout << "A die was rolled 5000 times.\n";
	for (int i=0;i<6;i++){ // for-loop used to output the die roll results.
		cout << "The die landed on " << (i+1) << " " << counter[i] << " times.\n"; // outputs results of counter array using i as the index
	}
	system("pause"); // pauses for the user to view output information before exiting the program
	return 0;
}

My suggested, improved code:

#include <cstdlib> // for rand()
#include <ctime>   // for time (used as prng seed)
#include <limits>  // for pause()
#include <iostream>
using namespace std;
 
static const unsigned int DIESIDES = 6;
static const unsigned int NUMROLLS = 5000;
 
/**
 * Simulates a die roll.
 * @return random number from 0 to (DIESIDES-1)
 */
int dieroll() {
   return rand() % (DIESIDES - 1);
}
 
/**
 * System-agnostic "wait for enter".
 */
void pause() {
   cin.clear();
   for (char c; cin.readsome(&c, 1); );
   cin.ignore(numeric_limits<streamsize>::max(), '\n');
}
 
/**
 * Program entry point.
 */
int main () {
 
   // Create an array of counters, one for each possible die roll result
   int counter[DIESIDES] = {0};
 
   // Seed random number generator using current time.
   srand(time(NULL));
 
   // Simulate die rolls, keeping a tally of how many times each value comes up
   for (int i = 0; i < NUMROLLS; i++) {
      int rollResult = dieroll();
      counter[rollResult]++;
   }
 
   cout << "A die was rolled " << NUMROLLS << " times." << endl;
 
   // Output tally of result frequency for each of the possible die roll values
   for (int i = 0; i < DIESIDES; i++) {
      cout << "The die landed on " << (i+1) << " " << counter[i] << " times." << endl;
   }
 
   // Pause for the user to view output information before exit, in case console is not persistent
   pause();
 
   return EXIT_SUCCESS;
}

For another request:

#include <exception>

class RoundRobinIterator_NoElementsException : public std::exception {
	virtual const char* what() const throw() {
		return "Container is empty";
	}
};

/**
 * Round Robin collections iterator.
 * 
 * Functions partially like a typical linear iterator but will
 * wrap-around when the end of the represented collection is reached.
 * It also employs somewhat different semantics, in that a local copy
 * of the container is made rather than iterating over some externally-
 * stored collection. This has the side-effect that the iterator cannot
 * be invalidated from the calling scope.
 * 
 * AUTHOR: Tomalak Geret'kal <http://kera.name>
 * REVISION: 0.3
 * DATE: 16th February 2009
 */
template <class Container>
class RoundRobinIterator {
	private:
		Container container;
		typename Container::iterator it;
		
	public:
		RoundRobinIterator(const Container& container) :
		  container(container), it(this->container.begin()) {
		};
		
		typename Container::value_type& operator*() {
			if (!container.size())
				throw RoundRobinIterator_NoElementsException();
				
			else if (it == container.end())
				it = container.begin();
			
			return *(it++);
		}
};

/* Testcase */

#include <iostream>
#include <vector>

/**
 * Testcase for Round Robin Iterator.
 * 
 * OUTPUT:
 * 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4
 * Container is empty
 */
int main() { 
	std::vector<int> v, u;
	for (int i = 0; i < 5; i++)
		v.push_back(i);
	
	try {
		// Attempts to show elements from [populated] vector v, 20 times
		RoundRobinIterator<std::vector<int> > it_v(v);
		for (int i = 0; i < 20; i++) {
			std::cout << *it_v << " ";
		}
		
		std::cout << std::endl;
		
		// Attempts to show elements from [empty] vector u, 20 times
		RoundRobinIterator<std::vector<int> > it_u(u);
		for (int i = 0; i < 20; i++) {
			std::cout << *it_u << " ";
		}
	}
	catch (std::exception& e) {
		std::cout << e.what();
	}
}