Bon un petit rappel pour commencer.

Rappel sur les fonctions en C

- En C les paramètres de fonction sont des recopies.
- A la fin d'une fonction les variables locales sont effacées.
- Par contre ce qui a pu être alloué dans la fonction n'est pas désalloué si ce n'est pas demandé explicitement.

Rappel sur les pointeurs

Un pointeur sert :
1- à modifier quelque chose qu'on aurait aimé passer en paramètre. Concrètement l'adresse est recopiée, mais pas ce qui est à cette adresse
2- à passer un paramètre plus petit (une adresse est plus rapide à recopier qu'une grosse structure)
3- à ne stocker qu'une fois qu'une donnée si on a besoin dans plusieurs structures.

Les allocations mémoires

En toute rigueur :
- à chaque malloc est associé un free situé dans le même horizon (un horizon est une paire d'accolade)
- parfois ce n'est pas possible donc on crée une sorte de constructeur qui fait l'allocation, et on pense à appeler le destructeur à la fin pour libérer la mémoire.

Les listes chainées

typedef struct maillon{
  struct maillon * suivant;
  int *data; // dans ton cas une tâche
} maillon_t;

typedef maillon_t * liste_t;

int inserer_tache(liste_t * l,int nouveau){
  maillon_t * mcur,mlast;
  for(mcur = l; mcur; mcur = mcur->suivant){
     if( *(mcur->data) == nouveau ) return 0; // deja présent dans la liste
  }
  // liste parcourue, on a rien trouvé ! ajout du nouveau maillon
  mcur->suivant = (maillon_t *)malloc(sizeof(maillon_t));
  mlast = mcur->suivant;
  mlast->suivant = NULL;
  mlast->data = nouveau;
  return 1;
}

#include <set>

// Definition d'une tache
struct tache_t{
  int x;
  tache_t(int x0=0):x(x0){}
};

// La relation d'ordre
bool operator<(
  const tache_t & t1,
  const tache_t & t2
){
  return (t1.x < t2.x);
}

int main(){
  std::set<tache_t> taches; // ensemble des taches
  tache_t t1(1),t2(5),t3(2);
  taches.insert(t1);
  taches.insert(t2);
  taches.insert(t3);
  return 0;
}