C'de Biçim Belirteçleri: Eksiksiz printf ve scanf Başvurusu

Bir biçim belirteci, printf'e bir değeri metne nasıl çevireceğini ve scanf'e metni bir değere nasıl çevireceğini söyler. C'nin, derleyicinin varsayılan olarak size yardım edemediği tek parçasıdır - argüman tipleri fonksiyona görünmezdir - dolayısıyla bu sayfa, karşılaştıracağınız tablodur.

Bir belirtimin genel biçimi şudur:

%[bayraklar][genislik][.hassasiyet][uzunluk]donusum

Yalnızca % ve dönüşüm harfi zorunludur. %-8.2lf beş parçanın hepsini kullanır.

Dönüşüm Tablosu

#include <stdio.h>

int main(void) {
    int x = 255;

    printf("%%d  : %d\n", x);
    printf("%%u  : %u\n", x);
    printf("%%x  : %x\n", x);
    printf("%%X  : %X\n", x);
    printf("%%o  : %o\n", x);
    printf("%%c  : %c\n", 65);
    printf("%%s  : %s\n", "metin");
    printf("%%f  : %f\n", 3.5);
    printf("%%e  : %e\n", 3.5);
    printf("%%g  : %g\n", 3.5);
    printf("%%p  : %p\n", (void *)&x);
    return 0;
}

İki madde uyarıyı hak eder. %n yazdırmak yerine belleğe yazar ve biçim metni açığının arkasındaki mekanizmadır - kullanıcı metninin bir biçim metnine ulaşmasına asla izin vermeyin. Ve %p bir void * ister; doğrudan bir int * geçirmek, her gerçek derleyici yine de adresi yazdırsa bile tanımsızdır.

Uzunluk Değiştiricileri

Uzunluk değiştiricisi hassasiyet ile dönüşüm harfi arasında gelir ve argümanın gerçekte ne kadar büyük olduğunu söyler.

İşaretli dönüşümler (d i) ile işaretsiz olanlar (u x o) farklı tipler alır - %lu, long değil unsigned long ister; bunu karıştırmak kozmetik bir hata değil, tanımsız davranıştır.

Kayan noktalı ve karakter aileleri için ise:

Gerçekte yazacağınız birleşimler:

#include <stdio.h>
#include <string.h>

int main(void) {
    short              s   = -12;
    long               l   = 3000000000L;
    long long          ll  = 9000000000000000000LL;
    unsigned long      ul  = 4000000000UL;
    unsigned long long ull = 18000000000000000000ULL;
    size_t             len = strlen("hello");
    long double        ld  = 2.5L;

    printf("short              : %hd\n", s);
    printf("long               : %ld\n", l);
    printf("long long          : %lld\n", ll);
    printf("unsigned long      : %lu\n", ul);
    printf("unsigned long long : %llu\n", ull);
    printf("size_t             : %zu\n", len);
    printf("long double        : %Lf\n", ld);
    return 0;
}

Ezberlenmesi gereken %zu'dur. sizeof, strlen ve her standart kütüphane boyutu size_t döndürür; bu, 64 bitlik bir sistemde 8 bayttır, int ise 4. printf("%d", strlen(s)), bazı platformlarda çalışıyor gibi görünen gerçek bir hatadır - %zu kullanın.

hh ve h değiştiricileri esas olarak, hedef boyutunun önemli olduğu scanf için vardır. printf'te bir short çağrıdan önce int'e yükseltilir, dolayısıyla %d onu zaten doğru yazdırırdı; %hd yalnızca niyeti belgeler.

Sabit Genişlikli Tipler

int32_t gibi <stdint.h> tipleri için taşınabilir belirteçler <inttypes.h>'deki makrolardır:

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>

int main(void) {
    int32_t  a = -2000000000;
    uint64_t b = 18000000000000000000ULL;

    printf("int32_t  : %" PRId32 "\n", a);
    printf("uint64_t : %" PRIu64 "\n", b);
    return 0;
}

PRId32, platformunuz için doğru harflere genişler ve komşu metin sabitleri birleşir; biçimin üç parçaya bölünmesinin sebebi budur. Çirkindir; alternatif - long long'a dönüştürüp %lld kullanmak - çoğu zaman daha okunaklı ve her zaman doğrudur.

Bayraklar

Bayraklar hemen %'den sonra gelir ve sunumu değiştirir. Yalnızca printf için geçerlidirler.

#include <stdio.h>

int main(void) {
    printf("|%6d|\n",   42);
    printf("|%-6d|\n",  42);
    printf("|%06d|\n",  42);
    printf("|%+d|\n",   42);
    printf("|% d|\n",   42);
    printf("|%#x|\n",  255);
    printf("|%#o|\n",   64);
    printf("|%#.0f|\n", 3.0);
    return 0;
}

