Like most everybody, I indent my code. I use tabs for that. Tabs are convenient, but they are set to different widths for different systems by default, and that can be annoying. For sets of nested curly brackets three or four levels deep, which between loops, if/else conditions, and function definition syntax can easily happen, wide tabs can make your lines run over the width of the screen.

Notepad++ can fix that. In the "Settings" menu there's a "Preferences" item, and in it there's an "Edit Components" tab. In it there's a tab box, which gives you exactly the two options you need to solve this problem once and for all: the first is the number of spaces equivalent to a tab's width. The default is 4, which is also the preferred width of at least one widely used coding standard -- the Zend Framework, for PHP. The other option is a cool little check-box that reads "Replace by space". 

You check that box, and your friends who like indented code but hate tabs will love you.

The advantage of using the class string, so far, seems to be that it saves the work of array length accounting. The global constant NAMELEN is gone. Here's the new version of the code in the previous post:

// An example of using structs: reading data from a list of student 
// names and grades, saved as a .csv file, into an array. In this 
// example the file is saved as .csv, but the delimiter between 
// name and grade is the tab character, '\t'. Also, the first row 
// of the .csv file has column names -- "name" and "grade" -- so
// I want to skip it.
//-------------------------------------------------------------------

#include <iostream>
#include <fstream>
#include <string>
using namespace std;

const int LISTMAX=1000; // maximum number of students

struct Student {
  string name;
  float grade;
};

void readList(string infilename);
// Arguments:
//   file name, passed as a class string.
// Side effects:
//   open file stream, function call of fillUp.

void fillUp(ifstream& inList, Student wholeClass[],
int LISTMAX, int& stCount);
// Preconditions: global constant LISTMAX is the dimension of
//   the wholeClass[] array of Student structs.
// Postconditions:
//   (1) grades[0] through grades[stCount-1] filled with positive
//   real numbers read from input file stream open by readList.
//   (2) names[0] through names[stCount-1] are class string objects.
//-------------------------------------------------------------------

int main()
{
  string infilename="example_list.csv";
  readList(infilename);
  return 0;
}
//-------------------------------------------------------------------

// open input, file stream call fillStudent to fill array named
// wholeClass[LISTMAX] with Student structs
void readList(string infilename)
{
  ifstream inList(infilename.c_str( ));
  if (inList.fail()) {
    cout << "Input file opening failed.\n";
    exit(1);
  }
  else {
    Student wholeClass[LISTMAX]; // initialize array of structs
    int stCount=0; // number of valid elements starts at zero
    fillUp(inList, wholeClass, LISTMAX, stCount);
    cout << "\nGrade Roll Report" << endl;
    cout << "There were " << stCount << " students." << endl;
  }
  inList.close();
}

// fill wholeClass[LISTMAX] using data from infilename.
void fillUp(ifstream& inList, Student wholeClass[],
int LISTMAX, int& stCount)
{
  string dummy; // container for garbage.
  getline(inList,dummy,'\n'); // toss the entire first row.
  for(int i=0; i<LISTMAX; i++) {
    while (stCount<LISTMAX &&
           getline(inList, wholeClass[i].name,'\t')) {
      if(inList >> wholeClass[i].grade) {
        getline(inList,dummy,'\n');
        cout << "Name: " << wholeClass[i].name
             << " Grade: "<< wholeClass[i].grade << endl;
      }
      stCount++;
    }
  }
}
//-------------------------------------------------------------------

So I'm back in school, continuing the course I started last fall. We're using the same textbook, and the quotes at the beginning of the sections are only getting better. Here's the one on testing and debugging your functions: "I beheld the wretch -- the miserable monster whom I had created." Can you tell it's from Frankenstein?

OK, so maybe the code above is a little over-commented for your taste, but they were very clear about how they wanted your programs in this course. There were points taken off for not commenting variables when you declared them, and the punishment for not commenting function prototypes was just a little short of a public flagellation.

I like this way of doing business. I learned my programming in the haphazard way that all social scientists do -- you write code in your statistical programming environment of choice, see to it that it does the job, and that's that. This, of course, bit me back numerous times over the years, so I did eventually come to appreciate the true cost of sloppiness. In computer science you don't get a chance at that sort of revelation, because bad practice is nipped in the bud. The textbook quoted Oscar Wilde before the first chapter was over: "In matters of grave importance,  style, not sincerity, is the vital thing."

Compile a .cpp source file in the GNU debugger:

g++ -g -Wall -o mysourcefile.out mysourcefile.cpp

Before starting gdb, make sure you're in the same directory as the executable just compiled above. Then call gdb:

add GNU

Then start the gdb debugger:

gdb mysourcefile.out

Things you can do here:

1) Set a breakpoint at a given function (e.g., main):

break main

2) Set a breakpoint at a given line (e.g., line 12):

break mysourcefile.cpp:12

3) Set a watch point at a given expression:

watch x>y

4) Find the type of that expression:

whatis x>y

5) OK, that was trivial, clearly it's boolean. More usefully, you can find its value so far (true or false in the GNU C++ compiler, 1 or 0 in others, I guess) with

print x>y

6) Step into the program (execute a certain number of lines after the debugger stopped at your breakpoint):

step <number of lines>

If you set a break point, run will execute the code up to then, at which point you can choose next to move on to the next line, or continue, for the thing to run until it exits normally or an error is found.