printf في لغة C: سلاسل التنسيق والمحدّدات وطباعة الأعداد العشرية

printf أول دالة يتعلّمها كل مبرمج C وآخر دالة يقرأ معظمهم دليلها كاملًا. وهي تستحق عشر دقائق، لأن سلسلة تنسيقها لغة صغيرة قائمة بذاتها - ولأن الخطأ في محدّد ليس خطأً مطبعيًا بل سلوكًا غير معرَّف.

وهي تعيش في <stdio.h>، فكل برنامج يستخدمها يبدأ بـ #include <stdio.h>.

نموذج سلسلة التنسيق

تمشي printf على سلسلة التنسيق محرفًا واحدًا في كل مرة. وكل ما ليس % يُطبع كما كُتب تمامًا. أما % فتبدأ مواصفة تحويل تلتهم الوسيط التالي وتطبعه بالصيغة المطلوبة.

#include <stdio.h>

int main(void) {
    int    count = 5;
    double price = 2.5;
    char   grade = 'A';
    const char *name = "apples";

    printf("Plain text, no arguments.\n");
    printf("%d %s cost $%.2f (grade %c)\n", count, name, price, grade);
    return 0;
}

تُطابَق الوسائط بالمحدّدات بحسب الموضع حصرًا: فأول % تأخذ count، والثانية تأخذ name، وهكذا. ولا تملك printf وسيلة للتحقّق من أنك مرّرت ما وعدت به - إذ لا تستطيع رؤية الأنواع - فسلسلة التنسيق عقد عليك الوفاء به. وهذا ما يجعل -Wall جديرة بالتفعيل: فـ GCC يقرأ سلسلة التنسيق الحرفية في وقت الترجمة ويحذّر حين لا يطابق وسيط.

ولا شيء يفرض سطرًا جديدًا. فـ printf("Hello") تترك المؤشّر بعد الحرف o، ولهذا تكاد كل سلسلة تنسيق تنتهي بـ \n.

المحدّدات التي تستخدمها يوميًا

خمسة تغطّي معظم الشيفرة:

#include <stdio.h>

int main(void) {
    int x = 42;

    printf("int     : %d\n", x);
    printf("double  : %f\n", 2.5);
    printf("string  : %s\n", "hello");
    printf("char    : %c\n", 'A');
    printf("pointer : %p\n", (void *)&x);
    printf("percent : 100%%\n");
    return 0;
}

وتختبئ قاعدتان في تلك القصاصة. تُكتب علامة % الحرفية %% - فعلامة % وحيدة في آخر سلسلة تنسيق سلوك غير معرَّف. و%p تتطلّب void *، فحوّل المؤشّر؛ وتمرير int * مباشرةً غير معرَّف تقنيًا وإن طُبع بشكل سليم عمليًا.

والجدول الكامل - كل محدّد وكل معدِّل طول وعمود scanf - في صفحة محدّدات التنسيق. وتبقى هذه الصفحة مع ما تلجأ إليه فعلًا.

العرض والدقّة والمحاذاة

بين % والحرف يمكنك وضع رايات وعرض ودقّة. وهذا كيف تحوّل حلقة إلى جدول.

#include <stdio.h>

int main(void) {
    printf("|%5d|\n", 42);        /* عرض 5، حشو قبل القيمة */
    printf("|%-5d|\n", 42);       /* راية الناقص: حشو بعد القيمة */
    printf("|%05d|\n", 42);       /* راية الصفر: حشو بأصفار */
    printf("|%+d|\n", 42);        /* راية الزائد: أظهر الإشارة دائمًا */
    printf("|%8.2f|\n", 3.14159); /* عرض 8، ورقمان بعد النقطة */
    printf("|%-10s|\n", "ok");    /* السلاسل تُحشى أيضًا */
    printf("|%.3s|\n", "truncate me");  /* الدقّة على سلسلة تقتطعها */
    return 0;
}

العرض حدّ أدنى لا حدّ أقصى أبدًا: فـ %3d مع القيمة 123456 تطبع الأرقام الستة كلها. أما الدقّة فتعني أشياء مختلفة بحسب النوع - أرقامًا بعد الفاصلة العشرية لـ %f، وأقصى عدد محارف لـ %s، وأدنى عدد أرقام لـ %d.

ويمكن توفير كليهما في وقت التشغيل بـ *، التي تقرأ وسيطًا من نوع int:

#include <stdio.h>

int main(void) {
    const char *names[] = {"Ada", "Grace", "Alan"};
    double scores[] = {92.5, 105.25, 87.0};
    int width = 10;

    printf("%-*s %8s\n", width, "NAME", "SCORE");
    for (int i = 0; i < 3; i++) {
        printf("%-*s %8.2f\n", width, names[i], scores[i]);
    }
    return 0;
}

وتغيير width يعيد توزيع الجدول كله. وهذه هي الطريقة المعيارية لطباعة أعمدة مصطفّة في C - دون حاجة إلى دالة حشو نصوص.

طباعة الأعداد العشرية بعقل

%f بلا دقّة تطبع دائمًا ستة أرقام بعد النقطة، وهو ما نادرًا ما يريده أحد:

#include <stdio.h>

int main(void) {
    double value = 1234.5;
    double tiny  = 0.000012345;
    double huge  = 123456789012.0;

    printf("%%f    : %f\n", value);
    printf("%%.2f  : %.2f\n", value);
    printf("%%.0f  : %.0f\n", value);
    printf("%%e    : %e\n", tiny);
    printf("%%g    : %g\n", tiny);
    printf("%%g    : %g\n", huge);
    printf("%%g    : %g\n", value);
    return 0;
}

ثلاثة خيارات، ولكلٍّ منها قاعدة إرشادية:

