Bonjour,

Je m'adresse à vous car j'essaie de faire le tp ZString du tuto de mateo.
J'en suis ou il faut surcharger l'opérateur +.
Pour cela je veut faire une allocation dynamique d'un tableau de char mais ca ne marche pas et windows me sort une belle erreur avec une croix rouge.

Le code qui plante :

char *chaineFinal = NULL;
int tailleTotal = 18;
chaineFinal = new char[tailleTotal];

et l'erreur :

L'instruction à "0x7c94426d" emploie l'adresse mémoire "0x70697a2". La mémoire ne peut pas être "read"

Salut

Pour t'aider nous allons avoir besoin que tu nous transcrive la fonction au complet et un main() minimal qui reproduit l'erreur. Ajoute aussi tes constructeurs.

Voila le code complet :

#include <iostream>
#include "Zstring.h"


using namespace std;

int main(void)
{
    char test[] = "Salut !";
    Zstring chaine3;
    Zstring chaine;
    Zstring chaine2 = "Bonjour !";
    Zstring chaine5;

    chaine = test;

    chaine5 = chaine2 + chaine;
    chaine3 = chaine2 + test;

    chaine.afficher();
    chaine2.afficher();
    chaine3.afficher();
    chaine5.afficher();

    return 0;
}

#include <iostream>
#include "Zstring.h"

using namespace std;

///constructeurs :
Zstring::Zstring()
{
    m_chaine = new char[1];
    m_chaine[0] = '\0';
    m_tailleChaine = 0;
}

Zstring::Zstring(const char *chaine)
{
    m_tailleChaine = longueurChaine(chaine);
    m_chaine = new char[m_tailleChaine];
    copieChaine(chaine, m_chaine);
}

Zstring::Zstring(const Zstring &chaine)
{
    m_tailleChaine = chaine.m_tailleChaine;
    m_chaine = new char[m_tailleChaine];
    copieChaine(chaine.m_chaine, m_chaine);
}

///destructeurs :
Zstring::~Zstring()
{
    delete[] m_chaine;
}

///Méthodes :

int Zstring::longueurChaine(const char *chaine)
{
    int taille = 0;
    for(int i = 0 ; chaine[i] != '\0' ; i++)
    {
        taille = i + 2;
    }
    return taille;
}

void Zstring::copieChaine(const char *chaineACopier, char *chaineCopier)
{
    int tailleChaine = longueurChaine(chaineACopier);
    for(int i = 0 ; i <= tailleChaine ; i++)
    {
        chaineCopier[i] = chaineACopier[i];
    }
}

void Zstring::afficher()
{
    if(m_chaine == NULL)
        cout << "La chaine est vide." << endl;
    else
        cout << "La chaine : \"" << m_chaine << "\" et est de longueur : " << m_tailleChaine << endl;
}

char *Zstring::getChaine()
{
    return m_chaine;
}

int Zstring::getLongueur()
{
    return m_tailleChaine;
}

void Zstring::concatenerChaine(const char *chaine1, const char *chaine2, char *chaineRetour)
{
    int taille1 = longueurChaine(chaine1) - 1;
    int taille2 = longueurChaine(chaine2);
    int tailleTotal;
    if(taille1 >= 0)
        tailleTotal = taille1 + taille2;
    else
        tailleTotal = taille2;

    if(tailleTotal > 0)
    {
        delete[] chaineRetour;
        cout << "allocation : " << tailleTotal << endl;
        chaineRetour = new char[tailleTotal];
        cout << "fin d'allocation" << endl;


        for(int i = 0 ; i <= taille1 ; i++)
        {
            chaineRetour[i] = chaine1[i];
        }
        for(int i = 0 ; i <= taille2 ; i++)
        {
            chaineRetour[taille1 + i] = chaine2[i];
        }
    }
}

///surcharge d'opérateur :

Zstring Zstring::operator=(const char *chaine)
{
    delete[] m_chaine;

    m_tailleChaine = longueurChaine(chaine);
    m_chaine = new char[m_tailleChaine];
    copieChaine(chaine, m_chaine);

    return *this;
}

Zstring Zstring::operator=(const Zstring &chaine)
{
    delete[] m_chaine;

    m_tailleChaine = chaine.m_tailleChaine;
    m_chaine = new char[m_tailleChaine];
    copieChaine(chaine.m_chaine, m_chaine);

    return *this;
}

Zstring Zstring::operator+(const char *chaine)
{
    char *chaineRetour = new char[1];
    chaineRetour[0] = '\0';

    concatenerChaine(m_chaine, chaine, chaineRetour);
    Zstring retour(chaineRetour);
    delete[] chaineRetour;
    return retour;
}

Zstring Zstring::operator+(const Zstring &chaine)
{
    char *chaineRetour = new char[1];
    chaineRetour[0] = '\0';

    concatenerChaine(m_chaine, chaine.m_chaine, chaineRetour);
    Zstring retour(chaineRetour);
    delete[] chaineRetour;
    return retour;
}

#ifndef ZSTRING_H_INCLUDED
#define ZSTRING_H_INCLUDED

#include <iostream>

class Zstring
{
    public :

    ///constructeurs :
    Zstring();//defaut
    Zstring(const char *chaine);//surcharge
    Zstring(const Zstring &chaine);//copie
    ///destructeurs :
    ~Zstring();

    ///Méthode :

    void afficher();
    char *getChaine();
    int getLongueur();

    ///surcharge d'operateur :
    Zstring operator=(const char *chaine);
    Zstring operator=(const Zstring &chaine);

    Zstring operator+(const char *chaine);
    Zstring operator+(const Zstring &chaine);


    private :
    ///attributs :
    char *m_chaine;
    int m_tailleChaine;
    ///Méthodes :
    int longueurChaine(const char *chaine);
    void copieChaine(const char *chaineACopier, char *chaineCopier);
    void concatenerChaine(const char *chaine1, const char *chaine2, char *chaineFinal);
};


#endif

Merci d'avance

Ok on commence.

Entre toi et moi : Une m_chaine ne devrait jamais être NULL. Peu importe l'état de la ZString, une chaine vide c'est "" ( {'\0'} ) pas NULL

Jusque la je suis d'accord, je modifie le tout pour éviter d'avoir m_chaine = NULL.
EDIT : Maintenant l'allocation fonctionne, mais la concatenation des chaines non.
j'ai édité le code au dessus.

C'est bon, tout fonctionne. J'ai juste mis le contenu de la fonction concatenerchaine ou je l'appelle en faisant les modification necessaire et tout fonctionne maintenant.