Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Marc Boyer
Clarck wrote:
Bonsoir
Est-ce qu'en C, QUELQUE SOIT LE TYPE d'un tableau déclaré comme ceci : <type_elements_tableau> nom_tableau[nombre_elements]; ceci est vrai :
Je suis pas 100% sur de moi, mais à ma connaissance.
nom_tableau est équivalent à &nom_tableau[0] ?
Oui.
&nom_tableau[0] est équivalent à &nom_tableau ? nom_tableau est équivalent à &nom_tableau ?
Non, dans le sens ou &nom_tableau est un pointeur sur un tableau de nombre_elements élements, le sizeof et l'arithmétique des pointeurs qui va avec change.
#include <stdio.h> int tab[50];
int main(){ printf("%u %u", /* Normalement c'est %z, mais si ton compilo est aussi bien que le mien, prend %u */ sizeof( *(& tab ) ), sizeof( *(&(tab[0])) ) ); return 0; }
Marc Boyer -- Lying for having sex or lying for making war? Trust US presidents :-(
Clarck wrote:
Bonsoir
Est-ce qu'en C, QUELQUE SOIT LE TYPE d'un tableau déclaré comme ceci :
<type_elements_tableau> nom_tableau[nombre_elements];
ceci est vrai :
Je suis pas 100% sur de moi, mais à ma connaissance.
nom_tableau est équivalent à &nom_tableau[0] ?
Oui.
&nom_tableau[0] est équivalent à &nom_tableau ?
nom_tableau est équivalent à &nom_tableau ?
Non, dans le sens ou &nom_tableau est un pointeur sur
un tableau de nombre_elements élements, le sizeof
et l'arithmétique des pointeurs qui va avec change.
#include <stdio.h>
int tab[50];
int main(){
printf("%u %u", /* Normalement c'est %z, mais si ton compilo
est aussi bien que le mien, prend %u */
sizeof( *(& tab ) ),
sizeof( *(&(tab[0])) ) );
return 0;
}
Marc Boyer
--
Lying for having sex or lying for making war? Trust US presidents :-(
Est-ce qu'en C, QUELQUE SOIT LE TYPE d'un tableau déclaré comme ceci : <type_elements_tableau> nom_tableau[nombre_elements]; ceci est vrai :
Je suis pas 100% sur de moi, mais à ma connaissance.
nom_tableau est équivalent à &nom_tableau[0] ?
Oui.
&nom_tableau[0] est équivalent à &nom_tableau ? nom_tableau est équivalent à &nom_tableau ?
Non, dans le sens ou &nom_tableau est un pointeur sur un tableau de nombre_elements élements, le sizeof et l'arithmétique des pointeurs qui va avec change.
#include <stdio.h> int tab[50];
int main(){ printf("%u %u", /* Normalement c'est %z, mais si ton compilo est aussi bien que le mien, prend %u */ sizeof( *(& tab ) ), sizeof( *(&(tab[0])) ) ); return 0; }
Marc Boyer -- Lying for having sex or lying for making war? Trust US presidents :-(
mahe
Marc Boyer wrote:
Clarck wrote:
Bonsoir
Est-ce qu'en C, QUELQUE SOIT LE TYPE d'un tableau déclaré comme ceci : <type_elements_tableau> nom_tableau[nombre_elements]; ceci est vrai :
Je suis pas 100% sur de moi, mais à ma connaissance.
nom_tableau est équivalent à &nom_tableau[0] ?
Oui.
Je n'ai pas eu connaisance de quelconque exception dans le standard, donc oui, merci de me corriger dans le cas contraire.
&nom_tableau[0] est équivalent à &nom_tableau ? nom_tableau est équivalent à &nom_tableau ?
Non, dans le sens ou &nom_tableau est un pointeur sur un tableau de nombre_elements élements, le sizeof et l'arithmétique des pointeurs qui va avec change.
Je ne sais pas ou tu voulais en venir, mais nom_tableau ==> pointe sur l'addresse de debut du tableau nom_tableau[0]==> donne le premier element du tableau &nom_tableau[0]==>donne l'addresse du premier element.
comme l'addresse du premier élément est également l'addresse de debut du tableau.
&nom_tableau[0]<==>nom_tableau<==>&nom_tableau;
#include <stdio.h> int tab[50];
int main(){ printf("%u %u", /* Normalement c'est %z, mais si ton compilo est aussi bien que le mien, prend %u */ sizeof( *(& tab ) ), sizeof( *(&(tab[0])) ) ); return 0; }
A ce que je sache, peut etre je me trompe:
sizeof( *(& tab ) ) <==> sizeof(tab) idem pour sizeof( *(&(tab[0])) <==> sizeof(tab[0])
int main(int argc,char** argv) { /*J'ai deliberament chosi un type plus grand que 4 octets, la taille est souvent egale a celui des pointeurs sur l'archi 32 bits */
long long toto[5]={1,2,3,4,5};
/*Pour s'assurer de l'addresse de debut de votre tableau*/ printf("toto=%Xn",toto); printf("&toto=%Xn",&toto); printf("&toto[0]=%Xn",&toto[0]);
/*Quelque mumuse avec sizeof*/ printf("sizeof(toto)=%ldn",sizeof(toto)); printf("sizeof(*(&toto))=%ldn",sizeof(*(&toto)));
**************************************************************** En sortie vous aurez, attention les valeur peut etre different selon l'archi, mais pas l'equivalence!!
Adresse de debut de votre tableau: *********************************** totoÿBEFBD0 &totoÿBEFBD0 &toto[0]ÿBEFBD0
Nombre d'octets occupe par votre tableau: ****************************************** sizeof(toto)@ sizeof(*(&toto))@
Taille du pointeur: ****************************************** sizeof(&toto)=4 sizeof(&toto[0])=4
Taille du 1er element (long long) ****************************************** sizeof(*(&toto[0]))=8 sizeof(toto[0])=8
Est-ce qu'en C, QUELQUE SOIT LE TYPE d'un tableau déclaré comme ceci :
<type_elements_tableau> nom_tableau[nombre_elements];
ceci est vrai :
Je suis pas 100% sur de moi, mais à ma connaissance.
nom_tableau est équivalent à &nom_tableau[0] ?
Oui.
Je n'ai pas eu connaisance de quelconque exception dans le standard,
donc oui, merci de me corriger dans le cas contraire.
&nom_tableau[0] est équivalent à &nom_tableau ?
nom_tableau est équivalent à &nom_tableau ?
Non, dans le sens ou &nom_tableau est un pointeur sur
un tableau de nombre_elements élements, le sizeof
et l'arithmétique des pointeurs qui va avec change.
Je ne sais pas ou tu voulais en venir, mais
nom_tableau ==> pointe sur l'addresse de debut du tableau
nom_tableau[0]==> donne le premier element du tableau
&nom_tableau[0]==>donne l'addresse du premier element.
comme l'addresse du premier élément est également l'addresse de debut du
tableau.
&nom_tableau[0]<==>nom_tableau<==>&nom_tableau;
#include <stdio.h>
int tab[50];
int main(){
printf("%u %u", /* Normalement c'est %z, mais si ton compilo
est aussi bien que le mien, prend %u */
sizeof( *(& tab ) ),
sizeof( *(&(tab[0])) ) );
return 0;
}
A ce que je sache, peut etre je me trompe:
sizeof( *(& tab ) ) <==> sizeof(tab)
idem pour
sizeof( *(&(tab[0])) <==> sizeof(tab[0])
int main(int argc,char** argv)
{
/*J'ai deliberament chosi un type plus grand
que 4 octets, la taille est souvent egale a celui des pointeurs sur
l'archi 32 bits
*/
long long toto[5]={1,2,3,4,5};
/*Pour s'assurer de l'addresse de debut de votre tableau*/
printf("toto=%Xn",toto);
printf("&toto=%Xn",&toto);
printf("&toto[0]=%Xn",&toto[0]);
/*Quelque mumuse avec sizeof*/
printf("sizeof(toto)=%ldn",sizeof(toto));
printf("sizeof(*(&toto))=%ldn",sizeof(*(&toto)));
****************************************************************
En sortie vous aurez, attention les valeur peut etre different selon
l'archi, mais pas l'equivalence!!
Adresse de debut de votre tableau:
***********************************
totoÿBEFBD0
&totoÿBEFBD0
&toto[0]ÿBEFBD0
Nombre d'octets occupe par votre tableau:
******************************************
sizeof(toto)@
sizeof(*(&toto))@
Taille du pointeur:
******************************************
sizeof(&toto)=4
sizeof(&toto[0])=4
Taille du 1er element (long long)
******************************************
sizeof(*(&toto[0]))=8
sizeof(toto[0])=8
Est-ce qu'en C, QUELQUE SOIT LE TYPE d'un tableau déclaré comme ceci : <type_elements_tableau> nom_tableau[nombre_elements]; ceci est vrai :
Je suis pas 100% sur de moi, mais à ma connaissance.
nom_tableau est équivalent à &nom_tableau[0] ?
Oui.
Je n'ai pas eu connaisance de quelconque exception dans le standard, donc oui, merci de me corriger dans le cas contraire.
&nom_tableau[0] est équivalent à &nom_tableau ? nom_tableau est équivalent à &nom_tableau ?
Non, dans le sens ou &nom_tableau est un pointeur sur un tableau de nombre_elements élements, le sizeof et l'arithmétique des pointeurs qui va avec change.
Je ne sais pas ou tu voulais en venir, mais nom_tableau ==> pointe sur l'addresse de debut du tableau nom_tableau[0]==> donne le premier element du tableau &nom_tableau[0]==>donne l'addresse du premier element.
comme l'addresse du premier élément est également l'addresse de debut du tableau.
&nom_tableau[0]<==>nom_tableau<==>&nom_tableau;
#include <stdio.h> int tab[50];
int main(){ printf("%u %u", /* Normalement c'est %z, mais si ton compilo est aussi bien que le mien, prend %u */ sizeof( *(& tab ) ), sizeof( *(&(tab[0])) ) ); return 0; }
A ce que je sache, peut etre je me trompe:
sizeof( *(& tab ) ) <==> sizeof(tab) idem pour sizeof( *(&(tab[0])) <==> sizeof(tab[0])
int main(int argc,char** argv) { /*J'ai deliberament chosi un type plus grand que 4 octets, la taille est souvent egale a celui des pointeurs sur l'archi 32 bits */
long long toto[5]={1,2,3,4,5};
/*Pour s'assurer de l'addresse de debut de votre tableau*/ printf("toto=%Xn",toto); printf("&toto=%Xn",&toto); printf("&toto[0]=%Xn",&toto[0]);
/*Quelque mumuse avec sizeof*/ printf("sizeof(toto)=%ldn",sizeof(toto)); printf("sizeof(*(&toto))=%ldn",sizeof(*(&toto)));
**************************************************************** En sortie vous aurez, attention les valeur peut etre different selon l'archi, mais pas l'equivalence!!
Adresse de debut de votre tableau: *********************************** totoÿBEFBD0 &totoÿBEFBD0 &toto[0]ÿBEFBD0
Nombre d'octets occupe par votre tableau: ****************************************** sizeof(toto)@ sizeof(*(&toto))@
Taille du pointeur: ****************************************** sizeof(&toto)=4 sizeof(&toto[0])=4
Taille du 1er element (long long) ****************************************** sizeof(*(&toto[0]))=8 sizeof(toto[0])=8
