如何在C ++异常类析构函数中释放变量

问题描述 投票:1回答:3

我正在定义一个新的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;
};
c++ exception destructor free dynamic-memory-allocation
3个回答
6
投票

这与例外无关。你的班级不容易复制。

如果你打算写一个这样的类,那么你需要遵循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;
};

1
投票

例外情况不应导致例外情况;他们应该是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];
};

-1
投票

我将添加另一个答案,试图将所有内容放在一起。

问题

问题如下。考虑这个例子:

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它的析构函数使用它但它已经被释放:因此错误。

规则5

出现这个问题的原因是我违反了C ++ 11中的5规则(以前的规则3)。

该规则规定,当手动使用和管理资源时(在我的情况下,内存是资源),如果一个类实现以下成员之一,则另一个应该被覆盖:

  1. 析构函数
  2. 复制构造函数
  3. 复制赋值运算符
  4. 移动复制构造函数
  5. 移动赋值运算符

4和5是2和3的对应,但与rvaluesherelvalues 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;
}
© www.soinside.com 2019 - 2024. All rights reserved.