Bonsoir,

je suis élève ingénieur je fais maintenant mon sujet de TP mais j'ai eu des difficultés en traduisant un algorithme en C++ .

1. Traduire en langage C++ le type couple et les operations permuterCouple, saisirCouple, libererCouple donnes ci-apres. Preciser la precondition des operations dans les commentaires de code, et utiliser une instruction assert pour la verifier lorsque cela est possible 

type Couple  =  Enregistrement 
          ltr   :  Caractere
          ptr  :  Pointeur vers Caractere 
Fin Enregistrement 

procedure  permuterCouple (m  c :  Couple ) 
         Variable 
                   tmp ←  c . ltr
                   c . ltr ←  memoire ( c . ptr) 
                   memoire ( c .  ptr )  ←  tmp 
fin 

fonction saisirCouple () : Couple 
        variable 
                 duo  :  Couple 
         debut 
                     duo . ptr ← allocation ( Caractere )
                     lire duo . ltr , memoire ( duo . ptr ) 
                     retourner duo
         fin 


procedure  libererCouple ( m  c  :  Couple ) 
             debut 
                       desallocation ( c  .  ptr )
                       c .  ptr  ←   NULL
             fin

-
Edité par KarimObeid 22 février 2024 à 21:24:33

Montre ce que tu as fait, on t'aidera a corriger.

Et ton message est illisible

gbdivers a écrit:

Montre ce que tu as fait, on t'aidera a corriger.

Et ton message est illisible

#include <iostream>
#include <cassert>

struct Couple {
    char ltr;
    char* ptr;
};

// Précondition : c.ptr doit pointer vers une zone de mémoire allouée
void permuterCouple(Couple& m, Couple& c) {
    char tmp = c.ltr;
    c.ltr = *(c.ptr);
    *(c.ptr) = tmp;
}

Couple saisirCouple() {
    Couple duo;
    duo.ptr = new char;
    std::cout << "Entrez un caractère : ";
    std::cin >> duo.ltr;
    std::cin >> *(duo.ptr); 
    return duo;
}

void libererCouple(Couple& m, Couple& c) {
    delete c.ptr;
    c.ptr = nullptr;
}

int main() {
    Couple couple1, couple2;
    couple1 = saisirCouple();
    couple2 = saisirCouple();

    permuterCouple(couple1, couple2);
    libererCouple(couple1, couple2);
    return 0;
}

Bon ... 

Si l'on admet que la librairie standard est interdite (c'est trop souvent le cas), ce code pose problèmes:
L'operateur New peut échouer, il convient d'intercepter l'exception éventuelle.
La précondition invoquée pour la fonction permuterCouple n'a pas de sens, en effet, il est impossible de vérifier la validité d'un pointeur nu.
Il aurait été avisé de fournir des opérateur à la structure Couple (assignation, copie).
La fonction saisirCouple viole le SRP et la loi de Déméter (elle instancie un couple, instancie le pointeur interne du couple,  et le saisit).
Instancier le pointeur interne est la tâche de la structure.
Même sans utiliser les pointeurs intelligents de la STL, tu peux écrire une classe RAII qui encapsule les pointeurs nu.

Si on peut utiliser la STL:
La classe std::pair remplacera la structure Couple.
La classe std::unique_ptr remplacera le pointeur nu.
La fonction std::make_unique remplacera l'operateur new.
L'operateur delete sera obsolète.
La fonction std::swap permet de permuter 2 variables.

C'est pas bien clair tout ça ? Qu'est-ce "m" ? Ni dans l'algo, ni dans le code tu t'en sert ? 

C'est quoi que tu veux échanger ? Deux objets couple où seulement le membre ltr avec le char pointé par ptr d'un couple ?