Le mini projet de C+\+ se fait à titre individuel sur l’un des sujets proposés. Chaque étudiant rendra le code propre du programme qui devra être compilable et exécutable ainsi qu’une à quelques pages de rapport pour soutenir votre code, la façon dont il a été réalisé, les problèmes rencontrés, ou tout autre information que vous jugerez pertinente pour son évaluation. Les mini projets de C+\+ de 2007 devront être rendus avant Noël. Le mini projet constitue l’un des éléments de la notation.
Le code pourra être exécutable sous GNU/Linux ou Windows.
Parmis les éléments du barême de notation de la propreté du code figurent :
une indentation cohérente ;
un code correctement commenté : des commentaires dupliquant une simple ligne de code sont inutiles, un commentaire descriptif sur chaque fonction des en-tête important, des boucles imbriquées sont souvent complexes à comprendre ;
une séparation claire entre les prototypes et l’implémentation ;
découpage des trop grosses fonctions en petites fonctions ;
utilisation d’espace de noms.
N’hésitez pas à utiliser un Makefile ou autre fichier projet pour faciliter la compilation plutôt que de taper les commandes dans un terminal. L’utilisation de programmes de tests pourra être un plus, en particulier pour vérifier votre code (fournissez-les).
Le C+\+ fournit une classe de manipulation de chaîne de caractères au travers de la bibliothèque STL: std::string. Dans ce mini-projet vous devrez réécrire une classe manipulant les chaînes de caractères sans vous servir de la STL ni d’aucune autre bibliothèque mais en utilisant uniquement un tableau de char (comme en C). Nommez votre classe String, elle devra comporter au strict minimum les méthodes suivantes :
class String { public: /** Create a new empty String. */ String(); /** Create a String initialized with the given string. */ String(const char* src, int len=-1); /** Copy constructor. */ String(const String& src); int length() const; String& operator=(const String& src); String& operator+(const String& src); char& operator[](int pos); bool operator==(const String& s) const; };
Écrivez des exemples d’utilisation de votre classe avec toutes ces méthodes. N’hésitez pas à rajouter les méthodes qui vous semble nécessaire. Pour les champs privés ou protégés, vous devrez évidemment avoir au moins un tableau (pointeur) de caractères ainsi que le taille de ce tableau dynamiquement alloué. Gérez la mémoire pour libérer le tableau une fois son utilisation terminé.
Si vous ne souhaitez pas réécrire vos propres fonctions pour copier des chaînes de caractères, utilisez les fonctions de string.h: memcpy(void*, const void*, size_t), etc.
Le but est de poursuivre l’algorithme de Lee implémenté lors du TP 6. Le routage devra désormais être possible sur plusieurs niveaux. Les grilles de composant devront être lues depuis un fichier comme précédemment mais en étendant le format pour le rendre multi-niveaux. L’interface graphique ne doit pas être étendue mais une nouvelle façon de visualiser le résultat et les étapes intermédiaires doit être prévue, par exemple en affichant la grille sur la sortie standard ou dans un fichier.
Veillez à vérifier votre programme qui devra être robuste à toutes les configurations possibles. Par exemple si l’utilisateur sélectionne deux points qui ne peuvent être reliés, éviter les débordements en dehors des plaquettes, etc. N’hésitez pas à créer des bouts de code uniquement destiner à tester le programme.
En SystemC (ou non), créez un automate cellulaire de dimension 1. Un automate cellulaire en dimension 1 est un tableau de cellules étant chacune activée ou désactivée. À chaque itération on met à jour chacune des cellules en fonction de son état et de ses voisines. Veillez à afficher l'état de chacune des cellules de façon à obtenir une trace visuelle. Par exemple en utilisant la règle (0,0,0 ⇒ 0) (0,0,1 ⇒ 1) (0,1,0) ⇒ 0) … si l’une des cellules contient la valeur 1 et que ses deux voisines sont à 0, alors la cellule passe à 0 en appliquant le troisième élément de la règle.
L’ensemble des cellules doit être mis à jour en parallèle. Les cellules en début et fin qui n’ont donc qu’une seule voisine sont associées pour être voisines.
Choisissez un ensemble de règle pour votre automate cellulaire sur le web et vérifiez que vous obtenez les bonnes traces. Veillez cependant à pouvoir charger n’importe quel type de règles en les lisant depuis un fichier par exemple.
Cet exercice peut aussi être fait en C+\+ sans utiliser SystemC.
Cet exercice peut être fait avec ou sans SystemC.
Le but est de créer un mini processeur capable d’exécuter quelques instructions lues depuis un fichier d’entrée et chargées en mémoire. Le système à modéliser et implémenter et constituer d’une bande de mémoire (tableau) dans laquelle est placé le programme à exécuter à l’adresse 0. Le processeur lit la première instruction en mémoire, l’exécute et passe à la suivante, jusqu'à rencontrer l’instruction exit qui termine le programme. Le processeur possède quelques registres et instructions de test et saut.
Un exemple de 16 octets que votre programme devra être capable d’exécuter ainsi que le bytecode correspondant et sa description.
mov eax, 2 10 02 Met 2 dans le registre EAX mov ebx, 3 11 03 Met 3 dans le registre EBX add eax, ebx 21 Ajoute la valeur de EBX à EAX cmp eax, 0 50 00 Compare la valeur de EAX à zéro je 6 61 08 Saute à l'exit (EIP + 6) si comparaison vraie putc '.' 80 2e Affiche '.' sur la console sub eax, 1 40 01 Enlève 1 au registre EAX jmp 6 60 08 Saute en arrière de 6 octets (au cmp) exit 00
Ce qui correspond au code C suivant :
int main() { int a = 2; int b = 3; a += b; while (a != 0) { putc('.'); a--; } exit(); }
À vous de vous occuper de créer un chargeur de programme en mémoire ainsi que le processeur accompagné de ses registres qui se charge de l’exécution.
Veillez à utiliser des classes ou des modules (en SystemC). En particulier séparez le processeur de la mémoire et de la console.