Salut,

Je voulais savoir, pour récuperer la taille d'un tableau de charactère, mon prof m'a dit que c'était pas possible

Puis dans le livre de Claude Delannoy

J'ai vu qu'on pouvait faire par exemple

taille = sizeof(t)/sizeof(t[0]);

Du coup, je pense qu'il y a des cas où c'est pas possible, et des cas où c'est possible. Je pense que ça doit être possible qu'avec les tableau statiques mais pas avec les tableau alloués dynamiquement, c'est ça ? Si oui pourquoi ? Si non pourquoi ?

Quelqu'un pour m'expliquer ça plus précisement svp ?

Merci pour vos réponses

Tu parles d'un tableau de caractères ou d'un tableau?
Si tu veux connaître la taille d'un tableau statique, bah tu le connais déjà puisque t'as dû l'allouer avec une variable constante
Si tu veux connaître le nombre de caractères dans une chaîne de caractères, il faut compter dans le tableau un par un chaque caractère jusqu'à ce que le caractère soit nul (le caractère nul indique la fin d'une chaîne de caractère)
Après, l'exemple de Delannoy permet de connaître, en bytes, la taille d'un tableau statique
Pour les vector, il suffit d'utiliser la méthode size()

J'ai dit un tableau de caractère dans mon premier post parce que j'avais ça en tête, mais en fait je voulais dire un tableau en général, que ce soit un tableau de caractère, ou tableau d'un type primitif, ou un tableau de structure

Par exemple si je fais

int main(void)
{
type* t = malloc(sizeof(type)*65);

remplir(t);

}

void remplir(type* t)
{

}

Purée, tab, m'a encore eu

donc :

int main(void)
{
type* t = malloc(sizeof(type)*65);

remplir(t); // obligé de faire remplir(t, 65) ?
}

void remplir(type* t) // Obliger de prendre la taille en parametre ?
{
int taille = sizeof(t)/sizeof(t[0]);

for(i = 0; i < taille; i++)
t[i] = 4;
}

Voilà, alors dans quel cas cet esprit peut s'appliquer ? Parce que là je pense que sizeof(t) vas retourner la taille en byte d'un type*, donc la taille d'une case memoire pouvant contenir une adresse d'une variable "type"

Il faut passer la taille en argument a la fonction remplir. Il n'y a pas d'autre moyen de savoir.

" que ça doit être possible qu'avec les tableau statiques mais pas avec les tableau alloués dynamiquement, c'est ça ? Si oui pourquoi ? Si non pourquoi ? "

Ce n'est effectivement possible qu'avec les tableaux statiques tout simplement parce qu'un opérateur sizeof() est directement remplacé par une constante au moment de la compilation, il faut donc que la taille du tableau soit connue au moment de la compilation, or ce n'est le cas qu'avec les tableaux statiques.

Si t'as un tableau statique "int tab[5]" quelque part dans ton code et un "sizeof(tab)" ailleurs dans ton code alors au moment de la compilation, pour le sizeof le compilateur va aller chercher "tab" dans sa table de symboles et va voir que cette variable est un tableau de 5 int, il pourra donc remplacer directement l'opérateur sizeof par la constante correspondante (ici 5 fois la taille d'un int).

En revanche dans le cas d'une fonction "void f(int t[])" là le symbole "t" n'est effectivement qu'un simple pointeur de int et fait la taille d'un mot, un "sizeof(t)" serait donc remplacé par une constante équivalent à la taille d'un mot au moment de la compilation.

Ha d'accord, je vois, merci, en relisant, c'est vrai qu'en fait, lorsqu'il fait :

taille = sizeof(t)/sizeof(t[0]);

et bien en fait c'est dans le main avec t qui est un tableau statique avec sa taille déjà renseigné

Merci

"Ce n'est effectivement possible qu'avec les tableaux statiques tout simplement parce qu'un opérateur sizeof() est directement remplacé par une constante au moment de la compilation, il faut donc que la taille du tableau soit connue au moment de la compilation, or ce n'est le cas qu'avec les tableaux statiques."

ya une exception: si le tableau est dynamique mais sur la pile, le sizeof se fait au runtime.

void foo (int size)
{
    int vla[size];
    printf( "size -> %d\n", sizeof(vla) );
}