Bonjour,
Par quel moyen il est possible de retourner un tableau de char, j'ai essayé plein de syntaxes, dont celle-ci:

char* retournerTableau()
{
    char monTableau[100] = {0, 1, 2, 3};
    return monTableau;
}

int main()
{

    char maChaine[100];
    maChaine = retournerTableau();
    return 0;
}

Sous Code::Blocks j'obtiens cette erreur (entre autres): error: incompatible types when assigning to type 'char[100]' from type 'char*'

Salut,

Le meilleur moyen est d'utiliser l'allocation dynamique. Tu trouveras des explications plus détaillées dans ma bio (un lien est disponible dans ma signature ).

Lorsqu'une variable est déclarée, la mémoire est allouée.
Puis, à la fin du bloc dans lequel la variable est déclarée, alors la mémoire est libérée et la variable, détruite.

En d'autres termes, lorsque la fonction "retournerTableau" se termine, le tableau qui est à l'interieur est aussi détruit !

Pour combler à ce problème, on alloue dynamiquement (manuellement) la mémoire.
Voici un exemple de code, mais je te conseilles d'aller voir le tuto qui en parle..

char* retournerTableau()
{
    // On alloue de la place pour 100 chars, on stocke l'adresse dans le pointeur "monTableau"
    char * monTableau = malloc(100 * sizeof(char));

    // On initialise le tableau
    monTableau[0] = 0;
    monTableau[1] = 1;
    monTableau[2] = 2;
    monTableau[3] = 3;

    // On retourne l'adresse
    return monTableau;
}

int main()
{
    // Va contenir l'adresse du tableau en mémoire
    char * maChaine;

    // On prend le tableau
    maChaine = retournerTableau();

    // Un petit test
    printf("test : %d\n", maChaine[3]);

    // On libere l'espace alloué précédemment
    free(maChaine);

    return 0;
}

Edit : grrr, grilled

Pour retourner une chaine de caractères il faut qu'elle soit alloué dynamiquement et à ce moment là tu feras une fonction qui retourne un char*
Comme ceci:

char* chaine(void)
{
    char* chaine = NULL;
    chaine = calloc(14, sizeof(char));
    sprintf(chaine, "Hello World !");

    return chaine;
}

Et surtout ne pas oublier de libérer la chaine allouée précédemment dans ton main avec: free(maChaine);

Et cette erreur: error: incompatible types when assigning to type 'char[100]' from type 'char*' c'est parce que tu fais un retour d'un tableau de char: char monTableau[100] alors que d'après ton prototype tu retournes un pointeur sur char

On ne peut pas retourner un tableau on retourne l'adresse du premier élément. On peut rusé en utilisant une structure par exemple.

Ici, c'est encore pire car le tableau est local à la fonction et donc il ne peut pas être retourner. Tu peux utiliser l'allocation dynamique ou encore passer le tableau en paramètre ou encore déclarer ton tableau en tant que variable static ou globale.

On peut copier un tableau grâce à memcpy, ici tu utilises des chaines donc autant utiliser strcpy :

char* retournerTableau()
{
    static char monTableau[100] = "Ache";
    return monTableau;
}
int main(void)
{
    char maChaine[100];
    stcpy(maChaine, retournerTableau());
    return 0;
}

Ou encore :

char* retournerTableau(char* chaine)
{
    char monTableau[100] = {0, 1, 2, 3};
    memcpy(chaine, monTableau, 100);
    return chaine;
}
int main(void)
{
    char maChaine[100];
    retournerTableau(maChaine);
    return 0;
}

une solution qui fonctionne:

#include <string.h>

char* retournerTableau()
{
  char monTableau[100] = {0, 1, 2, 3};
  return strdup(monTableau);
}

int main()
{
  char *maChaine;
  maChaine = retournerTableau();
  free(maChaine);
  return 0;
}

Citation : yannis51

une solution qui fonctionne:

#include <string.h>

char* retournerTableau()
{
  char monTableau[100] = {0, 1, 2, 3};
  return strdup(monTableau);
}

int main()
{
  char *maChaine;
  maChaine = retournerTableau();
  free(maChaine);
  return 0;
}

Bêtise + bug assuré + non portable .

J'ai utilisé strcpy() au final, merci pour tous vos conseils.