我正在定义一个新的C ++类，其what方法返回一个char*类型，其值为整数作为构造函数传递。
最初我使用string类并从what返回字符串数据。
然后我尝试在以下代码中使用char*类型：
/* Define the exception here */
class BadLengthException: public exception
{
public:
BadLengthException(int strLength)
{
strLen = strLength;
res = (char*)malloc(strLength+1);
int resultSize = sprintf(res, "%d", strLen);
}
~BadLengthException() throw()
{
free(res);
}
virtual const char* what() const throw()
{
return res;
}
private:
int strLen;
char* res;
};
但是在释放malloc分配的变量时遇到问题：它给出了这个异常：
pointer being freed was not allocated
*** set a breakpoint in malloc_error_break to debug
Abort trap: 6
那为什么呢？我应该在哪里以及如何在Exception类中释放动态分配的变量？
编辑
这是一个最小的工作完整示例。该程序将要求用户输入。第一个是指定以下输入数量的数字。其他输入将是字符串。如果字符串小于5，则会引发上述异常。
只需输入：1然后输入Me
#include <iostream>
#include <string>
#include <sstream>
#include <exception>
using namespace std;
/* Define the exception here */
class BadLengthException: public exception
{
public:
BadLengthException(int strLength)
{
strLen = strLength;
res = (char*)malloc(strLength+1);
int resultSize = sprintf(res, "%d", strLen);
}
~BadLengthException() throw()
{
free(res);
}
virtual const char* what() const throw()
{
return res;
}
private:
int strLen;
char* res;
};
bool checkUsername(string username) {
bool isValid = true;
int n = username.length();
if(n < 5) {
throw BadLengthException(n);
}
for(int i = 0; i < n-1; i++) {
if(username[i] == 'w' && username[i+1] == 'w') {
isValid = false;
}
}
return isValid;
}
int main() {
int T; cin >> T;
while(T--) {
string username;
cin >> username;
try {
bool isValid = checkUsername(username);
if(isValid) {
cout << "Valid" << '\n';
} else {
cout << "Invalid" << '\n';
}
} catch (BadLengthException e) {
cout << "Too short: " << e.what() << '\n';
}
}
return 0;
}
编辑2
使用字符串的原始类如下：这个确实有效
class BadLengthException: public exception
{
public:
BadLengthException(int strLength)
{
res = to_string(strLength);
}
virtual const char* what() const throw()
{
return res.c_str();
}
private:
string res;
};
这与例外无关。你的班级不容易复制。
如果你打算写一个这样的类，那么你需要遵循rule of three。
发生的事情是你的异常对象被复制，它复制指针，所以你释放两次相同的指针。
但这样做的简单方法是使用std::string而不是分配自己的内存。
class BadLengthException: public exception
{
public:
BadLengthException(int strLength) : strLen(strLength), res(std::to_string(strLength))
{
}
virtual const char* what() const throw()
{
return res.c_str();
}
private:
int strLen;
std::string res;
};
例外情况不应导致例外情况;他们应该是noexcept。因此，通常不鼓励动态内存alloc / dealloc - 隐式（例如使用std :: string ...）或显式（new / delete，malloc / free ...）。一种更好的方法是使用静态字符数组：
class BadLengthException:
public std::exception
{
public:
BadLengthException(size_t len){
std::snprintf(res, bufsz, fmt(), len);
};
~BadLengthException()=default;
virtual const char* what() const {return res;};
private:
static auto& fmt() {return "bad length [%dz]";};
static constexpr size_t fmtsz=sizeof(fmt());
static constexpr size_t intsz=std::numeric_limits<size_t>::digits10;
static constexpr size_t bufsz=fmtsz+intsz;
char res[bufsz];
};
我将添加另一个答案，试图将所有内容放在一起。
问题如下。考虑这个例子：
double division(int a, int b) {
if( b == 0 ) {
throw "Division by zero condition!";
}
return (a/b);
}
在另一个块中，将调用该函数：
double c;
try
{
c =division(d,f)
}
catch( ExceptionName e ) {
...
}
通常在被调用函数（上例中的division）中抛出异常（即生成实例），但是它们被捕获到代码的其他部分（直接调用函数或甚至更多外部函数）。要使异常实例从生成位置到捕获位置，可以复制实例。
显然，使用复制赋值构造函数（=清除）执行异常实例的复制。由于我没有声明一个，因此使用默认值。此默认构造函数具有以下指针行为：它不是复制指向的值，而是复制指针值本身（即地址），以便现在我有另一个指向同一地址的实例。
假设上面的division函数发生异常。假设执行了实例的副本。从函数返回时，原始实例正在被销毁，因为它位于堆栈内存中，因此调用析构函数并释放指针。但是，新副本也共享指针的内存。
当副本尝试使用其指针时，将出现错误，因为它不是有效指针。在我的情况下，它正在尝试使用free它的析构函数使用它但它已经被释放：因此错误。
出现这个问题的原因是我违反了C ++ 11中的5规则（以前的规则3）。
该规则规定，当手动使用和管理资源时（在我的情况下，内存是资源），如果一个类实现以下成员之一，则另一个应该被覆盖：
4和5是2和3的对应，但与rvalues（here在lvalues rvalues上的好帖子）
最简单的方法是使用string，如问题，注释和答案中已指定的那样，以便内存由字符串类自动管理。
另一种选择（如另一个答案中所述）是使用共享指针。
虽然不方便，但要与问题保持一致，这里是一个使用纯指针的实现。重新定义构造函数和析构函数，以便在复制构造函数中为它们分配新内存，而不是使用另一个实例分配的内存。
/* Define the exception here */
class BadLengthException: public exception
{
public:
BadLengthException(int strLength)
{
cout<<"Constructor\n";
strLen = strLength;
res = (char*)malloc(strLen+1);
int resultSize = sprintf(res, "%d", strLen);
}
/*assignment operator*/
BadLengthException& operator= (const BadLengthException &other)
{
cout<<"copy assignment constructor"<<endl;
if(&other == this)
{
return *this;
}
strLen = other.strLen;
res = (char*)malloc(strLen+1);
int resultSize = sprintf(res, "%d", strLen);
return *this;
}
/*copy constructor*/
BadLengthException(BadLengthException& other)
{
cout<<"copy constructor\n";
*this = other;
}
BadLengthException(BadLengthException&& other)
{
cout<<"move constructor "<<endl;
*this = other;
}
BadLengthException& operator=(BadLengthException&& other)
{
cout<<"move assignment operator"<<endl;
if(&other == this)
{
return *this;
}
*this = other;
return *this;
}
/*class destructor*/
~BadLengthException() throw()
{
cout<<"destructor"<<endl;
free(res);
}
virtual const char* what() const throw()
{
return res;
}
private:
int strLen;
char* res;
};
测试类的示例：
int main(int argc, char *argv[])
{
{
cout<<"-----Expecting copy constructor------\n";
BadLengthException e(10);
BadLengthException e1(e);
cout<<"10: "<<e1.what()<<endl;
}
cout<<endl<<endl;
{
cout<<"-----Expecting copy assignment operator------\n";
BadLengthException e(10);
BadLengthException e2 = e;
cout<<"10: "<<e2.what()<<endl;
}
cout<<endl<<endl;
{
cout<<"-----move assignment operator------\n";
BadLengthException e3(1);
e3 = BadLengthException(33);
}
{
cout<<"-----move constructor------\n";
BadLengthException e4 = BadLengthException(33);
}
{
cout<<"-----move constructor------\n";
BadLengthException e5(BadLengthException(33));
}
cout<<"-----6------\n";
BadLengthException e6(1), e6_1(2);
e6 = std::move(e6_1);
return 0;
}