C++:custrom String 类中的 SIGTRAP 错误

C++: SIGTRAP error in custrom String class

提问人:Gregor Hartl Watters 提问时间:6/4/2022 更新时间:6/4/2022 访问量:186

问:

在过去的两天里,我在互联网上搜索了一下,找不到发生这种情况的原因。

我的字符串类以人们期望的方式工作:它从堆上的初始连续内存块(128 字节)开始,然后根据需要调整大小。

我所有的 to 调用都与相应指针上的单个 to 匹配。newdelete[]

SIGTRAP 错误仅在调用析构函数时发生(使用最终时间)。delete[]

为了生成一个最小的可重现示例,我将代码(大约 1400 行)减少到下面看到的内容(以及似乎导致错误的原因)。

#include <string>
#include <iostream>
#include <cstring>

static int MIN_SIZE = 128;

    char *setchr_c(char *str, const char ch, size_t pos) {
        if (str == nullptr) {
            return nullptr;
        }
        *(str + pos) = ch;
        return str;
    }

    class String {
    private:
        char *data = nullptr;
        char *string = nullptr;
        size_t length_w_null = 0;
        size_t size = 0;
        size_t space_front = 0;
        size_t space_back = 0;
        bool is_empty = true;

        void set_size(bool def_do = true) {
            if (def_do) {
                do {
                    size *= 2;
                } while (size < length_w_null);
                return;
            }
            while (size < length_w_null) {
                size *= 2;
            }
        }

        void constructor(const char *str, bool after_empty = false) {
            size = MIN_SIZE;
            length_w_null = strlen(str) + 1;
            set_size(false);
            if (after_empty) { // this is to avoid re-assigning the memory if not necessary
                if (size != MIN_SIZE) {
                    // free(data);
                    printf("CTOR AFTER EMPTY DELETE, DELETING: %x\n", data);
                    delete[] data;
                    // data = (char *) malloc(size);
                    printf("CTOR AFTER EMPTY NEW, SIZE: %llu, ", size);
                    data = new char[size];
                    printf("ADDRESS: %x\n", data);
                }
            } else {
                // data = (char *) malloc(size);
                printf("CTOR ELSE NEW, SIZE: %llu, ", size);
                data = new char[size];
                printf("ADDRESS: %x\n", data);
            }
            memset(data, '\0', size);
            string = data + get_first_pos();
            setchr_c(string, '\0', length_w_null - 1);
            strcpy(string, str);
            space_front = get_first_pos();
            space_back = is_even(length_w_null) ? space_front : space_front + 1;
            is_empty = false;
        }

        void empty_constructor() {
            // data = (char *) malloc(MIN_SIZE);
            printf("EMPTY CTOR NEW, MINSIZE: %llu, ", MIN_SIZE);
            data = new char[MIN_SIZE];
            printf("ADDRESS: %x\n", data);
            memset(data, '\0', size);
            string = nullptr;
            length_w_null = 0;
            size = MIN_SIZE;
            space_front = MIN_SIZE / 2;
            space_back = MIN_SIZE / 2;
            is_empty = true;
        }

        static bool is_even(size_t num) {
            return num % 2 == 0;
        }

        [[nodiscard]] unsigned long get_first_pos() const {
            size_t new_len = length_w_null;
            if (!is_even(new_len)) {
                new_len++;
            }
            unsigned long pos = size / 2 - (new_len) / 2;
            return pos;
        }

    public:
        static const size_t nopos = -1;
        String() {
            empty_constructor();
        }

        String(char ch) {
            if (ch == '\0') {
                empty_constructor();
            } else {
                const char str[2]{ch, '\0'};
                constructor(str);
            }
        }

        String(const char *str) {
            if (str == nullptr) {
                return;
            }
            if (strlen(str) == 0) {
                empty_constructor();
            } else {
                constructor(str);
            }
        }

        void append_back(const char *str) {
            if (str == nullptr) {
                return;
            }
            if (is_empty) {
                constructor(str, true);
                return;
            }
            size_t l = strlen(str);
            size_t old_l = length_w_null - 1;
            length_w_null += l;
            if (l + 1 > space_back) {
                set_size();
                char *old_data = data;
                char *old_str = string;
                // data = (char *) malloc(size);
                printf("APPEND BACK NEW, SIZE: %llu, ", size);
                data = new char[size];
                printf("ADDRESS: %x\n", data);
                memset(data, '\0', size);
                string = data + get_first_pos();
                strcpy(string, old_str);
                // free(old_data);
                printf("APPEND BACK DELETE OLD_DATA, DELETING: %x\n", old_data);
                delete[] old_data;
                space_front = get_first_pos();
                space_back = is_even(length_w_null) ? space_front : space_front + 1;
            }
            strcpy(string + old_l, str);
            space_back -= l;
        }

        void append_front(const char *str) {
            if (str == nullptr) {
                return;
            }
            if (is_empty) {
                constructor(str, true);
                return;
            }
            size_t l = strlen(str);
            length_w_null += l;
            char gone = *string;
            if (l > space_front) {
                set_size();
                char *old_data = data;
                char *old_str = string;
                // data = (char *) malloc(size);
                printf("APPEND FRONT NEW, SIZE: %llu, ", size);
                data = new char[size];
                printf("ADDRESS: %x\n", data);
                memset(data, '\0', size);
                string = data + get_first_pos();
                strcpy(string + l, old_str);
                // free(old_data);
                printf("APPEND FRONT DELETE OLD_DATA, DELETING: %x\n", old_data);
                delete[] old_data;
                strcpy(string, str);
                space_front = get_first_pos();
                space_back = is_even(length_w_null) ? space_front : space_front + 1;
            } else {
                strcpy(string - l, str);
                string -= l;
                space_front -= l;
            }
            setchr_c(string, gone, l);
        }

        void push_back(char ch) {
            if (ch == 0) {
                return;
            }
            const char str[2] = {ch, '\0'};
            append_back(str);
        }

        void push_front(char ch) {
            if (ch == 0) {
                return;
            }
            const char str[2] = {ch, '\0'};
            append_front(str);
        }

        void clear() noexcept {
            // free(data);
            printf("CLEAR DELETE, DELETING: %x\n", data);
            delete[] data;
            empty_constructor();
        }

        size_t get_size() const {
            return size;
        }

        size_t get_length() const {
            return length_w_null == 0 ? 0 : length_w_null - 1;
        }

        const char *c_str() const noexcept {
            return string;
        }

        ~String() {
            // free(data);
            printf("DTOR DELETE, DELETING: %x\n", data);
            delete[] data;
        }

        friend std::ostream& operator<<(std::ostream& os, const String& str);
    };
    std::ostream& operator<<(std::ostream& os, const String& str) {
        os << str.string;
        return os;
    }
