problème syntaxe structure tableau pointeur en c

[invite7ade7f5a]

Bonjour tout le monde,
j'ai une probleme avec la syntaxe en c
j'ai crée une structure qui est la suivante :

typedef struct {
	int taille;
	int lmax;
	int *tab;
}liste;

je veux utiliser tab comme un pointeur sur le début d'un tableau après avoir alloué la mémoire a ce dernier avec une fonction :

void creerliste(liste *l){
	do{
	printf("donner la taille de la liste : ");
	scanf("%d", &l->taille);
	printf("donner la taille maximal de la liste : ");
	scanf("%d", &l->lmax);
	}while(l->taille>l->lmax);
	l->tab=(int*)malloc(l->lmax*sizeof(int));
}

mes question son :
es-que ma fonction allocation est juste?(le compilateur n'affiche aucun erreur)
comment je peux accéder a la valeur le chaque élément du tableau et a son adresse ?
j'ai pensé ça mais ça n'a pas marché

l->(tab+i)
l->*(tab+i)

merci beaucoup pour vos réponses
-----

[CM63]

Bonjour,

Ca me paraît bon. Mais dans le main il faut faire:

liste ma_liste;
creeliste(&ma_liste);

Et ensuite, toujours depuis le main, pour utiliser un élément du tableau, tu feras:

ma_liste.tab[i];

Ok?

[inviteb9f49292]

Et pour faire comme les pros, tu fais une "vraie" fonction d'allocation:

liste* liste_alloc (int taille, int taille_max) {
    if (taille_max < taille) {
        return NULL;
    }
    liste * l = malloc (sizeof (liste));
    if (NULL == l) {
        return NULL;
    }
    l->taille = taille;
    l->taille_max = taille_max;
    l->tab = malloc (taille_max * sizeof (int));
    if (NULL == l->tab) {
        free (l);
        return NULL;
    }
    return l;
}

tu dois faire un libérateur (qui va appeler le "free" sur le champ "tab" puis sur l'ensemble de la structure), des accesseurs et tu passes en structure opaque. Sur une petite structure simple comme ça on peut discuter des heures: faire un seul appel à "malloc", remplacer la structure par un tableau avec deux cases supplémentaires à la fin pour y placer "taille" et "taille_max", tu peux alors utiliser ton tableau de manière transparente...
Dernier conseil, sépares tout ce qui est entrés utilisateurs du reste du code, en gros fait tes "scanf" dans des variables que tu vas passer à ta fonction. C'est un principe de base pour éviter de réécrire un allocateur pour chaque "type" d'entrée, ou même si tu dois en créer de manière "automatique" (dont tu connais les taille sans demander à l'utilisateur).

[invite7ade7f5a]

Bonsoir,
un grand merci pour avoir éclairé ma lanterne
CM63:

Et ensuite, toujours depuis le main, pour utiliser un élément du tableau, tu feras:

Code:
ma_liste.tab[i];
Ok?

ça a fonctionné nickel
pour lou_ibmix_xi j'ai lu scrupuleusement votre poste et j'ai quelques questions :

liste* liste_alloc (int taille, int taille_max) {

pourquoi le liste* au début un void pourrai il fonctionner ?

return NULL;

pourquoi a chaque fois qu'une condition nécessaire n'ai pas satisfaite ? pour versifier si tout s'est bien passé ?

return l;

qu'elle est l'utilité ?
comment utiliser la fonction crée?

accesseurs et tu passes en structure opaque

quesqu’un accesseur et une structure opaque (j'ai cherché sur google et rien) ?
et enfin
j'ai suivis vos conseille que j'ai trouvé très constructif, svp pouvez vous m'en dire plus sur les règles de bases pour bien écrite ces programme
j’espère que j'ai pas abusé de question,
merci encore

[A voir en vidéo sur Futura]

[inviteb9f49292]

J'ai peut être taper un peu haut par rapport à ton niveau... Je vais essayer de clarifier ta lanterne:
L'intérêt de la fonction que je t'ai écrite est qu'elle "cache la complexité" de l'allocation d'une instance de ta structure, ainsi, l'utilisateur de ta structure n'a pas à réécrire à chaque fois la même suite de fonctions pour allouer une instance, il fait juste appelle à la fonction qui fait le boulot. Simplement pour pouvoir utiliser le pointeur sur l'instance nouvellement allouée, il faut bien le ressortir de la fonction, le plus naturel étant par la valeur de retour, c'est comme pour malloc qui renvoie un type générique, tu as fait un allocateur mais spécifiquement pour ta structure.
Et lorsqu'il y a un problème d'allocation, il faut spécifier à l'utilisateur qu'il n'a pas d'instance, là encore la manière la plus naturelle de faire est de retourner la valeur spécifique NULL qui correspond à un pointeur "interdit". Donc, l'appel à l'allocateur devrait ressembler à:

liste* nouvelle_liste = liste_alloc (10, 20);
if (NULL == nouvelle_liste) {
    /* l'allocation a echoue, gerer l'erreur */
} else {
    /* l'allocation a reussi */
    liste_libere (nouvelle_liste);
}

Digère déjà ça, et on pourra continuer après...