Corrigé du TD 5 : chaînes de caractères, cartes à jouer

#ifndef String_h
#define String_h
 
class String
{
public :
    String();
    String(String const & autre);
    String const & operator=(String const & autre);
    ~String();
 
    String(char const * src);
 
    int size() const;
    char operator[](int i) const;
    String const & operator+=String const & autre);
    int find(String const & autre) const;
    void replace(int position, String const & autre);
 
private :
    int taille;
    char* data;
};
 
String operator+(String const & s1, String const & s2);
bool operator<(String const & s1, String const & s2);
 
std::ostream & operator<<(std::ostream & stream, String const & str);
 
#endif

String::String()
: taille(0), data(NULL)
{
}
 
String::String(String const & autre)
: taille(0), data(NULL)
{
    operator=(autre);
}
 
String::String const & operator=(String const & autre)
{
    if(this!=&autre)
    {
        if(data!=NULL)
        {
            delete[] data;
        }
        taille = autre.size();
        data = new char[taille];
        for(int i=0; i<taille; ++i)
        {
            data[i] = autre[i];
        }
    }
    return (*this);
}
 
String::~String()
{
    delete[] data;
}
 
String::String(char const * src)
{
    taille = strlen(src);
    data = new char[taille];
    for(int i=0; i<taille; ++i)
    {
        data[i] = src[i];
    }
}
 
int String::size() const
{
    return taille;
}
 
char String::operator[](int i) const
{
    return data[i];
}
 
String const & String::operator+=String const & autre)
{
    if(size()==0)
    {
        operator=(autre);
    }
    else if(autre.size()!=0)
    {
        int nouvelleTaille = taille + autre.size();
        char nouveauData = new char[nouvelleTaille];
        for(int i=0; i<taille; ++i)
        {
            nouveauData[i] = data[i];
        }
        for(int i=0; i<autre.size(); ++i)
        {
            nouveauData[i+taille] = autre[i];
        }
        delete[] data;
        taille = nouvelleTaille;
        data = nouveauData;
    }
 
    return (*this);
}
 
int String::find(String const & autre) const
{
    if(taille<autre.taille) return -1;
 
    int i=0;
    bool trouve=false;
    while(i<taille && !trouve)
    {
        int j=0;
        while(data[i+j] == autre[j] && j<autre.size() )
        {
            ++j;
        }
        if(j==autre.size())
        {
            trouve = true;
        }
        else
        {
            ++i;
        }
    }
 
    return ( trouve?i:-1 );
}
 
void String::replace(int position, String const & autre)
{
    int const nouvelleTaille = std::max(position+autre.taille, taille);
 
    char* nouveauTableau = new char[nouvelleTaille];
    for(int i=0; i<position; ++i)
    {
        nouveauTableau[i] = data[i];
    }
    for(int i=position; i<position+autre.taille; ++i)
    {
        nouveauTableau[i] = autre[i];
    }
    for(int i=position+autre.taille; i<nouvelleTaille; ++i)
    {
        nouveauTableau[i] = data[i];
    }
 
    delete[] data;
    data = nouveauTableau;
    taille = nouvelleTaille;
}
 
String operator+(String const & s1, String const & s2)
{
    String resultat(s1);
    resultat += s2;
    return resultat;
}
 
bool operator<(String const & s1, String const & s2)
{
    int const tailleMin = std::min(s1.size(), s2.size());
 
    for(int i=0; i<tailleMin; ++i)
    {
        if(s1[i]<s2[i]) return true;
        else if(s1[i]>s2[i]) return false;
        // sinon on continue
    }
 
    // Les deux chaines sont egales
    return false;
}
 
std::ostream & operator<<(std::ostream & stream, String const & str)
{
    for(int i=0; i<str.size(); ++i)
    {
        stream << str[i];
    }
    return stream;
}

#ifndef rang_h
#define rang_h
 
enum Rang
{
    as,
    deux,
    trois,
    quatre,
    cinq,
    six,
    sept,
    huit,
    neuf,
    dix,
    valet,
    dame,
    roi
}; // enum Rang
 
Rang & operator++(Rang & r);
Rang operator++(Rang & r, int);
 
