C++ c++；：与投掷、尝试和接球一起工作

我只是想得到扔，试图赶上工作。 这是我的堆栈头文件，我将我的抛出放在“/**/”中以暂时忽略它。

它是当我弹出并按下时，所以当它是满的或是空的时抛出错误。这些我都是新手

在我的书中，它将FullStack和EmptyStack设置为。。。类FullStack{}；（因此为空类）和EmptyStack相同

也许有人能帮我解决这个问题

以下是一个简单的主要问题：

---

我怎样才能赶上工作呢。ex）调用stack.Push（item）时，如果它已满，我可以捕获错误并显示它

现场观看：

简言之：

• 您需要先定义exeption类，然后才能抛出它们。将它们包含在StackType的头文件中
• 不要在头文件中使用（全局）

  名称空间

  ！对于试图避免名称空间之间冲突的类用户来说，这将使他们的生活变得悲惨
• 您需要在堆栈上再推一个值

我尽量减少了评论，因为内联引用有点长（我认为评论应该发挥作用）

我可以建议：

• 从通用堆栈异常基类派生（也建议对异常类使用更一致的命名约定）：Edit稍微解决了这个问题。作为理由

编辑为演示增强的异常类型和示例处理程序而编辑的示例：

//Purpose: Header file for StackType. Containing all declerations and prototypes
#include <stdexcept>

struct StackException : virtual std::exception 
{  
    protected: StackException() {}
};
struct StackFullException : StackException 
{
    char const* what() const throw() { return "StackFullException"; }
};
struct StackEmptyException : StackException
{
    char const* what() const throw() { return "StackEmptyException"; }
};


template <class itemType>
class StackType
{
public:
    StackType   (int max);
    StackType   ();
    bool IsEmpty() const;
    bool IsFull () const;
    void Push   (itemType newItem);
    void Pop    ();
    itemType Top() const;
    ~StackType  (); // Destructor

private:
    int top;        // key:top of the stack
    int maxStack;   // max number of stack items
    itemType* list; // pointer to dynamically allocated memory
};

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
/*Implementation (StackStype.cpp)
StackType prototype functions*/

template <class itemType>
StackType<itemType>::StackType(int max)
{
    maxStack = max;
    top = -1;
    list = new itemType[maxStack];
}

template <class itemType>
StackType<itemType>::StackType()
{
    maxStack = 200;
    top = -1;
    list = new itemType[maxStack];
}

template <class itemType>
bool StackType<itemType>::IsEmpty() const
{
    return(top == -1);
}

template <class itemType>
bool StackType<itemType>::IsFull() const
{
    return(top == maxStack - 1);
}

template <class itemType>
void StackType<itemType>::Push(itemType newItem)
{
    if(IsFull())
    {
        throw StackFullException();
    }
    top++;
    list[top] = newItem;
}

template <class itemType>
void StackType<itemType>::Pop()
{
    if(IsEmpty())
    {
        throw StackEmptyException();
    }
    top--;
}

template <class itemType>
itemType StackType<itemType>::Top() const
{
    if(IsEmpty())
    {
        throw StackEmptyException();
    }
    return list[top];
}

template <class itemType>
StackType<itemType>::~StackType()
{
    delete [] list;
}

///////////////////////////////////////
// sample main.cpp

#include <iostream>
int main(void)
{
    try
    {
        StackType<int> stack(5);
        stack.Push(5);
        stack.Push(2);
        stack.Push(3);
        stack.Push(4);
        stack.Push(1);//<-----Still Ok!
        stack.Push(0);//<-----throw FullStack
    } catch (const StackException& e)
    {
        std::cerr << "Received a StackException: what()? " << e.what() << std::endl;
    }
}

