std :: vector :: resize导致模板类崩溃

Question

Here's the code : The place where it crashed is marked with a comment( //////crash ). I don't know what results in the problem.

After I print the size of data got from file,It shows ' 1 ' means that the array should only contains 1 element. So it seems that there's no 'bad_allocate error' ... Could you guys help me ? I would appreciate your kindly help very much. :)

#include<stdio.h>
#include<iostream>
#include<string>
#include<map>
#include<vector>
#include<algorithm>
#include<string.h>
#include<type_traits>
using namespace std;

bool read_int(int& val,FILE*& fp)
{
    if(fp == nullptr)
        return false;
    fread(&val,sizeof(int),1,fp);
    return true;
}

bool write_int(int val,FILE*& fp)
{
    if(fp == nullptr)
    {
        return false;
    }
    fwrite(&val,sizeof(int),1,fp);
    return true;
}


struct SANOBJ
{
    char path[128];
    char nickname[40];
    SANOBJ(const char* _p = nullptr,const char* _n = nullptr)
    {
        if(_p == nullptr || _n == nullptr)
            *this = {};
        int m = strlen(_p),n = strlen(_n);
        if(m < 128) strcpy(path,_p);
        if(n < 40) strcpy(nickname,_n);
    }
    ~SANOBJ(){}
    SANOBJ(const SANOBJ& other)
    {
        memcpy(path,other.path,sizeof(char) * 128);
        memcpy(nickname,other.nickname,sizeof(char) * 40);
    }
    bool operator < (const SANOBJ& other) const
    {
        return string(path) < string(other.path);
    }
    bool operator == (const SANOBJ& other) const
    {
        return (strcmp(other.path,path) == 0);
    }
};

template <typename source_type>     //the 'source_type' type need to have the member 'int m_index'
class FrameQueue
{
public:
    FrameQueue()    //fill the 1st frame automatically
    {
        source_type new_node;
        new_node.m_index = 0;
        m_data.push_back(new_node);
    }
    FrameQueue(const FrameQueue& other)
    {
        m_data = other.m_data;
    }

    bool AddFrame(const source_type& other) // keeps an ascending order
    {
        int index = _binary_search(other);
        if(index != -1)
        {
            return false;
        }
        m_data.insert(std::upper_bound(m_data.begin(),m_data.end(),other,
                                    [](const source_type& a,const source_type& b)->bool const{return a.m_index < b.m_index;}
                                    ),other);
        return true;
    }

    bool DeleteFrameByElemIndex(int elemIndex)  //delete frame according to the index of frame in the queue
    {
        if(elemIndex < 0)
            return false;
        if(elemIndex >= m_data.size())
            return false;
        typename std::vector<source_type>::iterator it ;
        it = m_data.begin() + elemIndex;
        it = m_data.erase(it);
        return true;
    }

    bool DeleteFrameByFrameIndex(int frameIndex)
    {
        source_type node = {};
        node.m_index = frameIndex;
        int index = _binary_search(node);
        if(index == -1)
        {
            return false;
        }
        typename std::vector<source_type>::iterator it;
        it = m_data.begin() + index;
        it = m_data.erase(it);
        return true;
    }

    bool Clear()        // There would always be a single frame
    {
        source_type new_node = {};
        new_node.m_index = 0;
        m_data.clear();
        m_data.push_back(new_node);
        return true;
    }

    bool WriteFile(FILE*& fp)
    {
        if(fp == nullptr)
            return false;
        bool result = write_int(m_data.size(),fp);
        if(result == false)
            return false;
        fwrite(&(m_data[0]),sizeof(source_type),m_data.size(),fp);
        return true;
    }

    bool ReadFile(FILE*& fp)
    {
        if(fp == nullptr)
            return false;
        int data_size;
        bool result = read_int(data_size,fp);
        if(result == false)
            return false;
        if(data_size > 0)
        {
            m_data.resize(data_size);
            fread(&(m_data[0]),sizeof(source_type),data_size,fp);
        }
        return true;
    }
private:
    int _binary_search(source_type target)
    {
        int l = 0,r = (int)m_data.size() - 1,mid;
        while(l<=r)
        {
            mid = (l + r) / 2;
            if(m_data[l].m_index == target.m_index)
            {
                return l;
            }
            if(m_data[r].m_index == target.m_index)
            {
                return r;
            }
            if(m_data[mid].m_index == target.m_index)
            {
                return mid;
            }
            if(m_data[mid].m_index > target.m_index)
            {
                r = mid - 1;
            }
            else
            {
                l = mid + 1;
            }
        }
        return -1;
    }
    public:
    vector<source_type> m_data;
};

