_Block_Type_Is_Valid (pHead->nBlockUse) Erreur

J'ai été dans un nouveau projet, mais je rencontre un problème dont je ne vois pas pourquoi l'échec.

Quand je perfom cette ligne supprimer textY me donner l'erreur _Block_Type_Is_Valid (pHead->nBlockUse). Donc, ce que je fais mal?

C'est le code source:

Texte.h

 #ifndef TEXT_H
 #define TEXT_H

typedef boost::shared_ptr<Font>  FontPtr;

class Text
{
public:

    Text(FontPtr font, char *text)
    {
        str = new char[35];
        this->font = font;    str = text; 
    }

    Text(const Text& cSource);
    Text& operator=(const Text& cSource);

    ~Text();
    .
    .
    .
    .

private:
    FontPtr font;
    char *str;
    GLuint texture;
    GLfloat pos_x, pos_y, width, height;
};

 #endif

Text.cpp

Text::Text(const Text& cSource)
{
    font = cSource.font;
    texture = cSource.texture;
    pos_x = cSource.pos_x;
    pos_y = cSource.pos_y;
    width = cSource.width;
    height = cSource.height;

    int sizeString = 35;
    if (cSource.str)
    {
        str = new char[sizeString];
        strncpy(str, cSource.str, sizeString);
    }

    else 
    {
        str = 0;
    }
}

Text& Text::operator=(const Text& cSource)
{
    delete[] str;

    font = cSource.font;
    texture = cSource.texture;
    pos_x = cSource.pos_x;
    pos_y = cSource.pos_y;
    width = cSource.width;
    height = cSource.height;

    int sizeString = 35;
    if (cSource.str)
    {
        str = new char[sizeString];
        strncpy(str, cSource.str, sizeString);
    }

    else 
    {
        str = 0;
    }

    return *this;
}

Text::~Text()
{
    delete[] str;
}

De police.h

#ifndef FONT_H
#define FONT_H

class Font
{
public:

    Font(TTF_Font *font, SDL_Color color)
    {
        this->font = font;    this->color = color; 
    }

    ~Font();
    .
    .
    .

private:
    TTF_Font *font;
    SDL_Color color;

};

#endif

Font.cpp

Font::~Font()
{
    TTF_CloseFont(font);
}

CGameApplication.cpp

.
.
.
.
void CGameApplication::initializeApplicationFonts()
{
    TTF_Font* font;
    SDL_Color color;

    font = TTF_OpenFont("test.ttf", 15);

    color.r = color.g = color.b = 255;

    GApp->addFont(font, color);

    Text *text = new Text(GApp->getFonts().at(0), " ");
    text->setTexture( CTextM->textToGLTexture(GApp->getFonts().at(0), text) );
    text->setPosX(20);  text->setPosY(20);

    GApp->addText(new Text(*text));

    Text *textY = new Text(GApp->getFonts().at(0), " ");
    textY->setTexture( CTextM->textToGLTexture(GApp->getFonts().at(0), textY) );
    textY->setPosX(80);  textY->setPosY(20);

    GApp->addText(new Text(*textY));
    delete textY;                 //-----> This line crashes the program with that error
}
.
.
.

GameApp.h

#ifndef GAMEAPP_H
#define GAMEAPP_H


class GameApp
{
public:
    GameApp(){
    }

    //~GameApp();

    void addFont(TTF_Font *font, SDL_Color color) { 
        vFonts.push_back(FontPtr( new Font(font, color) ) ); }

    vector<FontPtr> getFonts() { return vFonts; }

    void addText(Text *text) { 
        vTexts.push_back(new Text(*text));}

private:
    SDL_Surface *gameMainSurface;
    vector<Image*> vImages; 
    std::vector<FontPtr> vFonts;
    vector<Text*> vTexts;
    vector<Tile*> vTiles;
    Map *currentMap;
};

#endif

Donc je pense que le problème est que quand je vais détruire l'objet textY, le pointeur de la TTF_Font est détruit. Mais je ne suis pas sûr, parce que quand j'ai ajouter un objet Texte dans le vecteur-je utiliser un constructeur par copie donc les différents pointeurs obtenu copie sans problèmes.

