Accelerated C++ 15 Revisiting character pictures

grade.h

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

grade.cpp

// source file for the grade-ralated functons#include <vector>#include <stdexcept>#include "Student_info.h"#include "median.h"using std::vector;  using std::domain_error; using std::sort;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 - 1] + vec[mid]) / 2 : vec[mid];}double grade(double midterm, double final, double homework) {    return 0.2 * midterm + 0.4 * final + 0.4 * homework;}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);}

Student_info.h

#ifndef GUARD_Student_info#define GUARD_Student_info// Student_info.h header file#include <iostream>#include <string>#include <vector>class Student_info{public:    std::string name() const {        return n;    }    std::istream& read(std::istream&);    double grade() const;    static bool compare(const Student_info&, const Student_info&);private:    std::string n;    double midterm, final;    std::vector<double>  homework;};#endif

Student_info.cpp

// source file for Student_info-related functions#include <vector>#include <iostream>#include "Student_info.h"#include "grade.h"using std::cout;    using std::vector;  using std::istream;double Student_info::grade() const {    return ::grade(midterm, final, homework);}bool Student_info::compare(const Student_info& x, const Student_info& y) {    return x.n < y.n;}istream& read_hw(istream& in, vector<double>& hw) {    // read and store the homework grades    cout << "Enter all your homework grades, "            "followd by end-of-file: ";    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;}istream& Student_info::read(istream& is) {    // read and store the student's name and midterm and final exam grades    cout << "Please enter your first name, midterm and final exam grades: ";    is >> n >> midterm >> final;    read_hw(is, homework);    return is;}

Pic.h

#ifndef GUARD_Pic_h#define GUARD_Pic_h#include <iostream>#include <vector>#include <string>#include <algorithm>#include "Ptr.h"// forward declarationclass Picture;class Pic_base {    friend std::ostream& operator<<(std::ostream&, const Picture&);    friend class Frame_Pic;    friend class HCat_Pic;    friend class VCat_Pic;    friend class String_Pic;    private:        // no public interface(except for the destrctor)        typedef std::vector<std::string>::size_type ht_sz;                  typedef std::string::size_type wd_sz;                                                              virtual wd_sz width() const = 0;        virtual ht_sz height() const = 0;        virtual void display(std::ostream&, ht_sz, bool) const = 0;    public:        virtual ~Pic_base() { }    protected:        static void pad(std::ostream&, wd_sz, wd_sz);};void Pic_base::pad(std::ostream& os, wd_sz beg, wd_sz end) {    while (beg != end) {        os << " ";        ++beg;    }}class Frame_Pic: public Pic_base {    friend Picture frame(const Picture&);    // no public interface    Ptr<Pic_base> p;    Frame_Pic(const Ptr<Pic_base>& pic): p(pic) { }    wd_sz width() const { return p->width() + 4; }    ht_sz height() const { return p->height() + 4; }    void display(std::ostream&, ht_sz, bool) const;};void Frame_Pic::display(std::ostream& os, ht_sz row, bool do_pad) const {    if (row >= height()) {        // out of range        if (do_pad)            pad(os, 0, width());    } else if (row == 0 || row == height() - 1) {        // top or bottom row        os << std::string(width(), '*');    } else if (row == 1 || row == height() - 2) {        // second from top or bottom row        os << "*";        pad(os, 1, width() - 1);        os << "*";    } else {        // interior row        os << "* ";        p->display(os, row - 2, true);        os << " *";    }}class VCat_Pic: public Pic_base {    friend Picture vcat(const Picture&, const Picture&);    Ptr<Pic_base> top, bottom;    VCat_Pic(const Ptr<Pic_base>& t, const Ptr<Pic_base>& b):        top(t), bottom(b) { }    wd_sz width() const {        return std::max(top->width(), bottom->width());    }    ht_sz height() const{        return top->height() + bottom->height();    }    void display(std::ostream&, ht_sz, bool) const;};void VCat_Pic::display(std::ostream& os, ht_sz row, bool do_pad) const {    wd_sz w = 0;    if (row < top->height()) {        // we are in the top subpicture        top->display(os, row, do_pad);        w = top->width();    } else if (row < height()) {        // we are in the bottom subpicture        bottom->display(os, row - top->height(), do_pad);        w = bottom->width();    }    if (do_pad)        pad(os, w, width());}class HCat_Pic: public Pic_base {    friend Picture hcat(const Picture&, const Picture&);    Ptr<Pic_base> left, right;    HCat_Pic(const Ptr<Pic_base>& l, const Ptr<Pic_base>& r):        left(l), right(r) { }    wd_sz width() const {        return left->width() + right->width();    }    ht_sz height() const {        return std::max(left->height(), right->height());    }    void display(std::ostream&, ht_sz, bool) const;};void HCat_Pic::display(std::ostream& os, ht_sz row, bool do_pad) const {    left->display(os, row, do_pad || row < right->height());    right->display(os, row, do_pad);}class String_Pic: public Pic_base {    friend class Picture;    std::vector<std::string> data;    String_Pic(const std::vector<std::string>& v): data(v) { }    wd_sz width() const;    ht_sz height() const { return data.size(); }    void display(std::ostream&, ht_sz, bool) const;};Pic_base::wd_sz String_Pic::width() const {    Pic_base::wd_sz n = 0;    for (Pic_base::ht_sz i = 0; i != data.size(); ++i)        n = std::max(n, data[i].size());    return n;}void String_Pic::display(std::ostream& os, ht_sz row, bool do_pad) const {    wd_sz start = 0;    // write the row if we're still in range    if (row < height()) {        os << data[row];        start = data[row].size();    }    // pad the output if necessary    if (do_pad)        pad(os, start, width());}class Picture {    friend std::ostream& operator<<(std::ostream&, const Picture&);    friend Picture frame(const Picture&);    friend Picture hcat(const Picture&, const Picture&);    friend Picture vcat(const Picture&, const Picture&);    public:        Picture(const std::vector<std::string>& v = std::vector<std::string>()): p(new String_Pic(v)) { }    private:        Picture(Pic_base* ptr): p(ptr) { }        Ptr<Pic_base> p;};Picture frame(const Picture& pic) {    return new Frame_Pic(pic.p);}Picture hcat(const Picture& l, const Picture& r) {    return new HCat_Pic(l.p, r.p);}Picture vcat(const Picture& t, const Picture& b) {    return new VCat_Pic(t.p, b.p);}std::ostream& operator<<(std::ostream& os, const Picture& picture) {    const Pic_base::ht_sz ht = picture.p->height();    std::endl;    for (Pic_base::ht_sz i = 0; i != ht; ++i) {        picture.p->display(os, i, false);        os << std::endl;    }    return os;}#endif