• %.Nf للنقود والقياسات وكل ما له عدد منازل طبيعي. و%.2f هي ما تريده للعملات.
• %e للترميز العلمي، دائمًا d.dddddde±dd.
• %g حين لا تعرف رتبة المقدار مسبقًا. فهي تختار %f أو %e أيّهما أقصر وتزيل الأصفار الختامية - وهي الافتراضي الأعقل لتسجيل قيمة لم ترها.

وفخّ يستحق القول بوضوح: لا يوجد %lf في printf. فوسائط float تُرقّى إلى double قبل أن تراها printf أصلًا، فتتولّى %f الاثنين، و%lf لا معنى لها إلا في scanf حيث يهمّ حجم الوجهة. (تقبل C99 فعلًا %lf في printf كمرادف، لكن عادة كتابتها تقود الناس إلى كتابة %f في scanf، وهو ما يعطب فعلًا.)

الأعداد الصحيحة بعروض أخرى

%d لأجل int. أما الأنواع الأكبر أو غير الموقّعة فتحتاج معدِّل طول، وعدم تطابقها سلوك غير معرَّف لا خطأ تقريب:

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

int main(void) {
    long           big  = 3000000000L;
    unsigned int   u    = 4000000000u;
    size_t         len  = sizeof "hello";
    uint64_t       id   = 1234567890123456789ULL;

    printf("long     : %ld\n", big);
    printf("unsigned : %u\n", u);
    printf("size_t   : %zu\n", len);
    printf("uint64_t : %llu\n", (unsigned long long)id);

    printf("hex      : %x  HEX: %X  octal: %o\n", 255, 255, 8);
    return 0;
}

و%zu لأجل size_t هي ما يخطئ فيه الناس أكثر - فـ sizeof تُرجِع size_t لا int، فـ printf("%d", sizeof x) خطأ يصادف أن يعمل على أنظمة 32 بتًا ويسيء التصرّف على أنظمة 64 بتًا.

القيمة المُرجَعة

تُرجِع printf عدد المحارف التي كتبتها، أو عددًا سالبًا عند الفشل. وهي تُتجاهَل عادةً، وهذا مقبول في الغالب - لكنها مفيدة فعلًا حين تحتاج إلى معرفة عرض الخرج:

#include <stdio.h>

int main(void) {
    int written = printf("Hello, world!\n");
    printf("that call wrote %d characters\n", written);

    /* مفيدة لتسطير شيء لا تعرف عرضه: */
    const char *title = "Report";
    int n = printf("%s\n", title) - 1;   /* ناقص السطر الجديد */
    for (int i = 0; i < n; i++) {
        putchar('=');
    }
    putchar('\n');
    return 0;
}

وتكتب sprintf وsnprintf القريبتان في مخزن بدل الشاشة، وتُرجِعان الطول الذي أنتجتاه. وفضّل دائمًا snprintf، التي تأخذ حجم المخزن ولا يمكن أن تفيض:

#include <stdio.h>

int main(void) {
    char buffer[32];
    int n = snprintf(buffer, sizeof buffer, "%s scored %.1f", "Ada", 92.5);

    printf("[%s] (%d chars wanted)\n", buffer, n);
    return 0;
}

وتُرجِع snprintf الطول الذي كانت ستحتاجه السلسلة الكاملة، فقيمة مُرجَعة تساوي حجم المخزن أو تزيد عليها تخبرك بأن الخرج اقتُطع.

ثغرة سلسلة التنسيق

هذه هي المشكلة الأمنية الوحيدة في printf، وهي خطيرة. لا تمرّر أبدًا بيانات لم تكتبها كسلسلة تنسيق:

/* DANGEROUS - never do this */
printf(user_input);

/* Correct */
printf("%s", user_input);

إن احتوت user_input على %s، قرأت printf وسيطًا لم يُمرَّر قط واتّبعت أي قمامة على هيئة مؤشّر تجدها، فتنهار عادةً. و%x مكرّرة تُفرغ محتويات المكدّس على الشاشة، وقد تتضمّن كلمات مرور أو مفاتيح. و%n، التي تكتب عدد المحارف في وسيط، حوّلت هذا تاريخيًا إلى إفساد اعتباطي للذاكرة وتنفيذ شيفرة عن بُعد.

والقاعدة مطلقة ولا تكلّف شيئًا: سلسلة التنسيق دائمًا ثابت نصّي كتبته أنت. وأي شيء متغيّر يدخل كوسيط. وراية -Wformat-security في GCC تنبّه إلى الخطأ، وهي متضمَّنة في -Wall -Wextra.

التخزين المؤقّت: لماذا يظهر الخرج متأخّرًا أحيانًا

لا تكتب printf إلى الطرفية فورًا. فالخرج مخزَّن مؤقّتًا - ويُفرَّغ حين يمتلئ المخزن، أو حين يظهر سطر جديد على طرفية، أو حين ينتهي البرنامج بشكل طبيعي. ونتيجتان لذلك:

• قد يفقد البرنامج الذي ينهار خرجًا "طُبع سلفًا". فإن كنت تنقّح بـ printf ولم تظهر الرسالة الأخيرة، فقد وقع الانهيار بعد ذلك السطر لا قبله. أضف fflush(stdout) أو أرسل خرج التنقيح إلى stderr غير المخزَّن مؤقّتًا.
• وfprintf(stderr, ...) هي الطريقة الصحيحة لطباعة الأخطاء. فهي غير مخزَّنة مؤقّتًا، وتذهب إلى تيار منفصل يستطيع المستخدمون إعادة توجيهه مستقلًّا عن الخرج العادي.

#include <stdio.h>

int main(void) {
    printf("normal output goes to stdout\n");
    fprintf(stderr, "errors go to stderr\n");
    fflush(stdout);
    return 0;
}