Avez-vous marcher jusqu'à la pile d'appel pour voir qui était le dernier appel dans votre code qui a causé l'échec de débogage? (Aussi, Raw Pointeurs dans des conteneurs STL! Mes yeux! 🙂 )
Oui, c'est seulement un test alors que j'en œuvre des pointeurs intelligents dans tous les conteneurs STL. Je vais vérifier la pile des appels. Merci.

InformationsquelleAutor oscar.rpr | 2011-06-18

c++debugging pointers sdl visual-c++

11

Il suffit d'utiliser un std::string. Cette erreur signifie que vous doublez supprimé quelque chose, ou quelque chose comme ça, un problème que vous n'auriez pas si vous n'avez pas à gérer votre propre mémoire. Votre code est jonché de fuites de mémoire et d'autres bugs que vous n'aurez pas à std::string.
- Merci pour l'aide. J'ai changé tout les char* std::string et le travail sans problème. Et attendu qu'il n'est pas de problème si je le demande, si il y a un problème à utiliser des pointeurs dans des conteneurs STL, je pensais à utiliser auto_ptr dans certains d'entre eux, et shared_ptr dans d'autres objets qu'il est nécessaire, il est vraiment nécessaire?
- Vous ne pouvez pas utiliser auto_ptr dans des conteneurs Standard. Ce problème va être résolu en C++11, mais en C++03, vous devrez utiliser shared_ptr- même si il n'y a qu'une seule référence.
- Merci pour l'aide, je vais donc utiliser shared_ptr au lieu de raw pointeurs dans des conteneurs STL.
- "un problème que vous n'auriez pas si vous n'avez pas à gérer votre propre mémoire" je déteste ce sentiment dans un monde de ramasseurs d'ordures et de comptage de référence qui est plus difficile à déboguer. assurez-vous de chaîne est un cas spécial, mais la bonne réponse est "un problème que vous n'auriez pas si vous avez réussi votre mémoire correctement".
- Il y a un monde de différence entre les ramasseurs d'ordures et de comptage de référence, et std::string/std::vector. Ne gérez pas votre propre mémoire manuellement. Qui va juste conduire à l'infini de bugs.
- ouais, std::string est une bonne chose pour ne pas avoir à gérer le caractère de tampons. je ne veux pas considérer l'ensemble de ces choses - std::string (et d'autres choses comme vecteur) ne sont pas de gestion automatique de la mémoire, mais le code réutilisable que "juste" qu'il obtient droit.
InformationsquelleAutor Puppy
10

De ce que je peux voir, l'erreur a à voir avec la valeur par défaut ctor pour Text. Que vous prenez dans un char* pointeur, allouer de l'espace pour la chaîne, mais ne sont pas réellement copier le text en str, mais il suffit d'attribuer le pointeur! Vous ne corriger dans la copie ctor bien. Maintenant, considérons l'exemple suivant:
```
class Foo{
public:
    Foo(char* text){
        str = text;
    }

    ~Foo(){
        delete str;
    }

private:
    char* str;
};

int main(){
    Foo f("hi");
}
```
C++03 (pour assurer la compatibilité...) permet à des chaînes de caractères littérales ("hi") de se lier à des non-const char* pointeurs, comme on le voit dans ce code. C++11, heureusement, fixe et que cela devrait en fait plus de la compilation. Maintenant, la suppression d'une chaîne littérale de toute évidence ne fonctionne pas, que la chaîne est placée dans la lecture-seule la section de la .exe et en tant que tel n'est pas deletemesure. Je suppose que c'est là votre erreur vient de, si vous instanciez un Text objet à partir d'une chaîne littérale.

Noter que cela se produit également si vous le créer à partir d'un char[] créé sur la pile:
```
char text[] = "hi";
Foo f(text);
```
comme le Foo allons maintenant essayer de delete une pile de objet.

Un autre cas où ce qui pourrait se produire si vous double-supprimer un objet:
```
char* text = new char[3];
Foo f(text);
delete text;
```
- Merci, j'ai déjà résolu le problème en changeant chaque char * à std::string, parce qu'il était à l'origine une fuite de mémoire et d'autres problèmes.
InformationsquelleAutor Xeo

Vous devez vous connecter pour publier un commentaire.