Rang & operator--(Rang & r);
Rang operator--(Rang & r, int);
 
#endif // rang_h

#include "rang.h"
 
Rang& operator++(Rang & r)
{
    int rangInt = r;
 
    if(r==roi)
    {
        rangInt = as;
    }
    else
    {
        ++rangInt;
    }
 
    r = Rang(rangInt);
 
    return r;
}
 
Rang operator++(Rang & r, int)
{
    Rang ancienRang = r;
    ++r;
    return ancienRang;
}
 
Rang& operator--(Rang & r)
{
    int rangInt = r;
 
    if(r==as)
    {
        rangInt = roi;
    }
    else
    {
        ++rangInt;
    }
 
    r = Rang(rangInt);
 
    return r;
}
 
Rang operator--(Rang & r, int)
{
    Rang ancienRang = r;
    --r;
    return ancienRang;
}

#ifndef couleur_h
#define couleur_h
 
enum Couleur
{
    trefle,
    carreau,
    coeur,
    pique
}; // enum Couleur
 
Couleur & operator++(Couleur & c);
Couleur operator++(Couleur & c, int);
 
Couleur & operator--(Couleur & c);
Couleur operator--(Couleur & c, int);
 
#endif // couleur_h

#include "couleur.h"
 
Couleur& operator++(Couleur & c)
{
    int couleurInt = c;
 
    if(c==pique)
    {
        couleurInt = trefle;
    }
    else
    {
        ++couleurInt;
    }
 
    c = Couleur(couleurInt);
 
    return c;
}
 
Couleur operator++(Couleur & c, int)
{
    Couleur ancienneCouleur = c;
    ++c;
    return ancienneCouleur;
}
 
Couleur& operator--(Couleur & c)
{
    int couleurInt = c;
 
    if(c==trefle)
    {
        couleurInt = pique;
    }
    else
    {
        --couleurInt;
    }
 
    c = Couleur(couleurInt);
 
    return c;
}
 
Couleur operator--(Couleur & c, int)
{
    Couleur ancienneCouleur = c;
    --c;
    return ancienneCouleur;
}

#ifndef carte_h
#define carte_h
 
#include "rang.h"
#include "couleur.h"
 
struct Carte
{
 
    Rang rang;
    Couleur couleur;
 
    // La carte n'est pas initialisee
    Carte();
 
    Carte(Rang r, Couleur c);
 
    // Le constructeur de copie genere est correct
    // Le destructeur genere est correct
    // L'operateur d'affectation genere est correct
 
    Carte& operator++();
    Carte operator++(int);
 
    Carte& operator--();
    Carte operator--(int);
 
}; // struct Carte
 
bool operator<(Carte c1, Carte c2);
bool operator>(Carte c1, Carte c2);
 
#endif // carte_h

#include "carte.h"
 
Carte::Carte()
{
    // rien
}
 
Carte::Carte(Rang r, Couleur c)
: rang(r), couleur(c)
{
    // rien d'autre
}
 
Carte& Carte::operator++()
{
    if(rang==roi)
    {
        ++couleur;
    }
    ++rang;
 
    return (*this);
}
 
Carte Carte::operator++(int)
{
    Carte ancienneCarte = *this;
    operator++();
 
    return ancienneCarte;
}
 
Carte& Carte::operator--()
{
    if(rang==as)
    {
        --couleur;
    }
    --rang;
 
    return (*this);
}
 
Carte Carte::operator--(int)
{
    Carte ancienneCarte = *this;
    operator--();
 
    return ancienneCarte;
}
 
bool operator<(Carte c1, Carte c2)
{
    return (c1.couleur < c2.couleur || (c1.couleur == c2.couleur && c1.rang < c2.rang) );
}
 
bool operator>(Carte c1, Carte c2)
{
    return (c1.couleur > c2.couleur || (c1.couleur == c2.couleur && c1.rang > c2.rang) );
}

#include "carte.h"
 
#include <iostream>
 
int main()
{
        Carte c(roi, carreau);
 
        Carte c2 = c;
 
        ++c;
 
        std::cout << (c<c2) << " " << (c2<c) << std::endl;
}