C++ 一个类需要什么东西来定义它的向量？

我有两个简单的代码，我不知道它们有什么问题，但我怀疑我不能用当前的代码定义我的类类型的向量。 任何帮助

 #include <iostream>
#include <cmath>
#include <algorithm>
#include "Pair.h"
#include <vector>
#include <string>
using namespace std;


class Function{
public: 
    Function();
    Function(const Function& g);

/*  Function operator+(const Pair& input) const;
    Function& operator+=(const Pair& input);

    Function operator-(const Pair& input) const;
    Function& operator-=(const Pair& input);

    int& operator()(int input);

    Function operator+(const int input) const;
    Function operator-(const int input) const;
    Function operator/(const int input) const;
    Function operator*(const int input) const;

    Function& operator++();
    //Function& operator()++;
    Function& operator--();
    //Function& operator()--;

    Function operator=(const Function& input) const;
    Function operator+(const Function& input) const;
    Function& operator+=(Function& input);
    Function& operator-=(Function& input);
    bool operator==(Function& input) const;

    Function operator|(const Function &input) const;
    Function& operator|=(Function &input);

    Function operator()(const Function &input) const;

    ostream operator<<(const Function &input) const;

*/  
    vector<Pair> get_function_pairs() const;
    //void set_function_pairs(Function g);
    void add_pair(Pair g);
    void add_vector_of_pairs(vector<Pair> g);
    void sort_pairs();
private:
    vector<Pair> function_pairs;
};



void Function::add_pair(Pair g){
    function_pairs.push_back(g);
}

/*vector<Pair> Function::get_function_pairs() const{
    return function_pairs;
}

Function::Function(const Function& g){
    function_pairs.clear();
    for(int i = 0; i < g.get_function_pairs().size(); i++){
        function_pairs.push_back(g.get_function_pairs()[i]);
    }
}

/*Function Function::operator+(const Pair& input) const{
    Function a(*this);
    a.add_pair(input);
    return a;
}*/

#包括
#包括
#包括
#包括“Pair.h”
#包括
#包括
使用名称空间std；
类函数{
公众：
函数（）；
函数（常数函数&g）；
/*函数运算符+（常量对和输入）常量；
函数和运算符+=（常量对和输入）；
函数运算符-（常量对和输入）常量；
函数和运算符-=（常量对和输入）；
int&运算符（）（int输入）；
函数运算符+（常量int输入）常量；
函数运算符-（常量int输入）常量；
函数运算符/（常量int输入）常量；
函数运算符*（常量int输入）常量；
函数和运算符++（）；
//函数和运算符（）；
函数与运算符——（）；
//函数和运算符（）；
函数运算符=（常量函数和输入）常量；
函数运算符+（常量函数和输入）常量；
函数和运算符+=（函数和输入）；
函数和运算符-=（函数和输入）；
布尔运算符==（函数和输入）常量；
函数运算符|（常量函数和输入）常量；
函数和运算符|=（函数和输入）；
函数运算符（）（常量函数和输入）常量；
ostream操作符问题在于，由于
stringstream
成员，无法实现copysassignable和CopyConstructible

这也可以被看作是一个暗示，仅仅为了输出而包含一个像stringstream成员这样的重量级对象是一个设计缺陷，更不用说重新发明
std:：pair
轮子了

但不管怎么说，这个

#include <vector>
#include <sstream>

class Pair{
public:
    Pair() : x(0), y(0), s() {}
    Pair(int xx, int yy) : x(xx), y(yy), s() {}
    Pair(const Pair& rhs) : 
        x(rhs.x), y(rhs.y), s(rhs.s.str()) {}
    Pair& operator=(const Pair& rhs) { 
        x = rhs.x; 
        y = rhs.y; 
        s.str() = rhs.s.str();
        return *this;
    }
private:
    int x, y;
    std::stringstream s;
};

int main()
{
    std::vector<Pair> pairs;
    pairs.push_back(Pair());
    pairs.push_back(Pair(0,1));

    return 0;
}

#包括
#包括
类对{
公众：
Pair（）：x（0），y（0），s（）{}
配对（intxx，intyy）：x（xx），y（yy），s（）{}
对（常数对和rhs）：
x（rhs.x），y（rhs.y），s（rhs.s.str（））{}
成对运算符=（常量对和rhs）{
x=rhs.x；
y=rhs.y；
s、 str（）=rhs.s.str（）；
归还*这个；
}
私人：
int x，y；
std:：strings；
};
int main（）
{
std：：向量对；
配对。向后推（配对（））；
对。推回（对（0,1））；
返回0；
}

.
需求描述得很好。
//Function&operator（）++
这就是@zenith，它在注释中。问题出在其他地方。stringstream prob与++相关。因此，如果我想使用我以前的代码，我必须从类声明中删除sstream？或者（从设计角度来看，我建议这样做），或者如图所示扩展类（为了简洁起见，我跳过了
对中的其他成员，不是出于某种原因，它们可能会导致其他问题；我不知道）。
#include <vector>
#include <sstream>

class Pair{
public:
    Pair() : x(0), y(0), s() {}
    Pair(int xx, int yy) : x(xx), y(yy), s() {}
    Pair(const Pair& rhs) : 
        x(rhs.x), y(rhs.y), s(rhs.s.str()) {}
    Pair& operator=(const Pair& rhs) { 
        x = rhs.x; 
        y = rhs.y; 
        s.str() = rhs.s.str();
        return *this;
    }
private:
    int x, y;
    std::stringstream s;
};

int main()
{
    std::vector<Pair> pairs;
    pairs.push_back(Pair());
    pairs.push_back(Pair(0,1));

    return 0;
}