Problème de logique

D'après ce qu'on me demande, les données ne sont pas persistées et sont donc stockées dans des tables statiques en mémoire

Tout ce qu'on m'a donné c'est ça :

#include "../src/themes.h"

static struct Theme themes[NB_THEMES_MAX];
static int nbThemes=0;

int supprimerTheme(int identifiant)
{
    return -1;
}

int supprimerTousLesThemes()
{
    return -1;
}

Et vu que c'est un projet de groupe, je sais pas comment les autres vont fonctionner donc j'dois me débrouiller avec ça et je vois pas comment je peux faire.

On vient de seulement de me donner le theme.h avec que je devais compléter dans celui-ci càd SupprimerTheme et SupprimerTousLesThemes:

#ifndef THEMES_H_INCLUDED
#define THEMES_H_INCLUDED
#include <string.h>
#define NB_THEMES_MAX 100

struct Theme {
    int identifiant;
    char libelle[50];
};

 // renvoie le nombre de themes stockés.
 int nombreThemes();

 // compare les 2 thèmes reçus en paramètre.
 // si ils ont le même identifiant et le même libellé, la fonction renvoie 1.
 // si ce n'est pas le cas, elle renvoie 0.
 int themesIdentiques(struct Theme theme1, struct Theme theme2);

 // compare les 2 thèmes reçus en paramètre. La comparaison se fait sur les libellés.
 // si le libellé du thème 1 se trouve avant le libellé du thème 2 dans l'ordre lexicographique, elle renvoie un nombre <0.
 // si le libellé du thème 2 se trouve avant le libellé du thème 1 dans l'ordre lexicographique, elle renvoie un nombre <0.
 // si les libellés sont identiques, elle renvoie 0.
 // Utilisez la fonction strcmp()
 int comparerThemes(struct Theme theme1, struct Theme theme2);

 // ajoute un theme.
 // cette fonction doit affecter un identifiant au thème reçu en paramètre.
 // elle renvoie l'identifiant affecté au thème.
 // si table est pleine, elle renvoie 0.
 int ajouterTheme(struct Theme theme);


 // garnit le tableau reçu en paramètre avec les thèmes stockés.
 void listerThemes(struct Theme themes[]);

 // recherche le libellé du thème dont on reçoit l'identifiant en paramètre
 // si le thème identifié est présent, on recopie son libellé dans le paramètre libelle. On renvoie 1.
 // si le thème n'est pas présent, on affecte une chaine vide au paramètre libelle. On renvoie 0.
 int rechercherLibelleTheme(int identifiant, char libelle[]);

 // modifie le libellé du thème identifié par l'identifiant reçu en paramètre.
 // si le thème est présent, son libellé est modifié. La valeur 1 est renvoyée.
 // si aucun thème ne correspond à cet identifiant, la fonction renvoie 0.
 int modifierTheme(int identifiant, char nouveauLibelle[]);

 // supprime un thème.
 // si l'identifiant reçu en paramètre correspond à un thème stocké, celui-ci est supprimé et elle renvoie 1.
 // si l'identifiant reçu en paramètre ne correspond à aucun thème stocké, elle renvoie 0.
 int supprimerTheme(int identifiant);

 // supprime tous les thèmes stockés.
 // renvoie le nombre de thèmes qui ont été supprimés.
 int supprimerTousLesThemes();

// garnit le tableau reçu en paramètre avec les thèmes triés de façon ascendante sur leur libellé.
 void listerThemesTries(struct Theme themes[]);


#endif // THEMES_H_INCLUDED

C'est tout ce que j'ai eu pour le moment du chef de groupe

C'est vrai qu'après réflexion, ça me posaient plus de problèmes que ça n'en résolvaient, mais ça restait bien pensé. Mais du coup je reviens un peu à la case départ...

woaw t'as une bonne vision d'ensemble, j'aurais jamais pensé à ça mais au final elle ne fait que garnir une table si j'en crois le code

 // garnit le tableau reçu en paramètre avec les thèmes stockés.
 void listerThemes(struct Theme themes[]);

utiliser

listerThemes()

, comme le propose yg_be est, en principe, une bonne chose car tu encapsules l'usage des données en renvoyant la responsabilité de déterminer ce qui est un identifiant d'un thème à cette fonction (question @yg_be: et cette fonction, comment fait-elle pour distinguer si un entier stocké dans le tableau de référence représente un identifiant ou représente un emplacement vide ?)

