Accelerated C++ 5 Using sequential containers and analyzing strings

The<cctype>header provides useful functions for manipulating charactor data:

isspace(c)
isalpha(c)
isdigit(c)
isalnum(c)
ispunct(c) // punctuation charactor
isupper(c)
islower(c)
toupper(c)
tolower(c)

I.

split.h

#ifndef GUARD_split_h
#define GUARD_split_h

#include <vector>
#include <string>

std::vector<std::string> split(const std::string&);

#endif

split.cpp

//source file split-related
#include<cctype>
#include "split.h"

using std::string; using std::vector;

vector<string> split(const string& s) {

vector<string> ret;
typedef vector<string>::size_type s_sz;
s_sz i = 0;
s_sz j = 0;

while (i != s.size()) {
while (i != s.size() && isspace(s[i]))
++i;
j = i;
while (j != s.size() && !isspace(s[j]))
++j;
if (i != j) {
ret.push_back(s.substr(i,j - i));
i = j;
}
}
return ret;
}

I.

Student_info.h

Student_info.cpp

grade.h(median.h)

grade.cpp(median.cpp)

see Note 4

extract_fails.h

#ifndef GUARD_extract_fails_h
#define GUARD_extract_fails_h

#include <list>
#include "Student_info.h"

bool fgrade(const Student_info&);
bool pgrade(const Student_info&);

std::list<Student_info> extract_fails(std::list<Student_info>&);
#endif

extract_fails.cpp

#include "grade.h"
#include "extract_fails.h"
#include "fopgrade.h"
#include "Student_info.h"

using std::list;

bool fgrade(const Student_info& s) {
return grade(s) < 60;
}

bool pgrade(const Student_info& s) {
return grade(s) >= 60;
}

list<Student_info> extract_fails(list<Student_info>& students) {
list<Student_info> fails;
list<Stu
bc03
dent_info>::iterator iter = students.begin();

while(iter != students.end()){
if (fgrade(*iter)) {
fails.push_back(*iter);
iter = students.erase(iter);
} else {
++iter;
}
}
return fails;
}

main.cpp

#include <algorithm>
#include <iomanip>  // setprecision
#include <ios>      // streamsize
#include <iostream>
#include <stdexcept>
#include <string>
#include "Student_info.h"
#include "grade.h"
#include "extract_fails.h"

using std::list;            using std::sort;    using std::string;  using std::endl;
using std::domain_error;    using std::cin;     using std::cout;    using std::max;
using std::streamsize;      using std::setprecision; using std::list;
using std::setw;

int main(){
list<Student_info> students;
Student_info record;
list<Student_info> fail_stus;
string::size_type maxlen = 0;

// read and store all the students' data
// Invariant: students contains all the student records read so far
//            maxlen contains the length of the longest name in students
while (read(cin, record)) {
// find length of longest name
maxlen = max(maxlen, record.name.size());
students.push_back(record);
}

// alphabetize the student records
sort(students.begin(), students.end(), compare);

// write the names and grades
for (list<Student_info>::iterator it = students.begin(); it != students.end(); ++it){

// write the name, padded on the right to maxlen + 1 characters
record = (*it);
cout << record.name << string(maxlen + 1 - record.name.size(), ' ');

// compute and write the grade
try {
double final_grade = grade(record);
streamsize prec = cout.precision();
cout << setprecision(3) << final_grade << setprecision(prec);
} catch (domain_error e) {
cout << e.what();
}
cout << endl;
}

cout << "print the students who fail the exam!" << endl;
fail_stus = extract_fails(students);
for (list<Student_info>::iterator it = fail_stus.begin(); it != fail_stus.end(); ++it) {
record = *it;
cout << record.name << string(maxlen + 1 - record.name.size(), ' ');
try {
streamsize prec = cout.precision();
cout << setw(4) << setprecision(3) << grade(record) << setprecision(prec);
} catch (domain_error e) {
cout << e.what();
}
cout << endl;
}
return 0;
}