C'de Veri Tipleri: int, float, char, double ve Daha Fazlası

C'deki her değişkenin, onu bildirdiğinizde seçilen ve ömrü boyunca sabit kalan bir tipi vardır. Tip üç şeye karar verir: değişkenin kaç bayt kapladığına, o baytların nasıl yorumlanacağına ve onun üzerinde hangi işlemlerin anlamlı olduğuna.

C'nin tip listesi kısadır. Karmaşıklık değiştiricilerdedir.

Dört Temel Tip

#include <stdio.h>

int main(void) {
    char  initial = 'K';        /* tek karakter / tek bayt */
    int   count   = 42;         /* tam sayi */
    float ratio   = 3.14f;      /* ondalik, tek duyarlik */
    double precise = 3.141592653589793;  /* ondalik, cift duyarlik */

    printf("char:   %c\n", initial);
    printf("int:    %d\n", count);
    printf("float:  %f\n", ratio);
    printf("double: %.15f\n", precise);
    return 0;
}

• char bir bayt tutar. Tek karakterler ('A'), bir metnin baytları ve bazen minik bir tam sayı olarak kullanılır.
• int işçi atı tam sayı tipidir. Döngü sayaçları, boyutlar, kimlikler.
• float ve double gerçel sayıları tutar. double'ın hassasiyeti kabaca iki katıdır.
• void bir anlamda dördüncü tiptir, ama "değer yok" anlamına gelir - void bir değişken bildiremezsiniz; yalnızca fonksiyon dönüş tipi, boş parametre listesi ya da tipsiz gösterici olarak kullanabilirsiniz.

3.14f'teki f sonekine dikkat edin. Onsuz sabit bir double'dır ve onu bir float'a atamak hassasiyeti sessizce kaybeder. Bazı derleyiciler bunun için uyarır.

Değiştiriciler: short, long, unsigned

Temel tam sayı tipleri, boyutu ya da işareti değiştiren değiştiricilerle gelir.

#include <stdio.h>

int main(void) {
    short small = 32000;
    int normal = 2000000;
    long big = 2000000000L;
    long long huge = 9000000000000000000LL;

    unsigned int positive_only = 4000000000U;

    printf("short:        %hd\n", small);
    printf("int:          %d\n", normal);
    printf("long:         %ld\n", big);
    printf("long long:    %lld\n", huge);
    printf("unsigned int: %u\n", positive_only);
    return 0;
}

Her tam sayı tipinin kendi biçim belirtecine ihtiyacı vardır: short için %hd, int için %d, long için %ld, long long için %lld, unsigned için %u. Yanlışını kullanmak bir yuvarlama hatası değil, tanımsız davranıştır.

unsigned işaret bitini kaldırır ve pozitif aralığı ikiye katlar. Bir unsigned int, -2,1 ile +2,1 milyar yerine 0 ile yaklaşık 4,3 milyar arasını tutar. Gerçekten negatif olamayacak şeyler için doğru seçimdir - boyutlar, bayt sayıları, bit örüntüleri - ve sıfırın altına çıkarılabilecek her şey için bir tuzaktır.

signed; int, short, long ve long long için varsayılandır, dolayısıyla neredeyse hiç yazmazsınız. Önemli olduğu tek yer char'dır: düz char'ın işaretli mi işaretsiz mi olduğu gerçekleştirime bağlıdır, o yüzden işaret önemliyse signed char ya da unsigned char yazın.

Boyutlar: Gerçekte Ne Elde Edersiniz

C standardı kesin boyutları değil asgari değerleri belirtir. Modern 64 bitlik herhangi bir Linux, macOS ya da Windows makinesinde şunu görürsünüz:

long satırı insanları yakalayanıdır: Linux ve macOS'ta 8 bayt, 64 bitlik Windows'ta 4 bayttır. long'un 64 bitlik bir değer tutabileceğini varsayan kod taşınabilir değildir. Boyut gereksinimin bir parçasıysa long long ya da stdint.h'deki kesin genişlikli tipleri (int32_t, uint64_t) kullanın.

sizeof: Derleyiciye Sorun

Bir boyutu asla tahmin etmeyin - ölçün:

#include <stdio.h>

int main(void) {
    printf("char:        %zu bayt\n", sizeof(char));
    printf("short:       %zu bayt\n", sizeof(short));
    printf("int:         %zu bayt\n", sizeof(int));
    printf("long:        %zu bayt\n", sizeof(long));
    printf("long long:   %zu bayt\n", sizeof(long long));
    printf("float:       %zu bayt\n", sizeof(float));
    printf("double:      %zu bayt\n", sizeof(double));
    printf("bir gosterici: %zu bayt\n", sizeof(int *));
    return 0;
}

sizeof bir fonksiyon değil, bir operatördür ve derleme zamanında değerlendirilir. Değeri %zu ile yazdırılan size_t tipindedir.

sizeof(char)'ın tam olarak 1 olması garantidir - C'de bir baytın tanımı budur. Diğer her şey ona göre ölçülür.

limits.h ve float.h

Derleyiciniz için kesin aralıklar adlandırılmış sabitler olarak mevcuttur:

#include <stdio.h>
#include <limits.h>
#include <float.h>

int main(void) {
    printf("INT_MIN      = %d\n", INT_MIN);
    printf("INT_MAX      = %d\n", INT_MAX);
    printf("UINT_MAX     = %u\n", UINT_MAX);
    printf("LONG_MAX     = %ld\n", LONG_MAX);
    printf("CHAR_BIT     = bayt basina %d bit\n", CHAR_BIT);
    printf("FLT_DIG      = %d ondalik basamak\n", FLT_DIG);
    printf("DBL_DIG      = %d ondalik basamak\n", DBL_DIG);
    return 0;
}

