构造函数和高级异常抛出C++； 必须分析包含异常的C++代码，但我不习惯于分析代码应该做什么。有几件事我不明白。另外，我还没有缓冲数据结构的经验，或者在C++中抛出异常的细节。

数据结构的最大大小是多少

• 也就是说，如果一个Seq_缓冲区的大小为100，那么有多少个 元素可以存储吗
• 我的直觉告诉我如果你创造了100码的东西， 它的最大尺寸是100，但我不能确定事实

构造函数可以在C++中添加异常

• Seq_Buffer的构造函数能否引发异常
• 假设这是真的，为什么不解释就行了 说明尝试、接住或投掷挡块？我认为这是获得例外的唯一途径

我试着寻找这两个问题，但我真的很迷茫。谢谢你花时间阅读。我试着寻找这两个问题，但我真的很迷茫。感谢您抽出时间阅读

Seq_Buffer类及其构造函数的代码如下：

#ifndef SEQBUFFER_H
#define SEQBUFFER_H

#include <memory>
#include <experimental/optional>

#include "optional.h"

// Exceptions classes
struct full_buffer {};
struct empty_buffer {};

// Sequential buffer for values of type T
template <typename T>
class seq_buffer {
public:
  // Constructs a buffer for n elements
  seq_buffer(int n) :
    size_{n},
    buf_{new item_type[size_]}
  {
  }

  // Default destructor
  ~seq_buffer() = default;

  // Size of buffer
  int size() const noexcept { 
    return size_; 
  }

  // Is buffer empty?
  bool empty() const noexcept { 
    return next_read_ == next_write_; 
  }

  // Is buffer full?
  bool full() const noexcept {
    const int next = next_position(next_write_);
    return next == next_read_;
  }

  // Put element x into buffer with marker last.
  // An empty element signals end of buffer.
  void put(const optional<T> & x);

  // Gets a pair with next element and last indication.
  // Pair is accessed through members first and second
  optional<T> get();

private:
  // Compute next position after p following circular order
  int next_position(int p) const noexcept {
    return p + ((p+1>=size_)?(1-size_):1);
  }

private:
  // Size of buffer
  const int size_;

  using item_type = optional<T>;

  // Unique pointer to buffer of size_ elements.
  std::unique_ptr<item_type[]> buf_;

  // Next position to read
  int next_read_ = 0;

  // Next position to write
  int next_write_ = 0;
};

template <typename T>
void seq_buffer<T>::put(const optional<T> & x)
{
  const int next = next_position(next_write_);
  if (next == next_read_) throw full_buffer{};
  if (!x) {
    buf_[next_write_] = {};
  }
  else {
    buf_[next_write_] = *x;
  }
  next_write_ = next;
}

template <typename T>
optional<T> seq_buffer<T>::get()
{
  if (empty()) throw empty_buffer{};
  auto res = buf_[next_read_];
  next_read_ = next_position(next_read_);
  return res;
}

#endif

\ifndef seq buffer\u H
#定义缓冲区
#包括
#包括
#包括“可选的.h”
//例外类
结构完整_缓冲区{}；
结构空_缓冲区{}；
//T型值的顺序缓冲区
样板
类顺序缓冲区{
公众：
//为n个元素构造缓冲区
顺序缓冲区（整数n）：
大小{n}，
buf_u{新项目类型[大小]}
{
}
//默认析构函数
~seq_buffer（）=默认值；
//缓冲区大小
int size（）常量noexcept{
返回大小；
}
//缓冲区是空的吗？
bool empty（）常量noexcept{
返回next_read_u==next_write_u;；
}
//缓冲区满了吗？
bool full（）常量noexcept{
const int next=下一个位置（下一个写入位置）；
return next==next\u read；
}
//将元素x放入带有最后一个标记的缓冲区。
//空元素表示缓冲区结束。
无效认沽权（常数可选和x）；
//获取具有下一个元素和最后一个指示的对。
//通过第一个和第二个成员访问该对
可选get（）；
私人：
//按照循环顺序计算p之后的下一个位置
int next_位置（INTP）常数noexcept{
返回p+（（p+1>=大小？）（1-大小？）：1）；
}
私人：
//缓冲区大小
const int size_2;；
使用项目类型=可选；
//指向大小元素缓冲区的唯一指针。
std：：唯一的\u ptr buf；
//下一个阅读位置
int next_read_uu=0；
//下一个写作位置
int next_uwrite_uu=0；
};
样板
void seq_buffer:：put（常量可选&x）
{
const int next=下一个位置（下一个写入位置）；
如果（next==next_read_）抛出满的_缓冲区{}；
如果（！x）{
buf_uu[next_uwrite_uu]={}；
}
否则{
buf_u[next_write_u]=*x；
}
下一步\写入\下一步；
}
样板
可选的seq_缓冲区：：get（）
{
if（empty（））抛出空的_缓冲区{}；
自动恢复=buf_uu[下一次读取]；
下一个读取位置=下一个读取位置（下一个读取位置）；
返回res；
}
#恩迪夫

是的，我们可以从构造函数中抛出异常。这是处理构造函数失败或类初始化错误的最佳方法。以下面的代码为例

class bar
{
public:
  bar()
  {
    std::cout << "bar() called" << std::endl;
  }

  ~bar()
  {
    std::cout << "~bar() called" << std::endl;

  }
};
class foo
{
public:
  foo()
    : b(new bar())
  {
    std::cout << "foo() called" << std::endl;
    throw "throw something";
  }

  ~foo()
  {
    delete b;
    std::cout << "~foo() called" << std::endl;
  }

private:
  bar *b;
};


int main(void)
{
  try {
    std::cout << "heap: new foo" << std::endl;
    foo *f = new foo();
  } catch (const char *e) {
    std::cout << "heap exception: " << e << std::endl;
  }

  try {
    std::cout << "stack: foo" << std::endl;
    foo f;
  } catch (const char *e) {
    std::cout << "stack exception: " << e << std::endl;
  }

  return 0;
}

类栏
{
公众：
bar（）
{
好吧，如果你不能通过阅读代码来解决这个问题，为什么不创建一些测试用例，这样你就可以使用调试器来逐步完成它（然后你会获得经验，能够在没有调试器的情况下在精神上完成这项工作）你甚至可以自己尝试在构造函数中加入一个抛出，看看发生了什么。构造函数使用
new
，如果内存不足，它会抛出
bad\u alloc
。它还构造未知类型的对象
item\u type
。它的构造函数也可能抛出一个异常。我认为这是一个学生的家庭作业。Raymond Jones，你应该读一本StruouSUP书籍，这可能是学习C++的最好方法。好的，所以有内置的C++异常可以抛出不同的东西，而不需要关键字。这就是我所想的。谢谢！这有很大帮助！我也假设我可以尝试制作测试用例，我只需要确保我不伪造。RayMordjJunes比一般情况更为普遍：在C++中，函数不需要声明它们可以抛出。几乎任何操作符都可能被一些抛出函数重载。因此，必须在C++中声明每个语句都能够抛出，除非标准另有规定。n新语句，如
auto a=b；
和
cout