J´ai décidé de remplacer fprintf dans mon programme par une fonction de logging customisé par moi-même afin de logger une éventuelle erreur.

En utilisant fwrite, je dois passer la longueur du pointeur char à écrire en fichier... Voici comment je procède:

--------------------
void logText(char txtToLog[100],bool bootUp)
{
// Si le paramètre true passe, on initialise le logger
if(bootUp == true)
{
// Création d´un pointeur de fichier, ouverture du fichier de log ( efface le vieux contenu)
FILE *filePointer = fopen("log.txt","w");
// Écrit un petit message indiquant que la "Console" ( c´est comme ça que j´appel mon logger ; )) est prête
fwrite("Console ready",sizeof(char),sizeof("Console ready"),filePointer);
// On ferme le fichier
fclose(filePointer);
}
// Si le paramètre false passe, on log un tableau char
else
{
// Petite boucle pour trouver la grosseur du tableau
int i = 0;
while(txtToLog[i] ! = NULL)
{
i++;
}

// On créé un pointeur char pour passer à la fonction fwrite
char *txtPointer = &[0];

// On ouvre le fichier en append
FILE *filePointer = fopen("log.txt","a");

// On fait un retour de chariot pour que tout ne soit pas sur la même ligne

fwrite("\n",sizeof(char),sizeof("\n"),filePointer)
;

// Écriture du contenu du pointeur
fwrite(txtPointer,sizeof(char),i,filePointer);

// On ferme le fichier
fclose(filePointer);
}
}
--------------------

Hors, la comparaison char ! = null créée un avertissement: [Warning] NULL used in arithmetic. Je m´y attendais bien mais j´ignore quelle autre constante utilisée pour ne pas avoir cette erreur... Suggestion ?

Pour répondre exactement à ton problème, remplace NULL par 0 . . mais bon il existe la fonction strlen(txtToLog) qui fait exactement ce que tu fais pour calculer la longueur de ta chaine. Alors bon mieux vaut ne pas tout réinventer.

Sinon une petite remarque, globalement faudrait que tu revois plusieurs trucs dans ta fonction car c´est pas super super optimisé ni propre.

Déjà, pourquoi vouloir passer pas fwrite et non fprintf ? ???

"Déjà, pourquoi vouloir passer pas fwrite et non fprintf ? ???"

Beh justement, pour apprendre à utiliser fwrite de façon propre ; )

Ah ok, mais c´est pas ce qu´il y a de mieux adapté pour des fichiers textes . . A utiliser de préférence pour des fichiers binaires ( données images, son etc . . par exemple)

Ensuite tu sembles avoir besoin de quelques info concernant les tableaux, non ? C´est ta facon de les utiliser qui me fait dire ca.

Ça fonctionne ! =p

Pour clarifier un peu, j´utilisais cette fonction pour vérifier ma compréhension des tableaux, des pointeurs et de fwrite...

Je prends un peu d´expérience ici et là, je code morceau par morceau et j´ajoute à mon projet quand ça fonctionne !

Oh et je pense utiliser ma fonction de logging pour répèter des tâches que printf ne fait pas.

Cela dit, j´aurais une petite question... Pourquoi une fonction qui demande un pointeur fonctionne lorsque l´on passe un tableau ? ??

C´est justement là que je voulais en venir : )

Tout simplement parceque l´identifiant d´un tableau ( sans la fonction d´accès à un élément : les crochets quoi etc...) est : un pointeur !

Quand tu écris char txtToLog[100], tu déclares un tableau de caractères et txtToLog est un pointeur sur le premier élément du tableau ( txtToLog est de type char * et équivalent à &[0])

Donc quand tu fais:

char *txtPointer = &[0];
. ..
fwrite(txtPointer,sizeof(char),i,filePointer);

bin ca sert à rien vu que tu peux mettre directement :

fwrite(txtToLog,sizeof(char),i,filePointer);

Je me disais aussi ! Wow, merci, c´est L´INFORMATION qui me manque depuis... beh... je sais plus quand =p.

Il reste un détail, je sais qu´un pointeur qui n´est pas initialisé est dangereux... Face à ça, comment se comporte un pointeur dans un paramètres de fonction:

----
void ma_fonction(char *unpointeur1, int *unpointeur2, . ..)
----

?

comment se comporte un pointeur dans un paramètres de fonction

C´est à dire ? qu´entends tu par "comportement" ?

Je sais pas si c´est la réponse que tu attends, mais lors de l´appel de la fonction la valeur du pointeur est transmise à la fonction et donc tu peux accéder à la zone référencée par ce pointeur.

avec : void ma_fonction(char *unpointeur1, int *unpointeur2, . . .)

Tu peux écrire unpointeur1[0], unpointeur1[10] etc...

A toi de vérifier que le pointeur n´est pas "nul" c´est à dire que le pointeur existe bien.
Généralement le test s´effectue par rapport à la valeur NULL ( celle que tu utilisais au début..).

Donc si unpointeur1 == NULL faut pas s´en servir car non initialisé.

Il existe encore un autre cas où le pointeur peut être "dangereux" c´est ce que l´on appelle des "wild pointers". Mais là c´est un peu plus compliqué pour les contrôler. Si tu souhaites savoir comment, bin faudrait que tu connaisses la gestion des exceptions ( try, catch & Cie . ..)

Quoique la question est p-e un peu stupide... Ça ne doit pas poser problème... ?

Ho 2 messages en même temps =p.

Ce que je voulais c´est, en créant une fonction qui requiert un pointeur comme paramètre, ledit pointeur ( qui est un paramètre de la fonction) s´initialise-t-il proprement automatiquement ( à condition, évidemment, que la fonction soit appellée correctement =p) ? ??

Hmmm y manque un mot à mon dernier message =s...

"Ce que je voulais dire c´est"

et non

"Ce que je voulais c´est"

j´oubliais pour "wild pointers" généralement on les rencontre lorsqu´un pointeur est initialisé avec une valeur bidon par le programme ( lorsque tu oublies de l´initialiser à zéro par exemple et que le programme ne le fait pas à ta place) ou encore lorsque tu libères la zone sur laquelle faisait référence un pointeur mais que tu tentes d´accéder à cette zone après sa libération ( hmm suis je clair ? ).

s´initialise-t-il proprement

oui

void ma_fonction(char *ptr)
{
. ..
}

char txt[100];
ma_fonction(txt);

ca marchera nickel et c´est plutôt recommandé de faire ca. A moins d´avoir une fonction très spécifique, liée à la taille de ton tableau mais bon dans les 80% des cas il vaut mieux passer par un Type *

Sweeeeet, ça répond à toutes mes questions. Merci mille fois.

moi j´ai pas tout très bien suivi
mais c´etait instructif merci

bon allez, voila un truc de mieux car ta fct de trace va etre super lourde à utiliser :
voila t´as juste à remplacer [...] par ce que tu veux faire cad écrire dans un fichier+une console par exemple.

void Trace ( const char *_pszText, . ..) const
{

1. define D_STR_SIZE 256

char szInfo [D_STR_SIZE];

if(_pszText)
{
va_list marker;
va_start(marker, _pszText);

int s32NbCharWritten = _vsnprintf(szInfo, D_STR_SIZE-1, _pszText, marker);

assert ( s32NbCharWritten >= 0);
va_end ( marker);

// PLACE HERE YOUR CODE [...]
// szInfo is formatted buffer
// [...]
}
}

Ex :
void main ( void)
{
int i = 0;
Trace ( "Hello, i vaut : %d", i);
}
C pas plus propre non ? ; p