Oops, je n'avais pas vu la réponse de Marc
Mais je viens d'essayer :
#include <stdio.h>
char T1[100] = { 0 } ;
char T2[100] = { "0" } ;
char T3[100] = "0" ;
char T4[100] = { '0' } ;
int main(void)
...
J'obtiens le même résultat qu'avec le code précédent ou les variables
sont locales.
Je n'ai pas encore beaucoup eu l'occasion de travailer avec des
variables globales alors je ne suis pas sûre si c'est ce code est
correct pour une déclaration de variable globale.
Oops, je n'avais pas vu la réponse de Marc
Mais je viens d'essayer :
#include <stdio.h>
char T1[100] = { 0 } ;
char T2[100] = { "0" } ;
char T3[100] = "0" ;
char T4[100] = { '0' } ;
int main(void)
...
J'obtiens le même résultat qu'avec le code précédent ou les variables
sont locales.
Je n'ai pas encore beaucoup eu l'occasion de travailer avec des
variables globales alors je ne suis pas sûre si c'est ce code est
correct pour une déclaration de variable globale.
Oops, je n'avais pas vu la réponse de Marc
Mais je viens d'essayer :
#include <stdio.h>
char T1[100] = { 0 } ;
char T2[100] = { "0" } ;
char T3[100] = "0" ;
char T4[100] = { '0' } ;
int main(void)
...
J'obtiens le même résultat qu'avec le code précédent ou les variables
sont locales.
Je n'ai pas encore beaucoup eu l'occasion de travailer avec des
variables globales alors je ne suis pas sûre si c'est ce code est
correct pour une déclaration de variable globale.
In article ,
wrote:Je me questionne sur l'utilité d'iniatilisé une variable tableau avec
0, c'est automatiquement effectué lors de la déclaration char t1
[100] ; ?
Non, pas si la variable est locale. Celles-ci valent par defaut n'importe
quoi.
In article <67527f28-de10-4607-9b42-a02d5f882ab1@e27g2000yqm.googlegroups.com>,
bpascal123@googlemail.com <bpascal123@googlemail.com> wrote:
Je me questionne sur l'utilité d'iniatilisé une variable tableau avec
0, c'est automatiquement effectué lors de la déclaration char t1
[100] ; ?
Non, pas si la variable est locale. Celles-ci valent par defaut n'importe
quoi.
In article ,
wrote:Je me questionne sur l'utilité d'iniatilisé une variable tableau avec
0, c'est automatiquement effectué lors de la déclaration char t1
[100] ; ?
Non, pas si la variable est locale. Celles-ci valent par defaut n'importe
quoi.
Mais qui plus est, l'initialisation à 0 remplit l'objet de 0 binaires...
qui ne sont pas obligatoirement identiques (pour les nombres en virgule
flottante et les pointeurs) équivalents à la constante 0.
Mais qui plus est, l'initialisation à 0 remplit l'objet de 0 binaires...
qui ne sont pas obligatoirement identiques (pour les nombres en virgule
flottante et les pointeurs) équivalents à la constante 0.
Mais qui plus est, l'initialisation à 0 remplit l'objet de 0 binaires...
qui ne sont pas obligatoirement identiques (pour les nombres en virgule
flottante et les pointeurs) équivalents à la constante 0.
a écrit dans le message de groupe de discus sion
:
>> Oops, je n'avais pas vu la réponse de Marc
> Mais je viens d'essayer :
> #include <stdio.h>
> char T1[100] = { 0 } ;
> char T2[100] = { "0" } ;
> char T3[100] = "0" ;
> char T4[100] = { '0' } ;
> int main(void)
> ...
> J'obtiens le même résultat qu'avec le code précédent ou les var iables
> sont locales.
> Je n'ai pas encore beaucoup eu l'occasion de travailer avec des
> variables globales alors je ne suis pas sûre si c'est ce code est
> correct pour une déclaration de variable globale.
Y'a pas d'erreur.
Maintenant, on peut dire que :
T1 contient 100 char initialisés avec la valeur 0x00.
T2 contient 1 char initialisé avec la valeur 0x30, suivi de 99 char
initialisés avec la valeur 0x00.
T3 contient 1 char initialisé avec la valeur 0x30, suivi de 99 char
initialisés avec la valeur 0x00.
T4 contient 1 char initialisé avec la valeur 0x30, suivi de 99 char
initialisés avec la valeur 0x00.
La valeur hexadécimale 0x30 étant le code ASCII du caractère aff ichable
zéro.
soit :
T1 = { 0, 0,0,0, .... }
T2 = { '0', 0,0,0, .... }
T3 = { '0', 0,0,0, .... }
T4 = { '0', 0,0,0, .... }
Ou :
T1 = { 0x00, 0x00, 0x00, 0x00, .... }
T2 = { 0x30, 0x00, 0x00, 0x00, .... }
T3 = { 0x30, 0x00, 0x00, 0x00, .... }
T4 = { 0x30, 0x00, 0x00, 0x00, .... }
<bpascal...@googlemail.com> a écrit dans le message de groupe de discus sion
: 8890c8ef-996c-40eb-9afd-b73f48898...@p15g2000vbl.googlegroups.com...
>> Oops, je n'avais pas vu la réponse de Marc
> Mais je viens d'essayer :
> #include <stdio.h>
> char T1[100] = { 0 } ;
> char T2[100] = { "0" } ;
> char T3[100] = "0" ;
> char T4[100] = { '0' } ;
> int main(void)
> ...
> J'obtiens le même résultat qu'avec le code précédent ou les var iables
> sont locales.
> Je n'ai pas encore beaucoup eu l'occasion de travailer avec des
> variables globales alors je ne suis pas sûre si c'est ce code est
> correct pour une déclaration de variable globale.
Y'a pas d'erreur.
Maintenant, on peut dire que :
T1 contient 100 char initialisés avec la valeur 0x00.
T2 contient 1 char initialisé avec la valeur 0x30, suivi de 99 char
initialisés avec la valeur 0x00.
T3 contient 1 char initialisé avec la valeur 0x30, suivi de 99 char
initialisés avec la valeur 0x00.
T4 contient 1 char initialisé avec la valeur 0x30, suivi de 99 char
initialisés avec la valeur 0x00.
La valeur hexadécimale 0x30 étant le code ASCII du caractère aff ichable
zéro.
soit :
T1 = { 0, 0,0,0, .... }
T2 = { '0', 0,0,0, .... }
T3 = { '0', 0,0,0, .... }
T4 = { '0', 0,0,0, .... }
Ou :
T1 = { 0x00, 0x00, 0x00, 0x00, .... }
T2 = { 0x30, 0x00, 0x00, 0x00, .... }
T3 = { 0x30, 0x00, 0x00, 0x00, .... }
T4 = { 0x30, 0x00, 0x00, 0x00, .... }
a écrit dans le message de groupe de discus sion
:
>> Oops, je n'avais pas vu la réponse de Marc
> Mais je viens d'essayer :
> #include <stdio.h>
> char T1[100] = { 0 } ;
> char T2[100] = { "0" } ;
> char T3[100] = "0" ;
> char T4[100] = { '0' } ;
> int main(void)
> ...
> J'obtiens le même résultat qu'avec le code précédent ou les var iables
> sont locales.
> Je n'ai pas encore beaucoup eu l'occasion de travailer avec des
> variables globales alors je ne suis pas sûre si c'est ce code est
> correct pour une déclaration de variable globale.
Y'a pas d'erreur.
Maintenant, on peut dire que :
T1 contient 100 char initialisés avec la valeur 0x00.
T2 contient 1 char initialisé avec la valeur 0x30, suivi de 99 char
initialisés avec la valeur 0x00.
T3 contient 1 char initialisé avec la valeur 0x30, suivi de 99 char
initialisés avec la valeur 0x00.
T4 contient 1 char initialisé avec la valeur 0x30, suivi de 99 char
initialisés avec la valeur 0x00.
La valeur hexadécimale 0x30 étant le code ASCII du caractère aff ichable
zéro.
soit :
T1 = { 0, 0,0,0, .... }
T2 = { '0', 0,0,0, .... }
T3 = { '0', 0,0,0, .... }
T4 = { '0', 0,0,0, .... }
Ou :
T1 = { 0x00, 0x00, 0x00, 0x00, .... }
T2 = { 0x30, 0x00, 0x00, 0x00, .... }
T3 = { 0x30, 0x00, 0x00, 0x00, .... }
T4 = { 0x30, 0x00, 0x00, 0x00, .... }
Je suppose que "initialized by a character string literal..." ça veu t
dire "initialisée par une chaine de caractères quelconque", comme
"literal" se traduit par textuel alors la chaine quelconque pourrait
être { "0" } ou { "0", "0" }.
Par curiosité, j'ai essayé les possibilités dans le code suivant (p our
rappel, j'ai une expérience de 3-4 mois en programmation et je suis
comptable de formation)
#include <stdio.h>
int main(void)
{
char T1[100] = { 0 } ;
char T2[100] = { "0" } ;
char T3[100] = "0" ;
char T4[100] = { '0' } ;
int i ;
printf("nnResultat 10 : %c", T1[0]) ; /* rien n'est affiché */
printf("nnResultat 20 : %c", T1[1]) ; /* rien n'est affiché */
printf("nnResultat 21 : %c", T2[1]) ; /* rien n'est affiché */
printf("nnResultat 22 : %c", T3[1]) ; /* rien n'est affiché*/
printf("nnResultat 23 : %c", T4[1]) ; /* rien n'est affiché*/
printf("nnResultat 30 : %c", T1[10]) ; /* rien n'est affiché */
printf("nnResultat 31 : %c", T2[10]) ; /* rien n'est affiché */
printf("nnResultat 32 : %c", T3[10]) ; /* rien n'est affiché*/
printf("nnResultat 33 : %c", T4[10]) ; /* rien n'est affiché*/
printf("nnResultat 40 : %c", T1[101]) ; /* caractere aleatoire en
memoire */
printf("nnResultat 41 : %c", T2[101]) ; /* rien n'est affiché */
printf("nnResultat 42 : %c", T3[101]) ; /* rien n'est affiché */
printf("nnResultat 43 : %c", T4[101]) ; /* rien n'est affiché */
printf("nnResultat 100 : %s", T1) ; /* rien n'est affiché */
printf("nnResultat 101 : %s", T2) ; /* affiche 0 comme attendu */
printf("nnResultat 102 : %s", T3) ; /* affiche 0 comme attendu */
printf("nnResultat 103 : %s", T4) ; /* affiche 0 comme attendu */
printf("nn") ;
return 0 ;
}
Je m'attendais que initialisation voulait dire remplir T1, T2 ou T3
par une même valeur et éviter ainsi tout caractère aléatoire de
l'adresse des variables de T1, T2, T3.
Je m'aperçois cependant que ces tableaux ne sont pas initialisés dans
leur totalité mais au mieux sont vidés de leurs contenus.
Alors est-ce que l'initialisation au-delà de l'indice 0 pour T1, T2,
T3 et T4 vide le contenu des variables (SANS INSCRIRE 0) ?
Pour T4, le code ne confirme pas ce que Ed écrit :
"Quand on fait une initialisation partielle, tout ce qui est implicite
est mis à 0.
char x[3] = {'a'};
donne
{'a', 0, 0}
c'est garanti par la norme. "
T4 de l'exemple plus haut ne donne pas le même résultat.
Je suppose que "initialized by a character string literal..." ça veu t
dire "initialisée par une chaine de caractères quelconque", comme
"literal" se traduit par textuel alors la chaine quelconque pourrait
être { "0" } ou { "0", "0" }.
Par curiosité, j'ai essayé les possibilités dans le code suivant (p our
rappel, j'ai une expérience de 3-4 mois en programmation et je suis
comptable de formation)
#include <stdio.h>
int main(void)
{
char T1[100] = { 0 } ;
char T2[100] = { "0" } ;
char T3[100] = "0" ;
char T4[100] = { '0' } ;
int i ;
printf("nnResultat 10 : %c", T1[0]) ; /* rien n'est affiché */
printf("nnResultat 20 : %c", T1[1]) ; /* rien n'est affiché */
printf("nnResultat 21 : %c", T2[1]) ; /* rien n'est affiché */
printf("nnResultat 22 : %c", T3[1]) ; /* rien n'est affiché*/
printf("nnResultat 23 : %c", T4[1]) ; /* rien n'est affiché*/
printf("nnResultat 30 : %c", T1[10]) ; /* rien n'est affiché */
printf("nnResultat 31 : %c", T2[10]) ; /* rien n'est affiché */
printf("nnResultat 32 : %c", T3[10]) ; /* rien n'est affiché*/
printf("nnResultat 33 : %c", T4[10]) ; /* rien n'est affiché*/
printf("nnResultat 40 : %c", T1[101]) ; /* caractere aleatoire en
memoire */
printf("nnResultat 41 : %c", T2[101]) ; /* rien n'est affiché */
printf("nnResultat 42 : %c", T3[101]) ; /* rien n'est affiché */
printf("nnResultat 43 : %c", T4[101]) ; /* rien n'est affiché */
printf("nnResultat 100 : %s", T1) ; /* rien n'est affiché */
printf("nnResultat 101 : %s", T2) ; /* affiche 0 comme attendu */
printf("nnResultat 102 : %s", T3) ; /* affiche 0 comme attendu */
printf("nnResultat 103 : %s", T4) ; /* affiche 0 comme attendu */
printf("nn") ;
return 0 ;
}
Je m'attendais que initialisation voulait dire remplir T1, T2 ou T3
par une même valeur et éviter ainsi tout caractère aléatoire de
l'adresse des variables de T1, T2, T3.
Je m'aperçois cependant que ces tableaux ne sont pas initialisés dans
leur totalité mais au mieux sont vidés de leurs contenus.
Alors est-ce que l'initialisation au-delà de l'indice 0 pour T1, T2,
T3 et T4 vide le contenu des variables (SANS INSCRIRE 0) ?
Pour T4, le code ne confirme pas ce que Ed écrit :
"Quand on fait une initialisation partielle, tout ce qui est implicite
est mis à 0.
char x[3] = {'a'};
donne
{'a', 0, 0}
c'est garanti par la norme. "
T4 de l'exemple plus haut ne donne pas le même résultat.
Je suppose que "initialized by a character string literal..." ça veu t
dire "initialisée par une chaine de caractères quelconque", comme
"literal" se traduit par textuel alors la chaine quelconque pourrait
être { "0" } ou { "0", "0" }.
Par curiosité, j'ai essayé les possibilités dans le code suivant (p our
rappel, j'ai une expérience de 3-4 mois en programmation et je suis
comptable de formation)
#include <stdio.h>
int main(void)
{
char T1[100] = { 0 } ;
char T2[100] = { "0" } ;
char T3[100] = "0" ;
char T4[100] = { '0' } ;
int i ;
printf("nnResultat 10 : %c", T1[0]) ; /* rien n'est affiché */
printf("nnResultat 20 : %c", T1[1]) ; /* rien n'est affiché */
printf("nnResultat 21 : %c", T2[1]) ; /* rien n'est affiché */
printf("nnResultat 22 : %c", T3[1]) ; /* rien n'est affiché*/
printf("nnResultat 23 : %c", T4[1]) ; /* rien n'est affiché*/
printf("nnResultat 30 : %c", T1[10]) ; /* rien n'est affiché */
printf("nnResultat 31 : %c", T2[10]) ; /* rien n'est affiché */
printf("nnResultat 32 : %c", T3[10]) ; /* rien n'est affiché*/
printf("nnResultat 33 : %c", T4[10]) ; /* rien n'est affiché*/
printf("nnResultat 40 : %c", T1[101]) ; /* caractere aleatoire en
memoire */
printf("nnResultat 41 : %c", T2[101]) ; /* rien n'est affiché */
printf("nnResultat 42 : %c", T3[101]) ; /* rien n'est affiché */
printf("nnResultat 43 : %c", T4[101]) ; /* rien n'est affiché */
printf("nnResultat 100 : %s", T1) ; /* rien n'est affiché */
printf("nnResultat 101 : %s", T2) ; /* affiche 0 comme attendu */
printf("nnResultat 102 : %s", T3) ; /* affiche 0 comme attendu */
printf("nnResultat 103 : %s", T4) ; /* affiche 0 comme attendu */
printf("nn") ;
return 0 ;
}
Je m'attendais que initialisation voulait dire remplir T1, T2 ou T3
par une même valeur et éviter ainsi tout caractère aléatoire de
l'adresse des variables de T1, T2, T3.
Je m'aperçois cependant que ces tableaux ne sont pas initialisés dans
leur totalité mais au mieux sont vidés de leurs contenus.
Alors est-ce que l'initialisation au-delà de l'indice 0 pour T1, T2,
T3 et T4 vide le contenu des variables (SANS INSCRIRE 0) ?
Pour T4, le code ne confirme pas ce que Ed écrit :
"Quand on fait une initialisation partielle, tout ce qui est implicite
est mis à 0.
char x[3] = {'a'};
donne
{'a', 0, 0}
c'est garanti par la norme. "
T4 de l'exemple plus haut ne donne pas le même résultat.
>> > On 17 août, 18:08, ""
>> > wrote:
> Je suppose que "initialized by a character string literal..." ça v eut
> dire "initialisée par une chaine de caractères quelconque", comme
> "literal" se traduit par textuel alors la chaine quelconque pourrait
> être { "0" } ou { "0", "0" }.
> Par curiosité, j'ai essayé les possibilités dans le code suivant (pour
> rappel, j'ai une expérience de 3-4 mois en programmation et je suis
> comptable de formation)
En tous cas, félicitation ...
> #include <stdio.h>
> int main(void)
> {
> char T1[100] = { 0 } ;
> char T2[100] = { "0" } ;
> char T3[100] = "0" ;
> char T4[100] = { '0' } ;
Voulais-tu vraiment que ces variables est un portée locale à une fonc tion ?
Comme le faisait remarquer Marc Espie, ce type de variables n'est pas
garantie avoir été initialisées.
>> > On 17 août, 18:08, "bpascal...@googlemail.com"
>> > <bpascal...@googlemail.com> wrote:
> Je suppose que "initialized by a character string literal..." ça v eut
> dire "initialisée par une chaine de caractères quelconque", comme
> "literal" se traduit par textuel alors la chaine quelconque pourrait
> être { "0" } ou { "0", "0" }.
> Par curiosité, j'ai essayé les possibilités dans le code suivant (pour
> rappel, j'ai une expérience de 3-4 mois en programmation et je suis
> comptable de formation)
En tous cas, félicitation ...
> #include <stdio.h>
> int main(void)
> {
> char T1[100] = { 0 } ;
> char T2[100] = { "0" } ;
> char T3[100] = "0" ;
> char T4[100] = { '0' } ;
Voulais-tu vraiment que ces variables est un portée locale à une fonc tion ?
Comme le faisait remarquer Marc Espie, ce type de variables n'est pas
garantie avoir été initialisées.
>> > On 17 août, 18:08, ""
>> > wrote:
> Je suppose que "initialized by a character string literal..." ça v eut
> dire "initialisée par une chaine de caractères quelconque", comme
> "literal" se traduit par textuel alors la chaine quelconque pourrait
> être { "0" } ou { "0", "0" }.
> Par curiosité, j'ai essayé les possibilités dans le code suivant (pour
> rappel, j'ai une expérience de 3-4 mois en programmation et je suis
> comptable de formation)
En tous cas, félicitation ...
> #include <stdio.h>
> int main(void)
> {
> char T1[100] = { 0 } ;
> char T2[100] = { "0" } ;
> char T3[100] = "0" ;
> char T4[100] = { '0' } ;
Voulais-tu vraiment que ces variables est un portée locale à une fonc tion ?
Comme le faisait remarquer Marc Espie, ce type de variables n'est pas
garantie avoir été initialisées.
Antoine Leca writes:
> Mais qui plus est, l'initialisation à 0 remplit l'objet de 0 binaires ...
> qui ne sont pas obligatoirement identiques (pour les nombres en virgule
> flottante et les pointeurs) équivalents à la constante 0.
Heu... les objets a duree de vie statique non intialises explicitement so nt
initialises a la valeur 0 pour les variables de type arithmetique et avec
un pointeur null pour les variables de type pointeur. (6.5.7 pour C90,
6.7.8/10 pour C99).
Antoine Leca <r...@localhost.invalid> writes:
> Mais qui plus est, l'initialisation à 0 remplit l'objet de 0 binaires ...
> qui ne sont pas obligatoirement identiques (pour les nombres en virgule
> flottante et les pointeurs) équivalents à la constante 0.
Heu... les objets a duree de vie statique non intialises explicitement so nt
initialises a la valeur 0 pour les variables de type arithmetique et avec
un pointeur null pour les variables de type pointeur. (6.5.7 pour C90,
6.7.8/10 pour C99).
Antoine Leca writes:
> Mais qui plus est, l'initialisation à 0 remplit l'objet de 0 binaires ...
> qui ne sont pas obligatoirement identiques (pour les nombres en virgule
> flottante et les pointeurs) équivalents à la constante 0.
Heu... les objets a duree de vie statique non intialises explicitement so nt
initialises a la valeur 0 pour les variables de type arithmetique et avec
un pointeur null pour les variables de type pointeur. (6.5.7 pour C90,
6.7.8/10 pour C99).
Quelle est l'utilité de travailler avec des valeurs hexadécimales ?
Est-ce que printf avec le % hexadecimale va afficher un resultat là ou
un simple printf %d n'affiche rien pour une valeur arithmétique de
type tableau et nulle pour une valeur pointeur ?
Cette démonstration peut -elle se faire avec des valeurs binaires?
Autrement que pour la programmation d'appareils électroniques, drivers
et pilotes des périphériques informatiques quelle est l'utilité de
travailler avec des des données hexadecimales ou binaires?
Je pose cette question car pour commencer à apprendre la programmation
à partir dezéro, je ne me suis pas trop attardé sur les chapitres d e
conversion et autres manipulations de données binaires ou
hexadecimales.
Quelle est l'utilité de travailler avec des valeurs hexadécimales ?
Est-ce que printf avec le % hexadecimale va afficher un resultat là ou
un simple printf %d n'affiche rien pour une valeur arithmétique de
type tableau et nulle pour une valeur pointeur ?
Cette démonstration peut -elle se faire avec des valeurs binaires?
Autrement que pour la programmation d'appareils électroniques, drivers
et pilotes des périphériques informatiques quelle est l'utilité de
travailler avec des des données hexadecimales ou binaires?
Je pose cette question car pour commencer à apprendre la programmation
à partir dezéro, je ne me suis pas trop attardé sur les chapitres d e
conversion et autres manipulations de données binaires ou
hexadecimales.
Quelle est l'utilité de travailler avec des valeurs hexadécimales ?
Est-ce que printf avec le % hexadecimale va afficher un resultat là ou
un simple printf %d n'affiche rien pour une valeur arithmétique de
type tableau et nulle pour une valeur pointeur ?
Cette démonstration peut -elle se faire avec des valeurs binaires?
Autrement que pour la programmation d'appareils électroniques, drivers
et pilotes des périphériques informatiques quelle est l'utilité de
travailler avec des des données hexadecimales ou binaires?
Je pose cette question car pour commencer à apprendre la programmation
à partir dezéro, je ne me suis pas trop attardé sur les chapitres d e
conversion et autres manipulations de données binaires ou
hexadecimales.
On Aug 20, 2:27 pm, "Senhon" wrote:a écrit dans le message de groupe de
discussion
:
>> Oops, je n'avais pas vu la réponse de Marc
> Mais je viens d'essayer :
> #include <stdio.h>
> char T1[100] = { 0 } ;
> char T2[100] = { "0" } ;
> char T3[100] = "0" ;
> char T4[100] = { '0' } ;
> int main(void)
> ...
> J'obtiens le même résultat qu'avec le code précédent ou les variables
> sont locales.
> Je n'ai pas encore beaucoup eu l'occasion de travailer avec des
> variables globales alors je ne suis pas sûre si c'est ce code est
> correct pour une déclaration de variable globale.
Y'a pas d'erreur.
Maintenant, on peut dire que :
T1 contient 100 char initialisés avec la valeur 0x00.
T2 contient 1 char initialisé avec la valeur 0x30, suivi de 99 char
initialisés avec la valeur 0x00.
T3 contient 1 char initialisé avec la valeur 0x30, suivi de 99 char
initialisés avec la valeur 0x00.
T4 contient 1 char initialisé avec la valeur 0x30, suivi de 99 char
initialisés avec la valeur 0x00.
La valeur hexadécimale 0x30 étant le code ASCII du caractère affichable
zéro.
soit :
T1 = { 0, 0,0,0, .... }
T2 = { '0', 0,0,0, .... }
T3 = { '0', 0,0,0, .... }
T4 = { '0', 0,0,0, .... }
Ou :
T1 = { 0x00, 0x00, 0x00, 0x00, .... }
T2 = { 0x30, 0x00, 0x00, 0x00, .... }
T3 = { 0x30, 0x00, 0x00, 0x00, .... }
T4 = { 0x30, 0x00, 0x00, 0x00, .... }
Bonjour,
Quelle est l'utilité de travailler avec des valeurs hexadécimales ?
Est-ce que printf avec le % hexadecimale va afficher un resultat là ou
un simple printf %d n'affiche rien pour une valeur arithmétique de
type tableau et nulle pour une valeur pointeur ?
Cette démonstration peut -elle se faire avec des valeurs binaires?
Autrement que pour la programmation d'appareils électroniques, drivers
et pilotes des périphériques informatiques quelle est l'utilité de
travailler avec des des données hexadecimales ou binaires?
Je pose cette question car pour commencer à apprendre la programmation
à partir dezéro, je ne me suis pas trop attardé sur les chapitres de
conversion et autres manipulations de données binaires ou
hexadecimales.
On Aug 20, 2:27 pm, "Senhon" <N...@Nul.Nul> wrote:
<bpascal...@googlemail.com> a écrit dans le message de groupe de
discussion
: 8890c8ef-996c-40eb-9afd-b73f48898...@p15g2000vbl.googlegroups.com...
>> Oops, je n'avais pas vu la réponse de Marc
> Mais je viens d'essayer :
> #include <stdio.h>
> char T1[100] = { 0 } ;
> char T2[100] = { "0" } ;
> char T3[100] = "0" ;
> char T4[100] = { '0' } ;
> int main(void)
> ...
> J'obtiens le même résultat qu'avec le code précédent ou les variables
> sont locales.
> Je n'ai pas encore beaucoup eu l'occasion de travailer avec des
> variables globales alors je ne suis pas sûre si c'est ce code est
> correct pour une déclaration de variable globale.
Y'a pas d'erreur.
Maintenant, on peut dire que :
T1 contient 100 char initialisés avec la valeur 0x00.
T2 contient 1 char initialisé avec la valeur 0x30, suivi de 99 char
initialisés avec la valeur 0x00.
T3 contient 1 char initialisé avec la valeur 0x30, suivi de 99 char
initialisés avec la valeur 0x00.
T4 contient 1 char initialisé avec la valeur 0x30, suivi de 99 char
initialisés avec la valeur 0x00.
La valeur hexadécimale 0x30 étant le code ASCII du caractère affichable
zéro.
soit :
T1 = { 0, 0,0,0, .... }
T2 = { '0', 0,0,0, .... }
T3 = { '0', 0,0,0, .... }
T4 = { '0', 0,0,0, .... }
Ou :
T1 = { 0x00, 0x00, 0x00, 0x00, .... }
T2 = { 0x30, 0x00, 0x00, 0x00, .... }
T3 = { 0x30, 0x00, 0x00, 0x00, .... }
T4 = { 0x30, 0x00, 0x00, 0x00, .... }
Bonjour,
Quelle est l'utilité de travailler avec des valeurs hexadécimales ?
Est-ce que printf avec le % hexadecimale va afficher un resultat là ou
un simple printf %d n'affiche rien pour une valeur arithmétique de
type tableau et nulle pour une valeur pointeur ?
Cette démonstration peut -elle se faire avec des valeurs binaires?
Autrement que pour la programmation d'appareils électroniques, drivers
et pilotes des périphériques informatiques quelle est l'utilité de
travailler avec des des données hexadecimales ou binaires?
Je pose cette question car pour commencer à apprendre la programmation
à partir dezéro, je ne me suis pas trop attardé sur les chapitres de
conversion et autres manipulations de données binaires ou
hexadecimales.
On Aug 20, 2:27 pm, "Senhon" wrote:a écrit dans le message de groupe de
discussion
:
>> Oops, je n'avais pas vu la réponse de Marc
> Mais je viens d'essayer :
> #include <stdio.h>
> char T1[100] = { 0 } ;
> char T2[100] = { "0" } ;
> char T3[100] = "0" ;
> char T4[100] = { '0' } ;
> int main(void)
> ...
> J'obtiens le même résultat qu'avec le code précédent ou les variables
> sont locales.
> Je n'ai pas encore beaucoup eu l'occasion de travailer avec des
> variables globales alors je ne suis pas sûre si c'est ce code est
> correct pour une déclaration de variable globale.
Y'a pas d'erreur.
Maintenant, on peut dire que :
T1 contient 100 char initialisés avec la valeur 0x00.
T2 contient 1 char initialisé avec la valeur 0x30, suivi de 99 char
initialisés avec la valeur 0x00.
T3 contient 1 char initialisé avec la valeur 0x30, suivi de 99 char
initialisés avec la valeur 0x00.
T4 contient 1 char initialisé avec la valeur 0x30, suivi de 99 char
initialisés avec la valeur 0x00.
La valeur hexadécimale 0x30 étant le code ASCII du caractère affichable
zéro.
soit :
T1 = { 0, 0,0,0, .... }
T2 = { '0', 0,0,0, .... }
T3 = { '0', 0,0,0, .... }
T4 = { '0', 0,0,0, .... }
Ou :
T1 = { 0x00, 0x00, 0x00, 0x00, .... }
T2 = { 0x30, 0x00, 0x00, 0x00, .... }
T3 = { 0x30, 0x00, 0x00, 0x00, .... }
T4 = { 0x30, 0x00, 0x00, 0x00, .... }
Bonjour,
Quelle est l'utilité de travailler avec des valeurs hexadécimales ?
Est-ce que printf avec le % hexadecimale va afficher un resultat là ou
un simple printf %d n'affiche rien pour une valeur arithmétique de
type tableau et nulle pour une valeur pointeur ?
Cette démonstration peut -elle se faire avec des valeurs binaires?
Autrement que pour la programmation d'appareils électroniques, drivers
et pilotes des périphériques informatiques quelle est l'utilité de
travailler avec des des données hexadecimales ou binaires?
Je pose cette question car pour commencer à apprendre la programmation
à partir dezéro, je ne me suis pas trop attardé sur les chapitres de
conversion et autres manipulations de données binaires ou
hexadecimales.
> C'est un insignifiant B-A BA.
> C'est un insignifiant B-A BA.
> C'est un insignifiant B-A BA.
