تحويل الأنواع في لغة C: التحويلات الضمنية والتحويلات الصريحة

تحوّل C القيم بين الأنواع باستمرار. وبعض تلك التحويلات تكتبه بنفسك بتحويل صريح؛ ومعظمها يؤدّيه المترجم بصمت وفق قواعد لم تخترها. ومعرفة أيّها أيّ هي الفرق بين "لماذا يكون معدّلي 3 دائمًا؟" وشيفرة تفعل ما تقول.

التحويل الضمني

كلما لقيت قيمة من نوع سياقًا يتوقّع نوعًا آخر، حوّلتها C:

#include <stdio.h>

int main(void) {
    int    i = 5;
    double d = i;        /* int -> double: 5.0، دقيق */
    char   c = 'A';
    int    code = c;     /* char -> int: 65 */
    double pi = 3.9;
    int    truncated = pi;   /* double -> int: 3، ذهبت الـ .9 */

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

التحويلات التي لا يمكن أن تفقد معلومات (int إلى double، وchar إلى int، وshort إلى long) هي توسيع وهي آمنة دائمًا. والتحويلات في الاتجاه الآخر تضييق ويمكن أن تفقد بيانات - فقد صارت 3.9 أعلاه 3 بلا تحذير ما لم تطلب واحدًا بـ -Wconversion.

التحويلات الحسابية المعتادة

حين يكون لعامل ثنائي معاملان من نوعين مختلفين، تحوّلهما C إلى نوع مشترك قبل أداء العمل. والسلّم من الأسفل إلى الأعلى:

1. كل ما هو أصغر من int (char وshort و_Bool) يُرقّى إلى int. وهذه ترقية الأعداد الصحيحة وتحدث أولًا دائمًا.
2. إن كان أحد الطرفين long double، صار الآخر long double.
3. وإلا إن كان أحدهما double، صار الآخر double.
4. وإلا إن كان أحدهما float، صار الآخر float.
5. وإلا، فبين الأنواع الصحيحة، تفوز ذات الرتبة الأعلى، وإن تعادلت الرتب فاز غير الموقّع.

وتلك القاعدة الأخيرة هي التي تسبّب أخطاءً حقيقية. أما البقية فبديهية.

#include <stdio.h>

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

    /* تُرقّى a وb إلى int أولًا، فتتّسع 10000 بلا مشكلة. */
    printf("a * b as int = %d\n", a * b);

    /* لكن تخزينها مجددًا في char يضيّقها من جديد. */
    char product = a * b;
    printf("stored in char = %d\n", product);
    return 0;
}

ترقية الأعداد الصحيحة هي سبب عدم فيضان حسابات char بالطريقة التي قد تتوقّعها - وسبب فيضانها حين تخزّن النتيجة مجددًا في char.

التحويلات الصريحة

التحويل الصريح هو النوع الهدف بين قوسين:

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

وينطبق على التعبير الذي يليه مباشرةً، ويرتبط بإحكام شديد - أوثق من * و/ و+.

#include <stdio.h>

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

    printf("no cast:        %f\n", (double)(total / count));  /* 3.0 */
    printf("cast first:     %f\n", (double)total / count);    /* 3.5 */
    printf("cast both:      %f\n", (double)total / (double)count);
    return 0;
}

يقسم السطر الأول كأعداد صحيحة (فيعطي 3) ثم يحوّل 3 إلى 3.0 - بعد فوات الأوان. أما الثاني فيحوّل total قبل القسمة، فيرى العامل / قيمة double وقيمة int، فيرقّي int ويؤدّي قسمة ذات فاصلة عائمة.

وتحويل معامل واحد يكفي. فالتحويلات الحسابية المعتادة تتولّى الآخر.

إصلاح القسمة الصحيحة

هذا هو أشيع سبب على الإطلاق لكتابة تحويل صريح في C:

#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("sum = %d\n", sum);
    printf("wrong average: %f\n", (double)(sum / n));    /* 81.000000 - قُسِم كأعداد صحيحة، ثمّ حُوِّل */
    printf("right average: %f\n", (double)sum / n);      /* 81.200000 */

    /* للنسب المئوية الفخّ نفسه. */
    int passed = 3;
    printf("wrong pct: %d%%\n", passed / n * 100);            /* 0 percent */
    printf("right pct: %.1f%%\n", 100.0 * passed / n);        /* 60.0 percent */
    return 0;
}

وسطر النسبة المئوية مفيد: فـ passed / n هي 3 / 5، وتساوي 0 كأعداد صحيحة، و0 * 100 تساوي 0. والضرب قبل القسمة (100 * passed / n) يصلحها حتى بلا تحويل صريح، لأن 300 / 5 دقيقة - لكن ذلك لا ينجح إلا حين تتعاون الأرقام. والتحويل الصريح هو الإصلاح الموثوق.

اقتطاع لا تقريب

تحويل قيمة ذات فاصلة عائمة إلى عدد صحيح يهمل الكسر. وهو يقتطع باتجاه الصفر - ولا يقرّب:

#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);    /* 3، لا 4 */
    printf("(int)-3.9  = %d\n", (int)-3.9);    /* -3، لا -4 */

    /* التقريب الحقيقي من math.h: */
    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;
}

وإن بنيت هذا على جهازك، فتذكّر أن math.h تحتاج -lm عند الربط على لينكس.

وخطر آخر: تحويل قيمة ذات فاصلة عائمة أكبر من أن يتّسع لها النوع الصحيح سلوك غير معرَّف، لا التفافًا. فـ (int)1e20 قد تنتج أي شيء. افحص المدى قبل التحويل حين لا تكون القيمة تحت سيطرتك.

char وint

