为什么下面的代码不能编译（c++中的继承）

Question

所以这不是我遇到的问题，而是考试中我无法正确回答的问题。

我有以下课程：

template<class T>
class Server {
protected:
  std::vector<T> requests;
public:
 Server() = default;
 Server(const Server& other) = default;
 ~Server() = default;
 Server(const std::vector<T>& vec);
 Server& operator=(const Server<T>& other) = default;
 Server& operator+=(const T& request);
 Server& operator-=(const T& request);
 void operator()();
 std::size_t numRequests() const;
 friend Server<T> operator+(const Server<T>& a, const Server<T>& b );
 friend std::ostream& operator<<(std::ostream&, const Server<T>&);
};
template<class T>
Server<T> operator+(const Server<T>& a, const Server<T>& b );
template<class T>
std::ostream& operator<<(std::ostream&, const Server<T>&);

现在，我创建了一个名为LimitedNamedServer 的类，这些类之间的区别在于LimitedNamedServerobjects 具有最大请求容量和名称。

这就是它的样子：

template<class T>
LimitedNamedServer : public Server<T> {
 std::string name;
 std::size_t maxLimit;
public:
 LimitedNamedServer(const char* name, std::size_t limit) : Server<T>(), name(name), maxLimit(limit) {}
 LimitedNamedServer(const LimitedNamedServer& other) = default;
 ~LimitedNamedServer() = default;
 LimitedNamedServer(const char* name, std::size_t limit, const std::vector<T>& vec) : Server<T>(vec), name(name), maxLimit(limit) {
if(requests.size() > maxLimit) {
throw OverLimit();
 }
}
 LimitedNamedServer& operator=(const LimitedNamedServer<T>& other) = default;
 LimitedNamedServer& operator+=(const T& request) {
 if(numRequests()>=maxLimit) {
   throw OverLimit();
}
else {
 requests.push_back(request);
}
 return *this;
}
};

现在，问题如下：

让s1、s2 和s3 成为LimitedNamedServer 类中的三个对象。为什么下面的代码会编译不出来，这个问题怎么解决：

s1=s2+s3

我不知道为什么不应该编译。据我所知，我为Server 类定义的+ 运算符也可用于LimitedNamedServer 类中的对象。我最好的猜测是它发生在+ 的实现内部，我创建了一个新服务器而不是LimitedNamedServer，并且发生错误是因为s1 期望收到LimitedNamedServer 对象，而这是不是返回的对象。

这只是猜测，有人可以解释一下原因吗？

Answer 1

尝试向自己解释为什么它应该编译...

鉴于operator + 与Server 一起使用，问问自己如果允许编译该代码，name 和maxLimit 会发生什么。

提示：What is object slicing?

如您所知，您还需要为LimitedNamedServer 定义一个operator +。典型的实现是：

template <class T>
LimitedNamedServer<T> operator+(const LimitedNamedServer<T> &lhs, const LimitedNamedServer<T> &rhs)
{
    LimitedNamedServer result = lhs;
    result += rhs;
    return result;
}

这样写，你可以重复使用现有的代码，不需要交友。