Vector::push_back qui lache une violation de mémoire

Version imprimable

Bonjour,

Je suis un peu rouillé ... et je n'arrive pas du tout à trouver l'origine du problème.
Je lance en mode débug, le programme plante. Je lance en mode débug avec GDB par dessus, il plante (mais pas à cet endroit...)

Voici le code:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
inline const std::vector<ecdEntry::ptr> readEntries(const unsigned int amount)
    {
        std::vector<ecdEntry::ptr> result;
        for(unsigned int i = 0; i < amount; ++i)
        {
            ecdEntry::ptr eptr(new ecdEntry()); /// ok
            eptr->read(m_stream); /// ok
            std::cout << "read ptr " << eptr->m_name << std::endl; /// ok
            result.push_back(std::move(eptr)); /// crash
            std::cout << "push back ptr " << eptr->m_name << std::endl; // jamais print sur la console
        }
        return result;
    }

Quelqu'un aurait une idée lumineuse ...?
merci d'avance
nico

En utilisant une deuxime version, le bug change de place légèrement:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
    inline const std::vector<ecdEntry::ptr> readEntries(const unsigned int amount)
    {
        std::vector<ecdEntry::ptr> result(amount);
        for(auto& entry: result)
        {
            std::cout << entry << std::endl;
            entry = std::make_shared<ecdEntry>(); /// Crash à l'itération 2 (la premiere marche bien !
            std::cout << entry << std::endl;
            entry->read(m_stream);
            std::cout << "push back ptr " << entry->m_name << std::endl;
        }
        return result;
    }

15/04/2013, 16h38
backlash

peux-tu poster le code de ecdEntry s'il te plait?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
class ecdEntry
{
public:
    typedef std::shared_ptr<ecdEntry> ptr;
 
    ecdEntry() :
        m_name(new char(PackingRules::Sizes::FileName)),
        m_size(0),
        m_offset(0),
        m_packing_type(PackingRules::PackingTypes::None),
        m_childs()
    {
    }
    ecdEntry(const std::string& name,
             const unsigned long size,
             const unsigned long offset,
             const PackingRules::PackingTypes packing_type,
             const unsigned int childs = 0
             ) :
        m_name(new char(PackingRules::Sizes::FileName)),
        m_size(size),
        m_offset(offset),
        m_packing_type(packing_type),
        m_childs(childs)
    {
        std::cout << "default ctor"<<std::endl;
        if(static_cast<PackingRules::Sizes>(name.size()) >= PackingRules::Sizes::FileName)
        {
            throw std::logic_error("Name of this entry is too long");
        }
 
        std::fill_n(m_name, PackingRules::Sizes::FileName, 0);
        memcpy(m_name, name.c_str(), PackingRules::Sizes::FileName);
    }
 
    ecdEntry(const ecdEntry& entry) = delete;
    ecdEntry& operator=(const ecdEntry& entry) = delete;
 
    ~ecdEntry()
    {
        if(m_name) delete[] m_name;
    }
 
    static unsigned long size()
    {
        return PackingRules::Sizes::FileName
                +sizeof(unsigned long)
                +sizeof(unsigned long)
                +sizeof(unsigned short)
                +sizeof(unsigned int);
    }
 
    void read(std::ifstream& stream)
    {
        stream.read(reinterpret_cast<char*>(m_name), PackingRules::Sizes::FileName);
        char* buffer;
        stream.read(reinterpret_cast<char*>(&buffer), sizeof(unsigned long));
        m_size = reinterpret_cast<unsigned long>(buffer);
        stream.read(reinterpret_cast<char*>(&buffer), sizeof(unsigned long));
        m_offset = reinterpret_cast<unsigned long>(buffer);
        stream.read(reinterpret_cast<char*>(&buffer), sizeof(unsigned short));
        m_packing_type = static_cast<unsigned short>(reinterpret_cast<unsigned int>(buffer));
        stream.read(reinterpret_cast<char*>(&buffer), sizeof(unsigned int));
        m_childs = reinterpret_cast<unsigned int>(buffer);
        delete[] buffer;
    }
    void write(std::ofstream& stream)
    {
        stream.write(m_name, PackingRules::Sizes::FileName);
        stream.write(reinterpret_cast<char*>(&m_size), sizeof(unsigned long));
        stream.write(reinterpret_cast<char*>(&m_offset), sizeof(unsigned long));
        stream.write(reinterpret_cast<char*>(&m_packing_type), sizeof(unsigned short));
        stream.write(reinterpret_cast<char*>(&m_childs), sizeof(unsigned int));
    }
 
    char* m_name;
    unsigned long m_size;
    unsigned long m_offset;
    unsigned short m_packing_type;
    unsigned int m_childs;
};

15/04/2013, 17h24
Médinoc

Code:

m_name(new char[PackingRules::Sizes::FileName]),