Accelerated C++ Exercise 4-0(组织程序和数据）

#ifndef GUARD_median_h 
#define GUARD_median_h
#include<vector>
//median.h
double median(std::vector<double>);
#endif

// source file for the `median' function   
#include <algorithm>    // to get the declaration of `sort'   
#include <stdexcept>    // to get the declaration of `domain_error'   
#include <vector>       // to get the declaration of `vector'   
   
using std::domain_error;   using std::sort;   using std::vector;   
   
#include "median.h"   
   
// compute the median of a `vector<double>'   
// note that calling this function copies the entire argument `vector'   
double median(vector<double> vec)   
{   
    typedef vector<double>::size_type vec_sz;   
   
    vec_sz size = vec.size();   
    if (size == 0)   
        throw domain_error("median of an empty vector");   
   
    sort(vec.begin(), vec.end());   
   
    vec_sz mid = size/2;   
   
    return size % 2 == 0 ? (vec[mid] + vec[mid-1]) / 2 : vec[mid];   
} 

#ifndef GUARD_grade_h 
#define GUARD_grade_h 
 
// `grade.h' 
#include <vector> 
#include "Student_info.h" 
 
double grade(double, double, double); 
double grade(double, double, const std::vector<double>&); 
double grade(const Student_info&); 
 
#endif

#include <stdexcept>   
#include <vector>   
#include "grade.h"   
#include "median.h"   
#include "Student_info.h"   
   
using std::domain_error;  using std::vector;   
   
   
// compute a student's overall grade from midterm and final exam grades and homework grade   
double grade(double midterm, double final, double homework)   
{   
    return 0.2 * midterm + 0.4 * final + 0.4 * homework;   
}   
   
// compute a student's overall grade from midterm and final exam grades   
// and vector of homework grades.   
// this function does not copy its argument, because `median' does so for us.   
double grade(double midterm, double final, const vector<double>& hw)   
{   
    if (hw.size() == 0)   
        throw domain_error("student has done no homework");   
    return grade(midterm, final, median(hw));   
}   
   
double grade(const Student_info& s)   
{   
    return grade(s.midterm, s.final, s.homework);   
}   
  

#ifndef GUARD_Student_info 
#define GUARD_Student_info 
 
// `Student_info.h' header file 
#include <iostream> 
#include <string> 
#include <vector> 
 
struct Student_info { 
	std::string name; 
	double midterm, final; 
	std::vector<double> homework; 
}; 
 
bool compare(const Student_info&, const Student_info&); 
std::istream& read(std::istream&, Student_info&); 
std::istream& read_hw(std::istream&, std::vector<double>&); 
#endif

// source file for `Student_info'-related functions   
#include "Student_info.h"   
   
using std::istream;  using std::vector;   
   
bool compare(const Student_info& x, const Student_info& y)   
{   
    return x.name < y.name;   
}   
   
istream& read(istream& is, Student_info& s)   
{   
    // read and store the student's name and midterm and final exam grades   
    is >> s.name >> s.midterm >> s.final;   
   
    read_hw(is, s.homework);  // read and store all the student's homework grades   
    return is;   
}   
   
// read homework grades from an input stream into a `vector<double>'   
istream& read_hw(istream& in, vector<double>& hw)   
{   
    if (in) {   
        // get rid of previous contents   
        hw.clear();   
   
        // read homework grades   
        double x;   
        while (in >> x)   
            hw.push_back(x);   
   
        // clear the stream so that input will work for the next student   
        in.clear();   
    }   
    return in;   
} 

#include <algorithm>   
#include <iomanip>   
#include <ios>   
#include <iostream>   
#include <stdexcept>   
#include <string>   
#include <vector>   
#include "grade.h"   
#include "Student_info.h"   
   
using std::cin;                     using std::setprecision;   
using std::cout;                    using std::sort;   
using std::domain_error;            using std::streamsize;   
using std::endl;                    using std::string;   
using std::max;                     using std::vector;   
   
int main()   
{   
    vector<Student_info> students;   
    Student_info record;   
    string::size_type maxlen = 0;       // the length of the longest name   
   
    // 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 (vector<Student_info>::size_type i = 0;   
         i != students.size(); ++i) {   
   
        // write the name, padded on the right to `maxlen' `+' `1' characters   
        cout << students[i].name   
             << string(maxlen + 1 - students[i].name.size(), ' ');   
   
        // compute and write the grade   
        try {   
            double final_grade = grade(students[i]);   
            streamsize prec = cout.precision();   
            cout << setprecision(3) << final_grade   
                 << setprecision(prec);   
        } catch (domain_error e) {   
            cout << e.what();   
        }   
        cout << endl;   
    }  
	system("pause");
    return 0;   
}