Bir işlemin taşıp taşmayacağını bilmeniz gerektiğinde karşılaştıracağınız değerler bunlardır. a + b'yi hesaplamadan önce if (a > INT_MAX - b) kontrolü, taşmayı olmadan önce saptama yolunuzdur - ki bu önemlidir, çünkü işaretli taşmayı sonradan saptayamazsınız.

Tam Sayı Taşması

Bir değer tipinin aralığını aştığında ne olacağı tamamen işarete bağlıdır.

İşaretsiz taşma tanımlıdır: değer 2^N'e göre sarar.

#include <stdio.h>
#include <limits.h>

int main(void) {
    unsigned int u = UINT_MAX;
    printf("UINT_MAX     = %u\n", u);
    printf("UINT_MAX + 1 = %u\n", u + 1);   /* 0 olmasi garanti */

    unsigned int zero = 0;
    printf("0 - 1        = %u\n", zero - 1); /* UINT_MAX'e sarar */
    return 0;
}

O ikinci durum gerçek bir hata kaynağıdır. for (unsigned i = n - 1; i >= 0; i--) gibi bir döngü asla bitmez, çünkü işaretsiz bir değer her zaman >= 0'dır.

İşaretli taşma tanımsız davranıştır. "Sarar" değil - tanımsız. Derleyicinin bunun asla olmadığını varsayıp buna göre iyileştirme yapmasına izin verilir; bu da sonradan yazılmış bir taşma denetiminin silinebileceği anlamına gelir:

int sum = a + b;
if (sum < a) { /* derleyici bunu tamamen kaldırabilir */ }

Sınırları kullanarak önceden kontrol edin:

if (b > 0 && a > INT_MAX - b) {
    /* a + b taşardı - ele alın */
}

Kayan Nokta Hassasiyeti

float ve double sayıları ikili olarak saklar ve çoğu ondalık kesrin tam bir ikili biçimi yoktur - 1/3'ün tam bir ondalık biçiminin olmadığı gibi.

#include <stdio.h>

int main(void) {
    double a = 0.1;
    double b = 0.2;
    double sum = a + b;

    printf("0.1 + 0.2 = %.20f\n", sum);
    printf("0.3 mu? %s\n", (sum == 0.3) ? "evet" : "hayir");

    /* Dogru yol: bir tolerans icinde karsilastirin. */
    double diff = sum - 0.3;
    if (diff < 0) diff = -diff;
    printf("Yeterince yakin mi? %s\n", (diff < 1e-9) ? "evet" : "hayir");
    return 0;
}

Bundan çıkan kural: kayan noktalı değerleri asla == ile karşılaştırmayın. Bunun yerine mutlak farkı küçük bir toleransla karşılaştırın.

Ve para için asla kayan nokta kullanmayın. Kuruşları tam sayı olarak saklayın; kuruş cinsinden bir long long, dolar cinsinden bir double'ın olmadığı şekilde kesindir.

Bir Tip Seçmek

Kodun çoğunu kapsayan kısa bir karar listesi:

• Tam sayılar: bir sebebiniz yoksa int. CPU'nun en verimli şekilde işlediği ve tüm aritmetik kuralların etrafında kurulduğu tiptir.
• 2 milyardan büyük her şey: long long ya da stdint.h'deki int64_t.
• Boyutlar, uzunluklar, sizeof ya da strlen'den gelen dizi indeksleri: size_t. İşaretsizdir ve her nesne için yeterince büyük olması garantidir.
• Ondalıklar: double. float'ı yalnızca büyük dizilerde belleği yarıya indirmek ya da çift duyarlık birimi olmayan gömülü donanımda kullanın.
• Tek karakterler ve ham baytlar: metin için char, ikili veri için unsigned char.
• Doğru/yanlış: stdbool.h'deki bool - bkz. C'de booleanlar.
• Kesin bit genişlikleri (dosya biçimleri, ağ protokolleri, donanım yazmaçları): stdint.h - uint8_t, int16_t, uint32_t vb.

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

int main(void) {
    uint8_t  flags = 0xFF;          /* tam olarak 8 bit, isaretsiz */
    int32_t  offset = -100000;      /* tam olarak 32 bit, isaretli */
    uint64_t file_size = 5000000000ULL;

    printf("flags:     %u\n", flags);
    printf("offset:    %d\n", offset);
    printf("file_size: %llu bayt\n", (unsigned long long)file_size);
    return 0;
}

Tipleri Karıştırmak

Tek bir ifadede iki farklı tipi birleştirdiğinizde C, aritmetiği yapmadan önce onları arkanızdan dönüştürür. Bu genellikle yardımcıdır ve zaman zaman felakettir:

#include <stdio.h>

int main(void) {
    int a = 7, b = 2;

    printf("7 / 2  int olarak  = %d\n", a / b);        /* 3.5 degil, 3 */
    printf("7 / 2  2.0 ile     = %f\n", a / 2.0);      /* 3.5 */

    int  small = -1;
    unsigned int big = 1;
    printf("-1 < 1u ? %s\n", (small < big) ? "evet" : "hayir");  /* sasirtici */
    return 0;
}

Birincisi tam sayı bölmesidir: her iki işlenen de int'tir, dolayısıyla sonuç bir int'tir ve kesir atılır. Üçüncüsü daha kötüdür - işaretli bir değeri işaretsiz biriyle karşılaştırmak işaretliyi işaretsize dönüştürür ve -1'i devasa bir pozitif sayıya çevirir.

Bu dönüşüm kuralları ve onları açık dönüşümlerle nasıl denetleyeceğiniz, C'de tür dönüşümü sayfasının konusudur.