//用途：StackType的头文件。包含所有偏差和原型
#包括
结构堆栈异常：虚拟std:：异常
{  
受保护：StackException（）{}
};
结构StackFullException:StackException
{
char const*what（）const throw（）{返回“StackFullException”；}
};
结构StackEmptyException:StackException
{
char const*what（）const throw（）{return“StackEmptyException”；}
};
模板
类堆栈类型
{
公众：
堆栈类型（int max）；
StackType（）；
bool IsEmpty（）常量；
bool IsFull（）常量；
作废推送（itemType newItem）；
void Pop（）；
itemType Top（）常量；
~StackType（）；//析构函数
私人：
int top；//键：堆栈的顶部
int maxStack；//堆栈项的最大数量
itemType*list；//指向动态分配内存的指针
};
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
/*实现（StackStype.cpp）
StackType原型函数*/
模板
StackType:：StackType（int max）
{
maxStack=max；
top=-1；
列表=新项目类型[maxStack]；
}
模板
StackType:：StackType（）
{
maxStack=200；
top=-1；
列表=新项目类型[maxStack]；
}
模板
bool StackType:：IsEmpty（）常量
{
返回（顶部==-1）；
}
模板
bool StackType:：IsFull（）常量
{
返回（top==maxStack-1）；
}
模板
void StackType:：Push（itemType newItem）
{
如果（IsFull（））
{
抛出StackFullException（）；
}
top++；
列表[顶部]=新项目；
}
模板
void StackType:：Pop（）
{
if（IsEmpty（））
{
抛出StackEmptyException（）；
}
顶部--；
}
模板
itemType StackType:：Top（）常量
{
if（IsEmpty（））
{
抛出StackEmptyException（）；
}
返回列表[顶部]；
}
模板
StackType:：~StackType（）
{
删除[]列表；
}
///////////////////////////////////////
//示例main.cpp
#包括
内部主（空）
{
尝试
{
堆垛式堆垛（5）；
栈推（5）；
栈推（2）；
堆栈推送（3）；
堆栈推送（4）；
堆栈推送（1）；//@SoapBox:是的，这也花了我一段时间。非常感谢您提供的信息和帮助。我的班级并没有告诉我有关常见堆栈异常的情况，但同时做这两件事很有意思。说到不让用户生活痛苦，您的异常类应该来自
std:：exception
@Idelic:本着这种精神，它们是应该虚拟地派生，以避免由于不明确的catch块而引起意外。修改后的代码显示了适当的异常层次结构和示例处理程序。也可以在这里找到：我建议您捕获常量引用，而不是非常量引用。这有助于编译器。
int main()
{
     try {
           // ....
     } catch (const StackException& e)
     {
         std::cerr << "oops, a stack error occured: " << e.what() << std::endl;
     }
} 

//Purpose: Header file for StackType. Containing all declerations and prototypes
#include <stdexcept>

struct StackException : virtual std::exception 
{  
    protected: StackException() {}
};
struct StackFullException : StackException 
{
    char const* what() const throw() { return "StackFullException"; }
};
struct StackEmptyException : StackException
{
    char const* what() const throw() { return "StackEmptyException"; }
};


template <class itemType>
class StackType
{
public:
    StackType   (int max);
    StackType   ();
    bool IsEmpty() const;
    bool IsFull () const;
    void Push   (itemType newItem);
    void Pop    ();
    itemType Top() const;
    ~StackType  (); // Destructor

private:
    int top;        // key:top of the stack
    int maxStack;   // max number of stack items
    itemType* list; // pointer to dynamically allocated memory
};

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
/*Implementation (StackStype.cpp)
StackType prototype functions*/

template <class itemType>
StackType<itemType>::StackType(int max)
{
    maxStack = max;
    top = -1;
    list = new itemType[maxStack];
}

template <class itemType>
StackType<itemType>::StackType()
{
    maxStack = 200;
    top = -1;
    list = new itemType[maxStack];
}

template <class itemType>
bool StackType<itemType>::IsEmpty() const
{
    return(top == -1);
}

template <class itemType>
bool StackType<itemType>::IsFull() const
{
    return(top == maxStack - 1);
}

template <class itemType>
void StackType<itemType>::Push(itemType newItem)
{
    if(IsFull())
    {
        throw StackFullException();
    }
    top++;
    list[top] = newItem;
}

template <class itemType>
void StackType<itemType>::Pop()
{
    if(IsEmpty())
    {
        throw StackEmptyException();
    }
    top--;
}

template <class itemType>
itemType StackType<itemType>::Top() const
{
    if(IsEmpty())
    {
        throw StackEmptyException();
    }
    return list[top];
}

template <class itemType>
StackType<itemType>::~StackType()
{
    delete [] list;
}

///////////////////////////////////////
// sample main.cpp

#include <iostream>
int main(void)
{
    try
    {
        StackType<int> stack(5);
        stack.Push(5);
        stack.Push(2);
        stack.Push(3);
        stack.Push(4);
        stack.Push(1);//<-----Still Ok!
        stack.Push(0);//<-----throw FullStack
    } catch (const StackException& e)
    {
        std::cerr << "Received a StackException: what()? " << e.what() << std::endl;
    }
}