Çalıştırılabilir C Dokümanları: Tür Dönüşümü

Q: C'de nasıl dönüşüm yapılır?

Hedef türü değerden önce parantez içine koyun: (double)x, (int)3.9, (char)65. Dönüşüm hemen ardından gelen ifadeye uygulanır, dolayısıyla (double)a / b önce a'yı dönüştürüp sonra böler, oysa (double)(a / b) tam sayı olarak böler ve sonucu dönüştürür.

Q: C'de bir int'i float'a nasıl dönüştürürüm?

Atama bunu örtük olarak yapar - double d = 5; 5.0 saklar. Bir ifadenin içinde çoğu zaman açık bir dönüşüme ihtiyacınız olur: (double)total / count, tam sayı bölmesi yerine kayan nokta bölmesini zorlar.

C sürekli türler arasında değer dönüştürür. Bu dönüşümlerden bazılarını bir dönüşümle kendiniz yazarsınız; çoğunu derleyici, sizin seçmediğiniz kurallar altında sessizce gerçekleştirir. Hangisinin hangisi olduğunu bilmek, "ortalamam neden hep 3?" ile söylediğini yapan kod arasındaki farktır.

Örtük Dönüşüm

Bir türden bir değer, başkasını bekleyen bir bağlamla karşılaştığında C onu dönüştürür:

#include <stdio.h>

int main(void) {
    int    i = 5;
    double d = i;        /* int -> double: 5.0, tam */
    char   c = 'A';
    int    code = c;     /* char -> int: 65 */
    double pi = 3.9;
    int    truncated = pi;   /* double -> int: 3, .9 gitti */

    printf("d         = %f\n", d);
    printf("code      = %d\n", code);
    printf("truncated = %d\n", truncated);
    return 0;
}

Bilgi kaybedemeyen dönüşümler (int'ten double'a, char'dan int'e, short'tan long'a) genişleticidir ve her zaman güvenlidir. Diğer yöndeki dönüşümler daraltıcıdır ve veri kaybedebilir - yukarıdaki 3.9, -Wconversion ile istemedikçe hiçbir uyarı olmadan 3 oldu.

Alışıldık Aritmetik Dönüşümler

Bir ikili operatörün işlenenleri farklı türlerdeyken C, işi yapmadan önce onları ortak bir türe dönüştürür. Merdiven, alttan yukarı:

int'ten küçük her şey (char, short, _Bool) int'e yükseltilir. Bu tam sayı yükseltmedir ve her zaman önce gerçekleşir.
Taraflardan biri long double ise diğeri long double olur.
Değilse biri double ise diğeri double olur.
Değilse biri float ise diğeri float olur.
Değilse, tam sayı türleri arasında rütbesi yüksek olan kazanır ve rütbeler eşitse işaretsiz kazanır.

O son kural gerçek hatalara yol açandır. Geri kalanı sezgiseldir.

#include <stdio.h>

int main(void) {
    char a = 100, b = 100;

    /* a ve b once int'e yukseltilir, dolayisiyla 10000 gayet sigar. */
    printf("a * b int olarak = %d\n", a * b);

    /* Ama onu bir char'a geri saklamak yine daraltir. */
    char product = a * b;
    printf("char'a saklandi = %d\n", product);
    return 0;
}

Tam sayı yükseltme, char aritmetiğinin neden beklediğiniz gibi taşmadığını - ve sonucu bir char'a geri saklamanın neden taştığını - açıklar.

Açık Dönüşümler

Bir dönüşüm, parantez içindeki hedef türdür:

(double)x
(int)3.9
(char)65
(unsigned int)n

Hemen ardından gelen ifadeye uygulanır ve çok sıkı bağlanır - *, / ya da +'dan daha sıkı.

#include <stdio.h>

int main(void) {
    int total = 7, count = 2;

    printf("donusum yok:    %f\n", (double)(total / count));  /* 3.0 */
    printf("once donustur:  %f\n", (double)total / count);    /* 3.5 */
    printf("ikisini de:     %f\n", (double)total / (double)count);
    return 0;
}

İlk satır tam sayı olarak böler (3 verir) ve sonra 3'ü 3.0'a dönüştürür - çok geç. İkincisi, bölmeden önce total'ı dönüştürür, dolayısıyla / operatörü bir double ve bir int görür, int'i yükseltir ve kayan nokta bölmesi yapar.

Bir işleneni dönüştürmek yeterlidir. Alışıldık aritmetik dönüşümler diğerini halleder.

Tam Sayı Bölmesini Düzeltmek

C'de bir dönüşüm yazmanın tek en yaygın sebebi budur:

#include <stdio.h>

int main(void) {
    int scores[] = {88, 92, 75, 61, 90};
    int n = 5;
    int sum = 0;

    for (int i = 0; i < n; i++) {
        sum += scores[i];
    }

    printf("toplam = %d\n", sum);
    printf("yanlis ortalama: %f\n", (double)(sum / n));    /* 81.000000 - once tam sayi olarak bolundu, SONRA donusturuldu */
    printf("dogru ortalama:  %f\n", (double)sum / n);      /* 81.200000 */

    /* Yuzdelerde ayni tuzak var. */
    int passed = 3;
    printf("yanlis yuzde: %d%%\n", passed / n * 100);            /* yuzde 0 */
    printf("dogru yuzde:  %.1f%%\n", 100.0 * passed / n);        /* yuzde 60.0 */
    return 0;
}