Ptr.h

#ifndef GUARD_Ptr_h#define GUARD_Ptr_h// Ptr.h#include <iostream>#include <stdexcept>template <typename T> class Ptr {    public:        // new member to copy the object conditionally when needed        void make_unique() {            if (*refptr != 1) {                --*refptr;                refptr = new size_t(1);                p = p ? p->clone() : 0;            }        }        // same as Ref_handle        Ptr(): p(0), refptr(new size_t(1)) { }        Ptr(T* t): p(t), refptr(new size_t(1)) { }        Ptr(const Ptr& h): p(h.p), refptr(h.refptr) { ++*refptr; }        Ptr& operator=(const Ptr&);        ~Ptr();        operator bool() const { return p; }        T& operator*() const;         T* operator->() const {            if (p)                return p;            throw std::runtime_error("unbound Ptr");        }    private:        T* p;        std::size_t* refptr;};template <typename T> Ptr<T>& Ptr<T>::operator=(const Ptr& rhs) {    ++*rhs.refptr;    // free the left-hand side, destroying pointers if appropriate    if (--*refptr == 0) {        delete refptr;        delete p;    }    // copy in values from the right-hand side    refptr = rhs.refptr;    p = rhs.p;    return *this;}template <typename T>T& Ptr<T>::operator*() const {    if (p)        return *p;    throw std::runtime_error("unbound Ptr");}template <typename T>Ptr<T>::~Ptr() {    if (--*refptr == 0) {        delete refptr;        delete p;    }}#endif

main.cpp

// main.cpp#include "Pic.h"// #include "median.h"// #include "grade.h"// #include "Ptr.h"#include "Student_info.h"#include <algorithm>using std::vector;  using std::string;  using std::cin;using std::cout;    using std::endl;    using std::sort;Picture histogram(const vector<Student_info>& students) {    Picture names;    Picture grades;    // for each student    for (vector<Student_info>::const_iterator it = students.begin(); it != students.end(); ++it) {        // create vertically concatenated pictures of the names and grades        names = vcat(names, vector<string>(1, it->name()));        grades = vcat(grades,                vector<string>(1, " " + string(it->grade() / 5, '=')));    }    // horizontally concatenate the name and grade pictures to combine them    return hcat(names, grades);}int main() {    vector<Student_info> students;    Student_info s;    // read the names and grades    while (s.read(cin))        students.push_back(s);    // put the students in alphabetical order    sort(students.begin(), students.end(), Student_info::compare);    // write the names and histograms    cout << frame(histogram(students)) << endl;    return 0;}