Bayraklar birleşebilir: %-+8.2f, en az 8 genişlik, iki ondalık, her zaman işaretli, sayıdan sonra doldurulmuş demektir. İkisini de yazarsanız -, 0'ı yener.

Genişlik ve Hassasiyet

Genişlik en küçük alan boyutudur - çıktı ona ulaşacak şekilde doldurulur ve ona sığması için asla kırpılmaz. Hassasiyet (bir noktadan sonra) her aile için farklı bir şey ifade eder:

#include <stdio.h>

int main(void) {
    printf("|%10.3f|\n", 3.14159);     /* genislik 10, 3 ondalik */
    printf("|%.5d|\n",   42);          /* en az 5 basamak        */
    printf("|%.3s|\n",   "abcdefg");   /* en fazla 3 karakter    */
    printf("|%.0f|\n",   2.71828);     /* ondalik yok            */
    printf("|%*d|\n",    8, 42);       /* genislik bir argumandan */
    printf("|%.*f|\n",   3, 3.14159);  /* hassasiyet bir argumandan */
    return 0;
}

Bu sayılardan birinin yerine konan bir *, onu değerin kendisinden önce okunan bir int argümandan alır. Sütun genişlikleri çalışma zamanında hesaplanan tabloları böyle kurarsınız.

scanf'te genişliğin farklı ve çok daha önemli bir işi vardır: bir dönüşümün ne kadar girdi tüketeceğini sınırlar ki bu, %s ile bir tampon taşması arasında duran tek şeydir.

printf ile scanf'in Ayrıştığı Yerler

Birbirlerine benzerler ve dört yerde ayrışırlar. Her biri canlı bir hata kaynağıdır:

#include <stdio.h>

int main(void) {
    double d;
    char   word[16];

    printf("Bir ondalik sayi ve bir kelime girin: ");
    if (scanf("%lf %15s", &d, word) == 2) {   /* %lf ve bir genislik */
        printf("%.3f ve \"%s\"\n", d, word);  /* %f ve bir hassasiyet */
    } else {
        printf("Girdi eslesmedi.\n");
    }
    return 0;
}

2.5 merhaba deneyin. Onu okuyan biçim ile yazdıran biçim aynı double için farklı harfler kullanır ve %15s'teki 15, girdiyi 15 karakter artı sonlandırıcıyla sınırlar - tam olarak word'ün boyutu.

scanf Tarama Kümesi

%[...], boşlukla ayrılmış bir kelime yerine bir karakter kümesi okur. scanf ile bütün bir satır okumanın yoludur, ama fgets hâlâ daha iyi araçtır:

#include <stdio.h>

int main(void) {
    char line[64];

    printf("Bir cumle yazin: ");
    if (scanf("%63[^\n]", line) == 1) {     /* satir sonuna kadar her sey */
        printf("Yazdiginiz: %s\n", line);
    }
    return 0;
}

[^\n], "satır sonu dışındaki her karakter" demektir. %[0-9] yalnızca rakamları, %[abc] yalnızca o üç harfi okurdu. %s'nin aksine bir tarama kümesi baştaki boşlukları atlamaz, dolayısıyla tampondaki başıboş bir satır sonu hiçbir şeyle eşleşmemesine yol açar.

Yanlış Yapmak Tanımsız Davranıştır

printf, argümanınızın gerçek tipini göremez. Belirtecin ima ettiği kadar baytı, belirtecin söylediği gibi yorumlayarak okur. Dolayısıyla bir uyumsuzluk bir biçimlendirme aksaklığı değil - belleği yanlış şey olarak okumaktır:

printf("%d\n", 3.5);        /* çöp yazdırır: bir double'ın bitlerini int olarak okur */
printf("%s\n", 42);         /* 42'yi bir adres sayar - çökme */
printf("%d\n", strlen(s));  /* size_t, int olarak okunur - 64 bitte yanlış */
printf("%f\n", 3);          /* int, double olarak okunur - çöp */

Savunma tek bir bayrağa mal olur. -Wall ile derleyin ve GCC her sabit biçim metnini argümanlarıyla karşılaştırır:

gcc -Wall -Wextra program.c -o program

Yukarıdaki dört satırın her birini derleme zamanında bildirir. Bu, C'deki tek en değerli uyarıdır ve yukarıdaki editörde varsayılan olarak açıktır.

Bunları kullanmanın pratik tarafı için - hizalı tablolar, float'ları okunaklı yazdırmak, klasik satır sonu hatası olmadan girdi okumak - bkz. printf ve scanf.