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

实验任务4：

Vector.hpp代码：

#pragma once
#include<iostream>
#include<stdexcept>
using namespace std;

template<typename T>
class Vector
{
private:
    int size;
    T* ptr;
public:
    Vector(int n)
    {
    if (n < 0)
    {
        throw length_error("Vector constructor:negative size");
    }
    else
    {
        ptr = new T[size];
    }
    }


    Vector(int n, T value)
    {

    if (n < 0)
    {
        throw length_error("Vector constructor:negative size");
    }
    else
    {
        ptr = new T[size];
        for (int i = 0; i < size; i++)
        {
            ptr[i] = value;

        }
     }
    }
    
    
    Vector(const Vector<T>& v)
    {
    for (int i = 0; i < size; i++)
    {
        ptr[i] = v.ptr[i];
    }
    }
    ~Vector()
    {

    delete[]ptr;
    }

    int get_size()
    {
        return size;
    }

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

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

     friend void output(const Vector<T>& v);
};

template<typename T>
const T& Vector<T>::at(int index) const
{
    if (index < 0 || index >= size)
    {
        throw std::out_of_range("Vector: index out of range");
    }
    return ptr[index];
}

template<typename T>
T& Vector<T>::at(int index)
{
    if (index < 0 || index >= size)
    {
        throw std::out_of_range("Vector: index out of range");
    }
    return ptr[index];
}

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

template<typename T>
T& Vector<T>::operator[](int index)
{
    return at(index);
}

template<typename T>
void output(const Vector<T>& v)
{
     for (int i = 0; i < v.size; i++)
     {
         cout << v.ptr[i] << ", ";
     }
     cout <<"\b\b " << endl;

}

task4.cpp代码:

#include <iostream>
#include "Vector1.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) {
        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();
}

代码截图：

 

实验任务5：

information.hpp:

#pragma once
#include<iostream>
#include<string>
#include<iomanip>

using namespace std;

class information
{
private:
    int xuehao;
    string name;
    string major;
    int score;
public:
    information() = default;
    ~information() = default;

    string get_major()const{
        return major;
    }
    int get_score()const{
        return score;
    }

    friend ostream& operator<<(ostream& out, information& p);
    friend istream& operator>>(istream& in, information& p);
};

ostream& operator<<(ostream& out, information& p){
    out << setiosflags(ios_base::left);
    out << setw(10) << p.xuehao
        << setw(10) << p.name
        << setw(10) << p.major
        << setw(10) << p.score << endl;
    return out;

}

istream& operator>>(istream& in, information& p){
    in >> p.xuehao >> p.name >> p.major >> p.score;
    return in;
}

tools.hpp:

#pragma once
#include"information.hpp"
#include<iostream>
#include<string>
#include<fstream>
#include<vector>

bool paixu(const information& p1, const information& p2)
{
    if (p1.get_major() == p2.get_major()){
        return p1.get_score() > p2.get_score();
    }
    if (p1.get_major() < p2.get_major()){
        return true;
    }
    return false;
}

void output(ostream& out, const vector<information>& v)
{
    for (auto& i : v){
        out << i;
    }
}

void save(const string& filename, vector<information>& v)
{
    ofstream out(filename);
    if (!out.is_open())
    {
        cout << "文件写入失败" << endl;
        exit(0);
    }
    output(out, v);
    out.close();
}

void load(const string& filename, vector<information>& v)
{
    string firstline;
    information p;
    ifstream in(filename);
    if (!in.is_open()){
        cout << "文件读出失败" << endl;
        exit(0);
    }

    getline(in, firstline);
    while (in >> p){
        v.push_back(p);
    }

    in.close();
}

task5:

#include"information.hpp"
#include"tools.hpp"
#include<string>
#include<vector>
#include<algorithm>
#include<iostream>

int main()
{
    vector<information> v;
    load("data5.txt", v);
    sort(v.begin(), v.end(), paixu);
    output(cout, v);
    save("ans.txt", v);
    return 0;
}

 

代码截图：

 

 总结：

在文件的读写操作中，我利用ifstream和ofstream类，分别实现了从文件中读取对象向量和将向量保存到文件的功能。

重载<<和>>运算符，使得可以方便地通过标准输入输出流来读取和写入对象。

在重载输入运算符时，我需要注意到输入流中可能存在的换行符和空格等干扰因素，采取措施来避免它们对输入操作的影响。