Yüzde satırı öğreticidir: passed / n, 3 / 5'tir ve tam sayı olarak 0'dır ve 0 * 100 0'dır. Bölmeden önce çarpmak (100 * passed / n), 300 / 5 tam olduğu için dönüşüm olmadan bile düzeltir - ama bu yalnızca sayılar işbirliği yaptığında işe yarar. Dönüşüm güvenilir çözümdür.

Kırpma, Yuvarlama Değil

Kayan noktalı bir değeri bir tam sayıya dönüştürmek kesri atar. Sıfıra doğru kırpar - yuvarlamaz:

#include <stdio.h>
#include <math.h>

int main(void) {
    printf("(int) 3.2  = %d\n", (int) 3.2);
    printf("(int) 3.9  = %d\n", (int) 3.9);    /* 4 degil, 3 */
    printf("(int)-3.9  = %d\n", (int)-3.9);    /* -4 degil, -3 */

    /* math.h'den gercek yuvarlama: */
    printf("round(3.9)  = %d\n", (int)round(3.9));    /* 4  */
    printf("round(-3.9) = %d\n", (int)round(-3.9));   /* -4 */
    printf("floor(3.9)  = %d\n", (int)floor(3.9));    /* 3  */
    printf("ceil(3.2)   = %d\n", (int)ceil(3.2));     /* 4  */
    return 0;
}

Bunu kendi makinenizde derlerseniz, math.h'nin Linux'ta bağlama zamanında -lm istediğini unutmayın.

Bir tehlike daha: tam sayı türü için çok büyük olan kayan noktalı bir değeri dönüştürmek bir sarma değil tanımsız davranıştır. (int)1e20 herhangi bir şey üretebilir. Değer sizin denetiminizde değilse dönüştürmeden önce aralığı kontrol edin.

char ve int

C'de bir char, bir karakter kodu tutan küçük bir tam sayıdır. İkisi arasında dönüşüm günlük iştir:

#include <stdio.h>

int main(void) {
    char letter = 'A';
    int code = letter;

    printf("'%c' kodu %d\n", letter, code);
    printf("code + 1 -> '%c'\n", (char)(code + 1));   /* 'B' */

    /* Rakam karakterinden sayisal degerine: */
    char digit = '7';
    int value = digit - '0';
    printf("'%c' karakteri sayi olarak %d\n", digit, value);

    /* ASCII'deki sabit 32'lik boslukla buyukten kucuge: */
    for (char ch = 'A'; ch <= 'E'; ch++) {
        printf("%c -> %c\n", ch, (char)(ch + 32));
    }
    return 0;
}

digit - '0', bir rakam karakterini değerine çevirmenin standart deyimidir ve on rakam karakterinin ardışık olması garanti olduğu için çalışır. Harfler için + 32 aritmetiği yerine ctype.h'deki toupper() ve tolower()'ı tercih edin - kayma bir ASCII olgusudur, bir C garantisi değil.

İlgili bir tuzak: ctype.h'deki isdigit ve toupper gibi fonksiyonlar, ya EOF olması ya da unsigned char olarak gösterilebilmesi gereken bir int alır. Negatif olan düz bir char geçirmek (düz char işaretli olabileceği için mümkündür) tanımsızdır. Onu dönüştürün: isdigit((unsigned char)c).

İşaretli/İşaretsiz Tuzağı

Dönüşüm merdiveninin 5. adımı - eşitlikte işaretsiz kazanır - C'nin en şaşırtıcı karşılaştırmasını üretir:

#include <stdio.h>

int main(void) {
    int          signed_val = -1;
    unsigned int unsigned_val = 1;

    if (signed_val < unsigned_val) {
        printf("-1, 1'den kucuk  (bekledigniz)\n");
    } else {
        printf("-1, 1'den kucuk DEGIL  (C'nin gercekte soyledigi)\n");
    }

    printf("(unsigned)-1 = %u\n", (unsigned int)signed_val);
    return 0;
}

-1, bit örüntüsünü 4.294.967.295 olarak yeniden yorumlayan unsigned int'e dönüştürülür. Bu 1'den büyüktür, dolayısıyla karşılaştırma yanlıştır.

Aynı dönüşüm döngüleri sonsuza dek çalıştırır:

/* HATA: i işaretsizdir, dolayısıyla i >= 0 her zaman doğrudur. i 0 iken i-- sarar. */
for (size_t i = n - 1; i >= 0; i--) { ... }

Ve uzunluk denetimlerini başarısız kılar:

/* HATA: strlen, size_t (işaretsiz) döndürür. Metin 5'ten kısaysa
   len - 5 devasa bir sayıya sarar ve test geçer. */
if (strlen(s) - 5 > 0) { ... }

Bunu if (strlen(s) > 5) olarak yeniden yazın, çıkarma hiç gerçekleşmez.

