problème avec une chaine de caractère en static

Bonjour,
j’écris actuellement un programme qui récupère (dans un fichier) puis traite de longues chaines de caractère. Pour cela j’utilise une procédure dans laquelle je déclare une chaine de la façon suivante:

Code:

---

char *tampon = (char *)malloc(1000*sizeof(char));

---

Comme j’ai besoin de conserver le contenu de la chaine entre 2 appels de ma procédure, je souhaiterais la déclarer en static comme ceci:

Code:

---

static char *tampon = (char *)malloc(1000*sizeof(char));

---

Mais j’obtient l’erreur de compilation suivante:

Code:

---

erreur: un élément de l'initialisation n'est pas une constante

---

Avez-vous une idée?

À savoir: en déclarant ma chaine comme un tableau de caractère, ça fonctionne, mais cette solution ne m’arrange pas.

Code:

---

static char tampon[1000];

---

Merci pour l’aide que vous pourrez m’apporter.

Est-ce déclaré à l'intérieur du corps d'une fonction ou à l'extérieur ?

Le message est clair pourtant.
Ca veut dire qu'une variable qui est initialisée lors de la déclaration avec le mot clé "static" doit être de type constante.

Citation:

---

Envoyé par Bayard

Est-ce déclaré à l'intérieur du corps d'une fonction ou à l'extérieur ?

---

La déclaration que nous montre le P.O est forcément faite à l'intérieure d'une fonction. A l'extérieure c'est impossible.

Citation:

---

Envoyé par EdXray

Code:

---

char *tampon = (char *)malloc(1000*sizeof(char));

---

---

Le cast sur le "malloc" n'est pas nécessaire en C.
La taille d'un "char" ne peut pas valoir autre chose que 1.
Ce code peut donc être réduit à ceci :

Code:

---

char *tampon = malloc(1000);

---

Citation:

---

Envoyé par Bayard

Est-ce déclaré à l'intérieur du corps d'une fonction ou à l'extérieur ?

---

Peu importe, le problème est le même.

Citation:

---

Envoyé par EdXray

Comme j’ai besoin de conserver le contenu de la chaine entre 2 appels de ma procédure, je souhaiterais la déclarer en static comme ceci:

Code:

---

static char *tampon = (char *)malloc(1000*sizeof(char));

---

Mais j’obtient l’erreur de compilation suivante:

Code:

---

erreur: un élément de l'initialisation n'est pas une constante

---

---

La méthode barbare que tu utilises est peu recommandable (comment tu libères ? comment tu instancies ?)

Mais si tu y tiens, voici comment faire (les variables static ne peuvent être initialisée que par des expressions constantes) :

Dans une fonction (ou non) :

Code:

---

static char *tampon;

---

dans une fonction (la même si tampon est définie dans une fonction)

Code:

---

1 2 3 4 5 6 7 8 9 10 11

{ if (tampon == NULL) { tampon = malloc (1000 *sizeof *tampon); if (tampon != NULL) { /* ... suite ... */ } } }

---

mais, sauf dans de rares cas, tout celà est du domaine de la bidouille infâme. Tu devrais apprendre à programmer par contextes (structures) et donc à écrire du code réutilisable et instanciable (séparation du code et des instances des données).

Merci à tous pour votre aide si rapide!

Citation:

---

Envoyé par Emmanuel Delahaye

mais, sauf dans de rares cas, tout celà est du domaine de la bidouille infâme. Tu devrais apprendre à programmer par contextes (structures) et donc à écrire du code réutilisable et instanciable (séparation du code et des instances des données).

---

Je ne connais pas encore ttes les ficelles de C mais la propreté de mon code est ma priorité. Pourrais tu m’expliquer en qq mots ce qu’est la programmation par contextes? Je pensais que le mot instanciation était réservé à la programmation objet...

Citation:

---

Envoyé par EdXray

Je ne connais pas encore ttes les ficelles de C mais la propreté de mon code est ma priorité. Pourrais tu m’expliquer en qq mots ce qu’est la programmation par contextes? Je pensais que le mot instanciation était réservé à la programmation objet...

---

Il est fréquent que l'on ait besoin de données persistantes dans une code. Pour ça, on définit les données soit comme variable locale

Code:

---

1 2 3 4 5

void f () { T var; }

---

soit comme variable dynamique :

Code:

---

1 2 3 4 5

void f () { T* p_var = malloc (sizeof *p_var); }

---

et ensuite, on passe l'adresse de la variable aux fonctions qui en ont besoin :

Code:

---

1 2 3 4 5 6 7

void f () { T var; g (&var, ...); h (&var, ...); }

---

ou, en dynamique :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

void f () { T* p_var = malloc (sizeof *p_var); if (p_var != NULL) { g (p_var, ...); h (p_var, ...);     /* quand c'est fini */ free (p_var), p_var = NULL; } }

---

Les fonctions g() et h() ont pour prototype (par exemple)

Code:

---

1 2 3

/* lecture / écriture */ void g(T *p);

---

ou

Code:

---

1 2 3

/* lecture seule */ void h(T const *p);

---

T est un type qui peut être simple ou composé (tableau, structure)

Le gros avantage de ce type de codage est que l'on peut créer plusieurs instances des données qui utilisent le même code, ce qui est impossible avec une statique.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

void f () { T var_a; T var_b;   g (&var_a, ...); h (&var_a, ...);   g (&var_b, ...); h (&var_b, ...); }

---

C'est comme ça que fonctionne FILE*, par exemple...

Pour aller plus loin :

http://emmanuel-delahaye.developpez.com/tad.htm