In function `contexte':  
49 [Warning] return makes integer from pointer without a cast  
49 [Warning] function returns address of local variable

In function `main':  
58[Warning] passing arg 1 of `affiche' makes pointer from integer without a cast
 
je suis quand meme content parce que mon programme compile mais au moment de l'executer: Oh malheur... il me renvoie n'importe quoi.
Son but en fait est pour un mot (ici abracad) de me renvoyer trié par ordre alphabétique pour chaque lettre ce qu'il y a avant la lettre donnée:
ainsi on peut diviser abracad comme ca:
 
 
1 a -> \0                                                                    a->\0
2 b -> a                                                                     b->a
3 r -> ba                                                                    d->acarba
4 a -> rba          et renvoyer un liste triée ainsi                 c->arba
5 c -> arba                                                                 r->ba
6 a -> carba                                                               a->carba
7 d -> acarba                                                              a->rba
 
plutot que de trier directement les ce qui serait très gourmand en mémoire je prefère utiliser les indices d'où la création du tableau c que j'essaye de trier en fonction de l'ordre lexicographique de mon mot t.
Je pense que mon erreur vien du fait que j'aurais du faire un malloc quelque part mais le problème c'est que je ne sais pas ou ni comment (j'ai vraiment du mal avec malloc)
donc si quelqu'un pouvait m'aider à faire marcher ce programme (et en bonus en m'expliquant ce qui ne va pas) je lui en serais super reconnaissant.

grave

Très grave

grave

Il n'y a pas de quoi. Il y a 3 warnings graves qu'il faut absolument expliquer et corriger.
 
Quelques éléments de réponses (-ed-). /!\ Le code n'est pas corrigé./!\  

#include <stdio.h>
#include <stdlib.h>
 
/* -ed- manquait pour strlen() */
#include <string.h>
 
void affiche(int t[], int n)
{
   int i;
 
   printf("Voici le tableau \n" );
   for (i = 0;i < n;i++)
      printf("Element %d : %d \n", i, t[i]);
}
 
/* -ed-
int contexte( char *t) //tri contexte
 
la fonction ne modifiant pas le tableau entre, on peut ajouter le qualificateur const.
*/
int contexte( char const *t) //tri contexte
{
   /* -ed-
   int p, q;
 
   variables non utilisees.
   */
   int longueur = strlen(t);
   int i;
 
   /* -ed-
 
      Ceci est un tableau local. Son adresse est inutilisable en dehors de la
      fonction.
 
      De plus il a ete alloue automatiquement selon la specification VLA de C99
      qui n'est officiellement pas au point sur gcc.
   */
   int c[longueur];
 
   for (i = 0;i < longueur;i = i + 1) //création du tableau avec les indices de contextes
   {
      c[i] = i;
   }
 
   int perm;
   int temp;
   do
   {
      int limit = longueur - 2;
      perm = 0;
      for (i = 0; i <= limit; i++)
         if (t[c[i]] > t[c[i + 1]])
         {   /* permutation */
            temp = c[i];
            c[i] = c[i + 1];
            c[i + 1] = temp;
            /* il y a eu permutation */
            perm = 1;
         }
      ; /* fin du if et du for ! */
      limit--; /* le plus grand est a la fin donc on
                                         peut s'arreter au precedent */
   }
   /* si il a eu permutation on n'est pas trie donc on continue */
   while (perm);
 
   /* -ed-
      Le type retourne' est int. Il devrait etre int *.
      Mais meme en admettant que le type de retour soit int*,
      retourner l'adresse d'un tableau local n'a aucun sens,
      car cette adresse n'est plus valable apres execution de la fonction.
 
      Il y a donc un grave probleme de conception.
 
      Soit on passe l'adresse d'un tableau alloue par l'appelant, soit on
      retourne l'adresse d'un bloc alloue dynamiquement que l'appelant doit
      ensuite liberer.
 
    */
   return c;
}
 
int main(int argc, char *argv[])
{
   char const *t = "abracad";
   int n = strlen(t);
   int p = contexte(t);
 
   affiche(p, n);
 
   system("PAUSE" );
   return 0;
}

Il y a en effet quelques problèmes importants. ne confond pas adresse et valeur, tes retours de fonctions renvoient forcément un peu n'importe quoi. De plus ta définition de c[longueur] n'est pas très classe et ca m'étonne que ca compile. Utilise plutot une définition avec un malloc.
Quand tu utilise strlen utilise le type size_t (qui est en unsigned int et non en int) ca t'évitera bien des warnings mais sache qu'il va falloir changer pas mal de trucs dans ton code.

Le "je suis quand meme content était ironique"
que dois-je changer?
qu'est ce qui ne va pas c'est justement pour ca que j'aurais besoin d'aide:  
le malloc c'est encore du chinois pour moi je n'arrive jamais à savoir où quand et comment l'utiliser.
 

je n'ai pas très bien compris la différence entre unsigned int et int.
 

bin je sais pas moi, lis ton code ?
 
ta fonction renvoie un int et toi tu lui demande renvoie un int[], tu vois pas qu'il y a une couille dans le gigot ?

Sans moquerie, fait tu la différence entre int * et int ?
Si ce n'est pas le cas alors reprend un bouquin avant de continuer

oui int * designe un pointeur et int un simple entier jusque là ca va à peu près

bon alors en relisant ton code on voit bien que quand tu renvoie c de ta fonction contexte tu renvoie une adresse car c est un pointeur.donc la définition de ta fonction est mauvaise et la façon dont tu récupere le retour de ta fonction l'est aussi

 
 
En gros la taille d'une string sera toujours supérieure ou égale à 0, donc ca sert a rien d'avoir un entier signé. Ainsi le type size_t donne un entier non signé qui offre une plus grande taille positive et évite d'avoir un bit inutile sur le codage de la taille.
 
 
De plus au lieu de faire ton

 qui est très moche il faudra préférer un  

ce que ca fait, ca alloue une zone mémoire commençant à l'adresse c, et permettant de stocker longueur éléments int.

 
en modifiant mon code ainsi je n'ai plus de [Warning]
j'ai juste un problème avec l'algorithme de tri mais je pense que j'aurais moins de mal à le modifier.
Merci de votre aide qui m'a aider à y voir plus clair.
 
EDIT: je n'avais pas vu ton message caddie, je vais essayer egalement de faire les modification que tu me conseille ca m'aidera je suis sur à mieux comprendre.

Attention. Ce genre de citation est dangereuse lorsque le contexte n'est pas précisé. Ce n'est absolument pas un texte officiel ou généraliste, mais ce qui se passe pour une implémentation donnée.
 
Le langage C dit qu'un int a une plage minimale garantie de -32767 à 32767, alors que pour un unsigned int , elle est de 0 à 65535. En réalité, pour un implémentation donnée, les plages sont respectivement
 
INT_MIN à INT_MAX et 0 à UINT_MAX. Ces valeurs sont définies dans <limits.h>

Ce n'est toujours pas bon.  
Tu ne fais pas de free après ton malloc. Ce qui est grave c'est de ne pas en prendre l'habitude. Une fois que tu as fini d'utiliser les données stockées dans l'espace réservées par malloc il faut restituer l'espace mémoire au système.
à l'aide d'un free

 
Merci pour la précision !