实验6 模板类、文件I/O和异常处理

task4

Vector.hpp

#pragma once

#include <iostream>
#include <stdexcept>

using std::cout;
using std::endl;

template<typename T>
class Vector {
public:
    Vector(int size0 = 0);
    Vector(int size0, T same_value);
    Vector(const Vector<T>& v);
    ~Vector();

    int get_size() const;
    T& at(int index) const;
    T& at(int index);

    T& operator[](int index) const;
    T& operator[](int index);

    template<typename T1>
    friend void output(const Vector<T1>& v);

private:
    int size;
    T* ptr;
};

template<typename T>
Vector<T>::Vector(int size0) : size{ size0 } {
    if (size < 0)
        throw std::length_error("vectorInt constructor: negative size");

    ptr = new T[size];
}

template<typename T>
Vector<T>::Vector(int size0, T same_value) : size{ size0 } {
    if (size < 0)
        throw std::length_error("vectorInt constructor: negative size");

    ptr = new T[size];
    for (int i = 0; i < size; ++i)
        ptr[i] = same_value;
}

template<typename T>
Vector<T>::Vector(const Vector<T>& v) : size{ v.size }, ptr{ new T[size] } {//? get_size()
    for (int i = 0; i < size; ++i)
        ptr[i] = v.ptr[i];
}

template<typename T>
Vector<T>::~Vector() {
    delete[] ptr;
}

template<typename T>
int Vector<T>::get_size() const {
    return size;
}

template<typename T>
T& Vector<T>::at(int index) const {
    if (index < 0 || index >= size)
        throw std::out_of_range("vectorInt::operator[](): index out of this->size");

    return ptr[index];
}

template<typename T>
T& Vector<T>::at(int index) {
    return static_cast<const Vector<T>*>(this)->at(index);
}

template<typename T>
T& Vector<T>::operator[](int index) const {
    if (index < 0 || index >= size)
        throw std::out_of_range("vectorInt::operator[](): index out of this-> size");

    return ptr[index];
}

template<typename T>
T& Vector<T>::operator[](int index) {
    return static_cast<const Vector<T>*>(this)->operator[](index);
}

template<typename T1>
void output(const Vector<T1>& v) {
    for (int i = 0; i < v.size; ++i) {
        cout << v.at(i) << ", ";
    }
    cout << "\b\b \n";
}

task4.cpp

#include <iostream>
#include "Vector.hpp"

void test1() {
    using namespace std;

    int n;
    cout << "Enter n: ";
    cin >> n;

    Vector<double> x1(n);
    for (auto i = 0; i < n; ++i)
        x1.at(i) = i * 0.7;

    cout << "x1: "; output(x1);

    Vector<int> x2(n, 42);
    const Vector<int> x3(x2);

    cout << "x2: "; output(x2);
    cout << "x3: "; output(x3);

    x2.at(0) = 77;
    x2.at(1) = 777;
    cout << "x2: "; output(x2);
    cout << "x3: "; output(x3);
}

void test2() {
    using namespace std;

    int n, index;
    while (cout << "Enter n and index: ", cin >> n >> index) { // 多组输入，按下Ctrl + Z终止
        try {
            Vector<int> v(n, n);
            v.at(index) = -999;
            cout << "v: "; output(v);
        }
        catch (const exception& e) {
            cout << e.what() << endl;
        }
    }
}

int main() {
    cout << "测试1: 模板类接口测试\n";
    test1();
    
    cout << "\n测试2: 模板类异常处理测试\n";
    test2();
}

result4

 task5

Student.hpp

#pragma once

#include <iostream>
#include <string>
#include <iomanip>

using std::ostream;
using std::istream;
using std::string;
using std::setiosflags;
using std::setw;
using std::ios_base;



class Student {
public:
    Student() = default;
    ~Student() = default;

    string get_major() const;
    int get_score() const;

    friend ostream& operator<<(ostream& out, const Student& s);
    friend istream& operator>>(istream& in, Student& s);
private:
    string no;
    string name;
    string major;
    int score;
};

string Student::get_major() const {
    return major;
}

int Student::get_score() const {
    return score;
}


ostream& operator<<(ostream& out, const Student& s) {
    out << setiosflags(ios_base::left);
    out << setw(15) << s.no
        << setw(15) << s.name
        << setw(15) << s.major
        << setw(15) << s.score;

    return out;
}

istream& operator>>(istream& in, Student& s) {
    in >> s.no >> s.name >> s.major >> s.score;

    return in;
}

utils.hpp

#include "Student.hpp"
#include <fstream>
#include <iostream>
#include <vector>
#include <string>

bool compare_by_solutionInfo(const Student& s1, const Student& s2) {
    if (s1.get_major() < s2.get_major())
        return true;

    if (s1.get_major() == s2.get_major())
        return s1.get_score() > s2.get_score();

    return false;
}

// 把vector<Student>对象中的元素插入到输出流out
void output(std::ostream& out, const std::vector<Student>& v) {
    for (auto& i : v) {
        out << i << std::endl;
    }
}

// 把vector<Student>对象中的元素写到filename文件中
void save(const std::string& filename, std::vector<Student>& v) {
    using std::ofstream;

    ofstream out(filename);
    if (!out.is_open()) {
        std::cout << "fail to open file to write\n";
        return;
    }

    output(out, v);
    out.close();
}

// 从文件filename读取参赛选手信息到vector<Student>对象
void load(const std::string& filename, std::vector<Student>& v) {
    using std::ifstream;

    ifstream in(filename);
    if (!in.is_open()) {
        std::cout << "fail to open file to read\n";
        return;
    }

    std::string title_line;
    getline(in, title_line); // 跳过标题行

    Student t;
    while (in >> t) {
        v.push_back(t);
    }

    in.close();
}

task5.cpp

#include "Student.hpp"
#include "utils.hpp"
#include <iostream>
#include <vector>
#include <algorithm>

void test() {
    using namespace std;

    vector<Student> v;

    load("data.txt", v);
    sort(v.begin(), v.end(), compare_by_solutionInfo);
    output(cout, v);
    save("ans.txt", v);
}

int main() {
    test();
}

result5