personnellement, malgré son nom suggestif et prometteur pour faire de l'encapsulation, je trouve son descriptif pas très convainquant... pour cela il faudrait que l'on ait l'assurance que la "garnissage" liste les éléments séquentiellement à partir de l'index 0 et jusqu'à l'index nbThemes-1 ... ce comportement, bien que raisonnable, n'est pas explicité, tout ce qu'on sait c'est qu'un tableau est "garnit avec les thèmes stockés", mais c'est peut-être une question que tu peux poser pour compléter la spécification de

listerThemes()

...

on voit aussi que la taille du tableau passé en paramètre n'est pas indiquée, et qu'il est probable que le tableau doive être un tableau de taille NB_THEMES_MAX et tout ce qu'on saura c'est que le tableau contient des emplacements pleins et des emplacements vides :-)

Après avoir réfléchis un peu, j'en suis là

#include "../src/themes.h"

static struct Theme themes[NB_THEMES_MAX];
static int nbThemes=0;

int supprimerTheme(int identifiant)
{
    // Declaration
    int i=0;
    int flag=0;
    // Traitement
    while(i<nbThemes && flag==0)
    {
        if(themes[i].identifiant!=identifiant) i++;
        else flag=1;
    }
    if (flag==1){
        //supprime le theme correspondant à l'identifiant
        return 1; // La fonction a supprimer le theme
    }
    else
    {
        return 0; // La fonction n'a pas trouve le theme
    }
    return -1;
}

Pour vous je suis bien parti ou je suis à côté de la plaque ? Et je vois pas comment faire pour supprimer l'identifiant et le libellé du thème concerné.

EDIT : Ajout des balises de code (la coloration syntaxique). Explications disponibles ici : ICI Merci d'y penser dans tes prochains messages.

Merci d'y penser dans tes prochains messages.

il n'est pas possible de vérifier ton code sans savoir ce que fait ajouterTheme().

voilà le code de la fonction ajouterTheme

int ajouterTheme(struct Theme theme)
{
    nbThemes=nombreThemes();
    theme.identifiant=nbThemes++;
    return theme.identifiant;
    nbThemes++;
}

Et ce qu'elle doit faire :

 // ajoute un theme.
 // cette fonction doit affecter un identifiant au thème reçu en paramètre.
 // elle renvoie l'identifiant affecté au thème.
 // si table est pleine, elle renvoie 0.
 int ajouterTheme(struct Theme theme);

D'après le code que tu as fourni, les thèmes sont stockés dans le tableau theme :

#define NB_THEMES_MAX 100

struct Theme {
    int identifiant;
    char libelle[50];
};
static struct Theme themes[NB_THEMES_MAX];
static int nbThemes=0;

L'implémentation de ajouterTheme() que tu reproduis en réponse à la question de yg_be n'ajoute pas le thème passé en paramètre au tableau themes.

A mon sens, elle est fausse.

De plus, elle confond l'identifiant correspondant à un libellé et le nombre actuel de thèmes, ce qui n'a rien à voir. Un identifiant est, par définition unique. Si tu ajoutes 2 thèmes et que tu retires le premier, et que en ajoutes un autre, nbThemes passera successivement de 0 à 1, 2, puis 1, puis 2. On voit bien que ces chiffres ne peuvent pas servir à identifier un libellé de façon unique. Si plusieurs libellés portent le même identifiant, lorsque tu voudras supprimer un libellé par son identifiant, tu ne sauras pas ce que tu supprimes.

Avant, ton code confondait identifiant de libellé et index de tableau... maintenant celui-ci confond identifiant de libellé et nombre de libellés...

Au lieu de toute cette confusion, vous pourriez vous forcer :
- à utiliser des entiers supérieurs à 100 comme identifiants
- à générer ces nombres aléatoirement
- à vérifier, avant d'utiliser le nombre généré aléatoirement, que celui-ci n'a pas déjà été utilisé pour un identifiant existant

L'idée d'utiliser des entiers aléatoires était juste une idée frappante pour marquer les esprits sur le fait que l'identifiant n'est pas l'index, ni le nombre d'éléments. Cela peut être n'importe quoi qui soit un entier unique par rapport aux autres identifiants existants et soit différent de 0, et si je comprend bien l'exercice, tu n'as pas à savoir exactement comment il est attribué, cette information devrait t'être cachée.

D'où vient le code de ajouterTheme() que tu reproduis en réponse à la question de yg_be ? Il est évident pour moi que cette implémentation n'ajoute pas le thème passé en paramètre au tableau themes.

Et si rien n'est ajouté ... tu ne peux pas supprimer ce qui n'y est pas.