À quoi sert le spécificateur de format% n en C?

À quoi sert le %nspécificateur de format en C? Quelqu'un pourrait-il expliquer avec un exemple?

Rien d'imprimé. L'argument doit être un pointeur vers un entier signé, où le nombre de caractères écrits jusqu'à présent est stocké.

#include <stdio.h>

int main()
{
  int val;

  printf("blah %n blah\n", &val);

  printf("val = %d\n", val);

  return 0;

}

Le code précédent s'imprime:

blah  blah
val = 5

La plupart de ces réponses expliquent ce que %n fait (qui est de ne rien imprimer et d'écrire le nombre de caractères imprimés jusqu'à présent dans une intvariable), mais jusqu'à présent, personne n'a vraiment donné un exemple de son utilité . En voici une:

int n;
printf("%s: %nFoo\n", "hello", &n);
printf("%*sBar\n", n, "");

imprimera:

hello: Foo
       Bar

avec Foo et Bar alignés. (C'est trivial de faire cela sans utiliser %npour cet exemple particulier, et en général, on peut toujours interrompre ce premier printfappel:

int n = printf("%s: ", "hello");
printf("Foo\n");
printf("%*sBar\n", n, "");

La question de savoir si la commodité légèrement ajoutée vaut la peine d'utiliser quelque chose d'ésotérique comme %n(et éventuellement d'introduire des erreurs) est ouverte à débat.)

Je n'ai pas vraiment vu beaucoup d'utilisations pratiques du %nspécificateur dans le monde réel , mais je me souviens qu'il a été utilisé dans les vulnérabilités printf oldschool avec une attaque de chaîne de format il y a quelque temps.

Quelque chose qui est allé comme ça

void authorizeUser( char * username, char * password){

    ...code here setting authorized to false...
    printf(username);

    if ( authorized ) {
         giveControl(username);
    }
}

où un utilisateur malveillant pourrait profiter du paramètre de nom d'utilisateur qui est passé dans printf comme chaîne de format et utiliser une combinaison de %d, %cou w / e pour parcourir la pile d'appels, puis modifier la variable autorisée à une valeur vraie.

Ouais c'est une utilisation ésotérique, mais toujours utile à savoir lors de l'écriture d'un démon pour éviter les failles de sécurité? :RÉ

De là, nous voyons qu'il stocke le nombre de caractères imprimés jusqu'à présent.

n L'argument doit être un pointeur vers un entier dans lequel est écrit le nombre d'octets écrits jusqu'à présent dans la sortie par cet appel à l'une des fprintf()fonctions. Aucun argument n'est converti.

Un exemple d'utilisation serait:

int n_chars = 0;
printf("Hello, World%n", &n_chars);

n_charsaurait alors une valeur de 12.

Jusqu'à présent, toutes les réponses sont à ce sujet %n, mais pas pourquoi quiconque le voudrait en premier lieu. Je trouve que c'est quelque peu utile avec sprintf/ snprintf, lorsque vous devrez peut-être rompre ou modifier plus tard la chaîne résultante, car la valeur stockée est un index de tableau dans la chaîne résultante. Cette application est cependant beaucoup plus utile avec sscanf, d'autant plus que les fonctions de la scanffamille ne renvoient pas le nombre de caractères traités mais le nombre de champs.

Une autre utilisation vraiment hackeuse est d'obtenir un pseudo-log10 gratuitement en même temps tout en imprimant un nombre dans le cadre d'une autre opération.

L'argument associé à %nsera traité comme un int*et est rempli avec le nombre total de caractères imprimés à ce point dans le printf.

L'autre jour, je me suis retrouvé dans une situation où %ncela résoudrait bien mon problème. Contrairement à ma réponse précédente , dans ce cas, je ne peux pas concevoir une bonne alternative.

J'ai un contrôle GUI qui affiche du texte spécifié. Ce contrôle peut afficher une partie de ce texte en gras (ou en italique, ou souligné, etc.), et je peux spécifier quelle partie en spécifiant les index des caractères de début et de fin.

Dans mon cas, je génère le texte vers le contrôle avec snprintf, et j'aimerais que l'une des substitutions soit en gras. Trouver les indices de début et de fin de cette substitution n'est pas trivial car:

• La chaîne contient plusieurs substitutions et l'une des substitutions est un texte arbitraire spécifié par l'utilisateur. Cela signifie que faire une recherche textuelle pour la substitution qui me tient à cœur est potentiellement ambiguë.

• La chaîne de format peut être localisée et utiliser l' $extension POSIX pour les spécificateurs de format positionnels. Par conséquent, rechercher dans la chaîne de format d'origine les spécificateurs de format eux-mêmes n'est pas trivial.

• L'aspect de localisation signifie également que je ne peux pas facilement diviser la chaîne de format en plusieurs appels à snprintf.

Par conséquent, le moyen le plus simple de trouver les indices autour d'une substitution particulière serait de faire:

char buf[256];
int start;
int end;

snprintf(buf, sizeof buf,
         "blah blah %s %f yada yada %n%s%n yakety yak",
         someUserSpecifiedString,
         someFloat,
         &start, boldString, &end);
control->set_text(buf);
control->set_bold(start, end);

Il n'imprime rien. Il est utilisé pour déterminer combien de caractères ont été imprimés avant d' %napparaître dans la chaîne de format, et les afficher dans l'int fourni:

#include <stdio.h>

int main(int argc, char* argv[])
{
    int resultOfNSpecifier = 0;
    _set_printf_count_output(1); /* Required in visual studio */
    printf("Some format string%n\n", &resultOfNSpecifier);
    printf("Count of chars before the %%n: %d\n", resultOfNSpecifier);
    return 0;
}

_{( Documentation pour_set_printf_count_output )}

Il stockera la valeur du nombre de caractères imprimés jusqu'à présent dans cette printf()fonction.

Exemple:

int a;
printf("Hello World %n \n", &a);
printf("Characters printed so far = %d",a);

La sortie de ce programme sera

Hello World
Characters printed so far = 12

% n est C99, ne fonctionne pas avec VC ++.