using namespace std;
int main() {
    String bro;
    char array[] = "eeee;;dlfkjas;j;a;lAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsdjfk";
    bro.clear();
    for (const char &ch : array) {bro.push_front(ch);}
    bro.clear();
    bro.append_back("Let us see!");
    cout << bro << endl;
    return 0;
}

我添加了一些printf()语句来检查地址,没有什么明显的错误。

我得到的示例输出是:

EMPTY CTOR NEW, MINSIZE: 128, ADDRESS: 9b651920
CLEAR DELETE, DELETING: 9b651920
EMPTY CTOR NEW, MINSIZE: 128, ADDRESS: 9b651920
APPEND FRONT NEW, SIZE: 256, ADDRESS: 9b6519b0
APPEND FRONT DELETE OLD_DATA, DELETING: 9b651920
CLEAR DELETE, DELETING: 9b6519b0
EMPTY CTOR NEW, MINSIZE: 128, ADDRESS: 9b651920
Let us see!
DTOR DELETE, DELETING: 9b651920

...在程序崩溃之前。

编译器:Windows 上的 MinGW。

C++ 字符串 内存管理 malloc new-operator

评论

2赞 user4581301 6/4/2022
可能不相关:不是用于打印 .也许?%xchar*%p
2赞 user4581301 6/4/2022
并且变得有点迂腐,对于s来说。%zusize_t
1赞 user4581301 6/4/2022
在我们有 ,但是 ' memset(data, '\0', size);尺寸 != MIN_SIZE' 的东西会变得丑陋。empty_constructordata = new char[MIN_SIZE];. If
2赞 user4581301 6/4/2022
看起来来得有点太晚了size = MIN_SIZE;empty_constructor
1赞 user4581301 6/4/2022
可以在那里更多。我不确定 mingw 的 g++ 是否支持它,但切换到编译器命令行,看看它是否可以为您提供更多诊断。-fsanitize=address,undefined

答:

1赞 Gregor Hartl Watters 6/4/2022 #1

user4581301 已经很好地检查了我的代码,并指出了我的成员函数中的明显错误:我习惯于在我的指针中设置字符值(可以大于 128),它只有 128 个字节分配给它(最初)。empty_constructor()memset()sizedata

通过更改为 as 参数,一切都已解决。sizeMIN_SIZEmemset()

非常感谢 user4581301。

我将尽快接受这个答案以结束问题。

评论

1赞 user4581301 6/4/2022
建议:将所有变量赋值向上移动到函数的顶部。首先设置,然后根据而不是一致性来设置所有内容。一旦它全部基于 ,你可能会看到可以消除一些几乎重复的代码的方法,也许还有函数。size = MIN_SIZE;sizeMIN_SIZEsizeconstructorappend_
0赞 Gregor Hartl Watters 6/4/2022
@user4581301这是一个很好的建议;为了我自己,这也希望能帮助我的代码清晰。在我们说话的时候,正在努力!谢谢你一直为此付出的努力,你很善良