template<typename source_type>
class UniqueSource
{
public:
    UniqueSource(){}
    ~UniqueSource(){}
    bool Add(const source_type& other)//return false when insert failed,otherwise return true
    {
        if(m_map_source_to_index.find(other) == m_map_source_to_index.end())
        {
            int map_size = m_map_source_to_index.size();
            m_data.push_back(other);
            m_map_source_to_index.insert(pair<source_type,int>(other,map_size));
            m_result.push_back(map_size);
            return true;
        }
        else
        {
            m_result.push_back(m_map_source_to_index[other]);
            return true;
        }
        return false;
    }

    bool Delete(int elemIndex)  // delete the elem by elem Index,If succeed ,return true,otherwise return false
    {
        if(elemIndex < 0)
            return false;
        if(elemIndex >= m_data.size())
            return false;
        typename std::map<source_type,int>::iterator mit;
        typename std::vector<source_type>::iterator vit;
        for(mit = m_map_source_to_index.begin();mit!=m_map_source_to_index.end();++mit)
        {
            m_map_source_to_index.erase(mit);
        }
        vit = m_data.begin() + elemIndex;
        m_data.erase(vit);
        return true;
    }

    bool Clear()
    {
        m_map_source_to_index.clear();
        m_data.clear();
        m_result.clear();
        return true;
    }

    bool WriteFile(FILE*& fp)
    {
        if(fp == nullptr)
            return false;
        bool result = write_int(m_data.size(),fp);
        if(result == false)
            return false;
        if(m_data.size() > 0)
            fwrite(&(m_data[0]),sizeof(source_type),m_data.size(),fp);
        result = write_int(m_result.size(),fp);
        if(result == false)
            return false;
        if(m_result.size() > 0)
            fwrite(&(m_result[0]),sizeof(int),m_result.size(),fp);
        return true;
    }

    bool ReadFile(FILE*& fp)
    {
        if(fp == nullptr)
            return false;
        Clear();
        int data_size;
        read_int(data_size,fp);
        if(data_size > 0)
        {
            printf("[%d]",data_size);
            m_data.resize(data_size);   /////////////////Crash!!!!!!!!!!!!
            printf("Resize Ok\r\n");
            fread(&(m_data[0]),sizeof(source_type),data_size,fp);
        }
        read_int(data_size,fp);
        printf("[%d]",data_size);
        if(data_size > 0)
        {
            m_result.resize(data_size);
            fread(&(m_result[0]),sizeof(int),data_size,fp);
        }
        return true;
    }
//private:
    map<source_type,int> m_map_source_to_index;
    vector<source_type> m_data;
    vector<int> m_result;   //the index I want
};

int main()
{
    UniqueSource<SANOBJ> m;
    SANOBJ t = {"123","456"};
    m.Add(t);
    printf("Added\r\n");
    FILE* fp = nullptr;
    fp = fopen("test.b","wb");
    if(fp == nullptr)
    {
        printf("Failed...\r\n");
    }
    bool ret = false;
    ret = m.WriteFile(fp);
    if(ret)
    {
        printf("Writed!\r\n");
        fclose(fp);
    }
    fp = fopen("test.b","rb");
    if(fp == nullptr)
    {
        printf("Failed...\r\n");
    }
    ret = m.ReadFile(fp);
    fclose(fp);
    printf("Readed\r\n");
    for(int i=0;i<m.m_data.size();i++)
        printf("%s %s\r\n",m.m_data[i].path,m.m_data[i].nickname);
    return 0;
}

Answer 1

Yes. The problem is is with *this = {}

If I were you, I'd rewrite SANOBJ constructor like this (this is a rough code and you may need to slightly modify it if you wish)

SANOBJ(const char* _p = nullptr,const char* _n = nullptr)
{
    if (( _p != nullptr ) && ((strlen(_p) < 128)))
        strcpy(path,_p);

    if (( _n != nullptr ) && ((strlen(_n) < 40)))
        strcpy(nickname,_n);
}

It'll resolve the problem.

Naturally, I don't play with *this (not this).

Answer 2

*this = {} default-constructs a new SANOBJ instance and then assigns it to *this . This would normally be OK, but here you are calling it from the SANOBJ default constructor (making the logic being something like "to default-construct a SANOBJ , default-construct a SANOBJ and then assign its value to myself"), leading to infinite recursion and eventually a stack overflow.

Sidenote: The copy constructor is not needed.

Answer 3

If you want to be sure that the member variables are empty (char path[128] and char nickname[40]) set at the beginning of the constructor something like: path[0] = '\\0'; nickname[0] = '\\0'; path[0] = '\\0'; nickname[0] = '\\0'; Or use something like on constructor:

SANOBJ(const char* _p = nullptr,const char* _n = nullptr)
    : path(), nickname()
{

}

But don't use *this= {}