根据cmets和answers，似乎有三种方法：
- 编写
getline() 的自定义版本，可能在内部使用std::istream::getline() 成员来获取实际字符。
- 使用过滤流缓冲区来限制可能接收的数据量。
- 不要读取
std::string，而是使用带有自定义分配器的字符串实例化来限制存储在字符串中的内存量。
并非所有建议都附带代码。这个答案提供了所有方法的代码，并对所有三种方法进行了一些讨论。在进入实现细节之前，首先值得指出的是，如果接收到过长的输入会发生什么，有多种选择：
- 读取过长的行可能会导致成功读取部分行，即结果字符串包含读取的内容，并且流没有设置任何错误标志。但是，这样做意味着无法区分一条线正好达到极限还是太长。不过，由于限制有些随意，它可能并不重要。
- 读取过长的行可能会被视为失败（即设置
std::ios_base::failbit 和/或std::ios_base::bad_bit），并且由于读取失败，因此会产生一个空字符串。显然，产生一个空字符串可以防止潜在地查看到目前为止读取的字符串以了解发生了什么。
- 读取过长的行可能会提供部分行读取，并且还会在流上设置错误标志。这似乎是合理的行为，既可以检测到有问题，也可以为潜在的检查提供输入。
虽然已经有多个代码示例实现了getline() 的有限版本，但这里还有一个！我认为它更简单（尽管可能更慢；必要时可以处理性能），它还保留了std::getline()s 接口：它使用流的width() 来传达限制（可能考虑到width() 是一个合理的扩展到std::getline()):
template <typename cT, typename Traits, typename Alloc>
std::basic_istream<cT, Traits>&
safe_getline(std::basic_istream<cT, Traits>& in,
std::basic_string<cT, Traits, Alloc>& value,
cT delim)
{
typedef std::basic_string<cT, Traits, Alloc> string_type;
typedef typename string_type::size_type size_type;
typename std::basic_istream<cT, Traits>::sentry cerberos(in);
if (cerberos) {
value.clear();
size_type width(in.width(0));
if (width == 0) {
width = std::numeric_limits<size_type>::max();
}
std::istreambuf_iterator<char> it(in), end;
for (; value.size() != width && it != end; ++it) {
if (!Traits::eq(delim, *it)) {
value.push_back(*it);
}
else {
++it;
break;
}
}
if (value.size() == width) {
in.setstate(std::ios_base::failbit);
}
}
return in;
}
这个版本的getline() 的使用与std::getline() 一样，但是当限制读取的数据量似乎合理时，设置width()，例如：
std::string line;
if (safe_getline(in >> std::setw(max_characters), line)) {
// do something with the input
}
另一种方法是仅使用过滤流缓冲区来限制输入量：过滤器只会计算处理的字符数并将数量限制为合适的字符数。这种方法实际上比单个行更容易应用于整个流：当只处理一行时，过滤器不能只从底层流中获取充满字符的缓冲区，因为没有可靠的方法将字符放回原处。实现无缓冲版本仍然很简单，但可能不是特别有效：
template <typename cT, typename Traits = std::char_traits<char> >
class basic_limitbuf
: std::basic_streambuf <cT, Traits> {
public:
typedef Traits traits_type;
typedef typename Traits::int_type int_type;
private:
std::streamsize size;
std::streamsize max;
std::basic_istream<cT, Traits>* stream;
std::basic_streambuf<cT, Traits>* sbuf;
int_type underflow() {
if (this->size < this->max) {
return this->sbuf->sgetc();
}
else {
this->stream->setstate(std::ios_base::failbit);
return traits_type::eof();
}
}
int_type uflow() {
if (this->size < this->max) {
++this->size;
return this->sbuf->sbumpc();
}
else {
this->stream->setstate(std::ios_base::failbit);
return traits_type::eof();
}
}
public:
basic_limitbuf(std::streamsize max,
std::basic_istream<cT, Traits>& stream)
: size()
, max(max)
, stream(&stream)
, sbuf(this->stream->rdbuf(this)) {
}
~basic_limitbuf() {
std::ios_base::iostate state = this->stream->rdstate();
this->stream->rdbuf(this->sbuf);
this->stream->setstate(state);
}
};
此流缓冲区已设置为在构造时插入自身并在销毁时移除自身。也就是说，它可以像这样简单地使用：
std::string line;
basic_limitbuf<char> sbuf(max_characters, in);
if (std::getline(in, line)) {
// do something with the input
}
添加一个设置限制的操纵器也很容易。这种方法的一个优点是，如果可以限制流的总大小，则不需要触及任何读取代码：可以在创建流之后立即设置过滤器。当不需要退出过滤器时，过滤器也可以使用缓冲区，这将大大提高性能。
建议的第三种方法是将std::basic_string 与自定义分配器一起使用。分配器方法有两个方面有点尴尬：
- 正在读取的字符串实际上具有一种不能立即转换为
std::string 的类型（尽管转换也不难）。
- 可以轻松限制最大数组大小，但字符串的随机大小或多或少会小于此值：当流分配失败时会抛出异常，并且不会尝试将字符串增大较小的大小。
这是限制分配大小的分配器的必要代码：
template <typename T>
struct limit_alloc
{
private:
std::size_t max_;
public:
typedef T value_type;
limit_alloc(std::size_t max): max_(max) {}
template <typename S>
limit_alloc(limit_alloc<S> const& other): max_(other.max()) {}
std::size_t max() const { return this->max_; }
T* allocate(std::size_t size) {
return size <= max_
? static_cast<T*>(operator new[](size))
: throw std::bad_alloc();
}
void deallocate(void* ptr, std::size_t) {
return operator delete[](ptr);
}
};
template <typename T0, typename T1>
bool operator== (limit_alloc<T0> const& a0, limit_alloc<T1> const& a1) {
return a0.max() == a1.max();
}
template <typename T0, typename T1>
bool operator!= (limit_alloc<T0> const& a0, limit_alloc<T1> const& a1) {
return !(a0 == a1);
}
分配器可以像这样使用（代码可以用最新版本的clang 编译，但不能用gcc）：
std::basic_string<char, std::char_traits<char>, limit_alloc<char> >
tmp(limit_alloc<char>(max_chars));
if (std::getline(in, tmp)) {
std::string(tmp.begin(), tmp.end());
// do something with the input
}
总之，有多种方法，每种方法都有自己的小缺点，但每种方法都可以合理地实现限制基于超长线路的拒绝服务攻击的既定目标：
- 使用自定义版本的
getline() 意味着需要更改阅读代码。
- 除非可以限制整个流的大小，否则使用自定义流缓冲区会很慢。
- 使用自定义分配器可以减少控制，并且需要对读取代码进行一些更改。