Savunmalar: sayıları ve indeksleri baştan sona tek bir işaretlilikte tutun, -Wsign-compare ile derleyin (-Wextra içinde bulunur) ve karıştırmanız gerektiğinde, değerin negatif olamayacağını saptadıktan sonra açıkça dönüştürün.

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

int main(void) {
    const char *s = "hi";
    size_t len = strlen(s);

    /* Guvenli: cikarma yapmadan karsilastir. */
    if (len > 5) {
        printf("uzun\n");
    } else {
        printf("kisa: %zu karakter\n", len);
    }

    /* Guvenli: deger kucuk oldugu bilinince isaretli bir tipe donustur. */
    int signed_len = (int)len;
    printf("len - 5 = %d\n", signed_len - 5);
    return 0;
}

Göstericileri Dönüştürmek

Dönüşümler gösterici türleri arasında da dönüştürür ve burada gerçek risk taşırlar, çünkü baytların kendisini değil belleğin nasıl yorumlandığını değiştirirler.

#include <stdio.h>

int main(void) {
    int value = 1;
    /* Bir int'in baytlarini bir char gostericisiyle goruntule. */
    unsigned char *bytes = (unsigned char *)&value;

    printf("int 1 su baytlarla saklaniyor:");
    for (size_t i = 0; i < sizeof(int); i++) {
        printf(" %02x", bytes[i]);
    }
    printf("\n");
    return 0;
}

Küçük-sonlu (little-endian) bir makinede bu 01 00 00 00 yazdırır. Nesne gösterimini bir unsigned char * üzerinden incelemek, standardın açıkça onayladığı birkaç gösterici dönüşümünden biridir.

Diğer gösterici dönüşümlerinin çoğu onaylı değildir. Bir int'i bir float * üzerinden okumak katı takma ad (strict aliasing) kuralını ihlal eder ve derlense bile tanımsız davranıştır; baytları yeniden yorumlamak için bunun yerine memcpy kullanın.

Bilmeye değer iki gelenek. C'de void *, her nesne gösterici türüne ve türünden dönüşüm olmadan dönüşür; malloc'un sonucunu dönüştürmemeniz gerekmesinin sebebi budur:

int *arr = malloc(n * sizeof *arr);        /* doğru C */
int *arr = (int *)malloc(n * sizeof *arr); /* gereksiz; eksik bir başlığı gizler */

Dönüşüm C++'ta zorunludur; bu kadar çok kodun onu içermesinin sebebi budur. C'de <stdlib.h>'yi unutma hatasını gizleyebilir.

Ve printf("%p", ...) bir void * bekler, dolayısıyla oradaki gösterici argümanları gerçekten bir dönüşüme ihtiyaç duyar: printf("%p", (void *)p).

Bir Dönüşümün Yanlış Cevap Olduğu Zaman

Bir dönüşüm derleyiciyi susturur. Bazen derleyici haklıydı.

long big = 5000000000L;
int  small = (int)big;    /* dönüşüm gerçek veri kaybını gizler */

Değer gerçekten sığıyorsa dönüşüm, denetlediğinizi belgeler. Sığmayabiliyorsa dönüşüm, bir uyarıyı sessiz bir yanlış cevaba çevirmiştir. Birini yazmadan önce çözümün bir değişkenin tipini değiştirmek olup olmadığını sorun - int yerine double, int yerine size_t, long yerine long long. Bir dönüşüm esas olarak, (double)sum / count'ta olduğu gibi, iki doğru türün tek bir işlem için buluşması gerektiğinde doğru araçtır.

Sıkça Sorulan Sorular

C'de nasıl dönüşüm yapılır?

Hedef türü değerden önce parantez içine koyun: (double)x, (int)3.9, (char)65. Dönüşüm hemen ardından gelen ifadeye uygulanır, dolayısıyla (double)a / b önce a'yı dönüştürüp sonra böler, oysa (double)(a / b) tam sayı olarak böler ve sonucu dönüştürür.

C'de bir int'i float'a nasıl dönüştürürüm?

Atama bunu örtük olarak yapar - double d = 5; 5.0 saklar. Bir ifadenin içinde çoğu zaman açık bir dönüşüme ihtiyacınız olur: (double)total / count, tam sayı bölmesi yerine kayan nokta bölmesini zorlar.

C'de bir float'ı int'e dönüştürünce ne olur?

Kesirli kısım atılır - sıfıra doğru kırpılır, asla yuvarlanmaz. (int)3.9 3 ve (int)-3.9 -3'tür. Yuvarlamak için pozitifler için dönüşümden önce 0.5 ekleyin ya da math.h'deki round(), floor() veya ceil()'i kullanın.

İşaretli ile işaretsiz bir int'i karşılaştırmak neden yanlış cevap veriyor?

C'nin alışıldık aritmetik dönüşümleri işaretli değeri işaretsize dönüştürür, dolayısıyla -1 < 1u yanlıştır: -1 devasa bir pozitif sayı olur. Sayıları ve boyutları tek bir işaretlilikte tutun ya da değerin negatif olamayacağını denetledikten sonra açıkça dönüştürün.

İlgili kavramlar