rappel sur sizeof() - Page 2

Ah, c'est génial

Sasume :
Je pense que PpHd parlait de l'utilisation du qualifieur static à l'intérieur d'une fonction (donc ton deuxième cas).

Ah peut-être... Mais pas moi

squale92
: pour les variables globales, static fait que leur portée est limitée au fichier où elles sont déclarées (en somme, ça en fait des variables globales locales à un fichier ^^ )

Exactement, ça s'appelle des variables globales non exportées, et donc ça reste des variables globales ^^

Tu devrais faire un tour sur fclc. Tu auais du succes

peut-être, mais moi j'ai rien inventé, je suis pas supposé deviner que t'as ta propre interpretation de "local" ^^

(une petite page qui explique tout ça très simplement, si besoin : ici ^^)

J'ai parle de trucs locaux, pas de variables locales

c'est vrai qu'un truc c'est tout de suite plus clair quand c'est local.

ahem

Perso je trouve plus pratique de faire ça :

typedef struct
{
// Ma strucutre ///
} OBJET;

OBJET **variable;

puis dans ton prog utiliser
set(variable,nombre);
...
free(variable);

avec
#define set(var,nb) ((var) = calloc((var), (nb) * sizeof(*(var))))
#define delete(var) (free(var))

Les avantages de la macro 'set' sont que tu ne te soucis pas du type de ta variable et que tu n'as pas besoin d'utiliser 'memset' pour mettre à 0 le contenue de ta variable

Par rapport au ./12, j'ai trouvé un élément de réponse : des problèmes peuvent se poser si deux structures s'utilisent mutuellement. Exemple :

// fichier a.h
#include "b.h"

typedef struct
{
  B *b;
}A;

// fichier b.h
#include "a.h"

typedef struct
{
  A *a;
}B;

(je n'ai pas écrit les directives pour éviter l'inclusion multiple par souci de simplicité)
A la compilation un problème se posera parce que lorsque le fichier a.h sera parsé, il inclut le fichier b.h qui définira le type B mais qui ne pourra pas le faire parce que le type A ne sera pas encore défini.

Le problème peut se résoudre comme ceci :

// fichier a.h
#include "b.h"

struct s_a
{
  struct s_b *b;
};

typedef struct s_a A;

// fichier b.h
struct s_a; // On n'inclut pas a.h

struct s_b
{
  struct s_a *a;
};

typedef struct s_b B;

Et comme ça on résoud le problème
Cette solution n'aurait pas pu être appliquée si on avait directement définit le type A sans définir la structure s_a.
Je me trompe ?
J'avais pensé à un truc de ce genre (pas joli joli) :

// fichier b.h
struct foo;
typedef struct foo A;

typedef struct
{
  A *a;
}B;

Mais évidemment ça ne fonctionne pas parce qu'après avoir parsé les fichier a.h et b.h on se retrouve avec deux définitions pour le type A qui sont différentes.

En tout cas, je dois maintenant réorganiser pas mal de mes fichiers sources maintenant :/

on peut très bien faire directement

typedef struct foo A;
typedef struct bar B;

struct bar
{
A *a;
};

Le "A *a" sera traduit en "struct foo *a" et le compilateur C (ou C++) l'acceptera même s'il n'a jamais entendu parler de la structure foo avant (puisqu'il sait que c'est une structure).
Per contre, si on retire l'étoile, il gueulera "incomplete type"...

et

#ifndef FOO_DEFINED
#define FOO_DEFINED
typedef struct foo FOO;
#endif

?

Link :
on peut très bien faire directement

typedef struct foo A;
typedef struct bar B;

struct bar
{
A *a;
};

Le "A *a" sera traduit en "struct foo *a" et le compilateur C (ou C++) l'acceptera même s'il n'a jamais entendu parler de la structure foo avant (puisqu'il sait que c'est une structure).
Per contre, si on retire l'étoile, il gueulera "incomplete type"...

Sauf que si une unité de traduction utilise la structure A et la structure B, autrement dit si elle inclut a.h et b.h, elle se retrouvera avec deux définitions de types différentes pour A (une dans a.h et une dans b.h [qui correspondrait au code que tu as donné]).

dans ce cas, on ajoute simplement les gardes de pollux...