قيمة char في C هي عدد صحيح صغير يحمل رمز محرف. والتحويل بين الاثنين عمل يومي:

#include <stdio.h>

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

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

    /* من محرف رقم إلى قيمته العددية: */
    char digit = '7';
    int value = digit - '0';
    printf("the character '%c' as a number is %d\n", digit, value);

    /* من كبير إلى صغير، باستخدام فجوة الـ 32 الثابتة في ASCII: */
    for (char ch = 'A'; ch <= 'E'; ch++) {
        printf("%c -> %c\n", ch, (char)(ch + 32));
    }
    return 0;
}

digit - '0' هي الاصطلاح المعياري لتحويل محرف رقم إلى قيمته، وتعمل لأن محارف الأرقام العشرة مضمون أنها متتالية. وللحروف، فضّل toupper() وtolower() من ctype.h على حساب + 32 - فالإزاحة حقيقة في ASCII لا ضمانة في C.

وفخّ مرتبط: تأخذ دوال ctype.h مثل isdigit وtoupper قيمة int يجب أن تكون إما EOF وإما قابلة للتمثيل كـ unsigned char. وتمرير char عادي سالب (وهو ممكن، إذ قد يكون char العادي موقّعًا) غير معرَّف. حوّله: isdigit((unsigned char)c).

فخّ الموقّع وغير الموقّع

الخطوة 5 من سلّم التحويل - فوز غير الموقّع عند التعادل - تُنتج أكثر مقارنات C إدهاشًا:

#include <stdio.h>

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

    if (signed_val < unsigned_val) {
        printf("-1 is less than 1  (what you expect)\n");
    } else {
        printf("-1 is NOT less than 1  (what C actually says)\n");
    }

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

تُحوَّل -1 إلى unsigned int، فيُعاد تفسير نمط بتاتها على أنه 4,294,967,295. وذلك أكبر من 1، فالمقارنة خاطئة.

والتحويل نفسه يجعل الحلقات تدور إلى الأبد:

/* BUG: i is unsigned, so i >= 0 is always true. When i is 0, i-- wraps. */
for (size_t i = n - 1; i >= 0; i--) { ... }

ويجعل فحوص الأطوال تفشل:

/* BUG: strlen returns size_t (unsigned). If the string is shorter
   than 5, len - 5 wraps to a huge number and the test passes. */
if (strlen(s) - 5 > 0) { ... }

أعد كتابتها if (strlen(s) > 5) فلا يقع الطرح إطلاقًا.

والدفاعات: أبقِ العدّادات والفهارس بإشارة واحدة في كل مكان، وترجم بـ -Wsign-compare (المتضمَّنة في -Wextra)، وحين تضطرّ إلى الخلط، حوّل صراحةً بعد التأكّد من أن القيمة لا يمكن أن تكون سالبة.

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

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

    /* آمن: قارن دون طرح. */
    if (len > 5) {
        printf("long\n");
    } else {
        printf("short: %zu characters\n", len);
    }

    /* آمن: حوّل إلى نوع موقّع بعد أن تُعرَف القيمة صغيرة. */
    int signed_len = (int)len;
    printf("len - 5 = %d\n", signed_len - 5);
    return 0;
}

تحويل المؤشّرات

تحوّل التحويلات الصريحة أيضًا بين أنواع المؤشّرات، وهي تحمل هنا خطرًا حقيقيًا لأنها تغيّر كيفية تفسير الذاكرة، لا البايتات نفسها.

#include <stdio.h>

int main(void) {
    int value = 1;
    /* انظر إلى بايتات int عبر مؤشّر char. */
    unsigned char *bytes = (unsigned char *)&value;

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

على جهاز صغير الطرف يطبع هذا 01 00 00 00. وفحص تمثيل الكائن عبر unsigned char * من تحويلات المؤشّرات القليلة التي يباركها المعيار صراحةً.

ومعظم تحويلات المؤشّرات الأخرى غير مباركة. فقراءة int عبر float * تخالف قاعدة التسمية المستعارة الصارمة وهي سلوك غير معرَّف وإن تُرجمت؛ استخدم memcpy لإعادة تفسير البايتات بدلًا من ذلك.

وعرفان يستحقّان المعرفة. يتحوّل void * من وإلى أي نوع مؤشّر كائن دون تحويل صريح في C، ولهذا ينبغي ألّا تحوّل نتيجة malloc:

int *arr = malloc(n * sizeof *arr);        /* correct C */
int *arr = (int *)malloc(n * sizeof *arr); /* needless; hides a missing header */

والتحويل مطلوب في C++، ولهذا تحمله شيفرة كثيرة. أما في C فيمكن أن يخفي خطأ نسيان <stdlib.h>.

وprintf("%p", ...) تتوقّع void *، فوسائط المؤشّرات هناك تحتاج تحويلًا فعلًا: printf("%p", (void *)p).

متى يكون التحويل الصريح الجواب الخاطئ

التحويل الصريح يُسكِت المترجم. وأحيانًا كان المترجم محقًّا.

long big = 5000000000L;
int  small = (int)big;    /* the cast hides real data loss */

إن كانت القيمة تتّسع فعلًا، وثّق التحويلُ أنك تحقّقت. وإن كانت قد لا تتّسع، فقد حوّل التحويلُ تحذيرًا إلى إجابة خاطئة صامتة. وقبل كتابة واحد، اسأل ما إذا كان الإصلاح هو تغيير نوع متغيّر بدلًا من ذلك - double بدل int، وsize_t بدل int، وlong long بدل long. والتحويل الصريح هو الأداة الصحيحة أساسًا حين يجب أن يلتقي نوعان صحيحان لعملية واحدة، كما في (double)sum / count.