La classe CharSequence représente maintenant une chaine constante.

Gestion de l’affectation des objets

Opérateur d’affectation

Ecrire le main suivant :

int main (){
    CharSequence s1 ("one more time"); // 1
    CharSequence s2 ("sample string"); // 2
    s2 = s1 ; // 3
    s2.debug();
}

Que se passe-t-il en 3 ? Vérifier la mémoire avec valgrind. Inspecter les instances en utilisant gdb.

Pour redéfinir l’opérateur d’affectation, il y a deux prototypes :

const CharSequence &operator=(const CharSequence &);

ou

CharSequence operator=(const CharSequence &);

• Pourquoi est-il préférable de choisir le premier ?
• Dans notre cas, que fait le code de l’opérateur ? Implémenter celui-ci.
• Vérifier votre code final avec valgrind.

Opérateur []

Nous voulons écrire le code suivant :

int main (){
    CharSequence s ("I did it again");
    for ( int i = 0; i < s.length() ; i ++)
    	printf ("%c\n", s[i]);
}

Pour cela, il est nécessaire de redéfinir l’opérateur[]. Il y a deux prototypes:

char operator []( unsigned int indice );

// ou

char & operator []( unsigned int indice );

Dans quel cas peut-on écrire l’instruction suivante s[3] = 'Z'; ? Pourquoi ? Dans notre cas (chaine constante) quel prototype est-il préférable ? Voyez-vous un troisième prototype possible ? Essayer d’utiliser l’opérateur dans la fonction foo du début du TD. Modifier.

Opérateur de conversion

Nous voulons pouvoir écrire le code suivant :

int main (){
    CharSequence s ("one more time");
    printf("%s\n", (const char *) s );
}

Pour cela, il est nécessaire de redéfinir l’opérateur de conversion. La valeur de retour de cet opérateur pose-t-elle problème ?

Opérateur + de concaténation

Ecrire dans la classe CharSequence l’opérateur d’addition effectuant la concaténation de deux chaînes de caractères.

Cet opérateur ne modifiera pas les deux chaînes concaténées et renverra donc une nouvelle chaîne.

Exercice hors séance : Surcharger cet opérateur tel que l’on puisse concaténer une chaîne et un entier. Pour cette version, vous pourrez utiliser une variable static interne servant de buffer. Quels sont les dangers d’une telle solution ?