در قسمت ۳۵ آموزش امبدد C با نحوه دریافت اطلاعات در زبان C، خواندن دادههای متنی، استفاده از تابع fgets، تبدیل رشته به عدد با sscanf و همچنین بازکردن، خواندن و نوشتن فایلهای متنی آشنا شدیم.
در این قسمت قصد داریم یک قدم جلوتر برویم و با نوع دیگری از فایلها به نام فایلهای باینری (Binary Files) آشنا شویم. برخلاف فایلهای متنی که اطلاعات را به شکل نویسههای قابلخواندن ذخیره میکنند، در فایلهای باینری دادهها بهصورت مستقیم و در قالب بایتها ذخیره میشوند.
در ادامه، توابع fread و fwrite را بررسی میکنیم، یک برنامه برای کپیکردن فایل مینویسیم و در پایان با مفهوم Buffering و نحوه تخلیه بافر با استفاده از تابع fflush آشنا خواهیم شد.
در برنامهنویسی C، فایلها را میتوان به دو گروه کلی متنی و باینری تقسیم کرد. در فایل متنی (Text File)، اطلاعات به شکل کاراکترها ذخیره میشوند. برای مثال، اگر عدد 123 را در یک فایل متنی ذخیره کنیم، در واقع کاراکترهای مربوط به ارقام 1، 2 و 3 در فایل قرار میگیرند.
اما در فایل باینری (Binary File)، اطلاعات به شکل مستقیم و در قالب بایت ذخیره میشوند. در این حالت، دادهها الزاماً قابلخواندن برای انسان نیستند و ممکن است شامل مقادیر صفر، کاراکترهای غیرقابلچاپ و هر نوع ترکیب بایتی باشند.
برای مثال، اگر بخواهیم مقدار 123 را در یک فایل باینری ذخیره کنیم، میتوانیم مقدار عددی آن را در قالب بایتهای حافظه بنویسیم؛ نه اینکه الزاماً سه کاراکتر متنی 1، 2 و 3 را ذخیره کنیم. مهمترین تفاوت این دو نوع فایل در نحوه تفسیر و ذخیره اطلاعات است. فایل متنی برای مشاهده و ویرایش انسانی مناسبتر است، در حالی که فایل باینری برای ذخیره مستقیم دادهها و جابهجایی حجم زیادی از اطلاعات کاربرد دارد.
| ویژگی | فایل متنی | فایل باینری |
|---|---|---|
| نحوه ذخیرهسازی | نویسههای متنی | بایتهای خام |
| قابلیت خواندن توسط انسان | معمولاً دارد | معمولاً ندارد |
| نمایش اطلاعات | با ویرایشگر متن | معمولاً با ابزارهای مخصوص |
| کاربرد | فایل تنظیمات و گزارشها | تصاویر، دادههای خام و فایلهای ذخیرهسازی |

شکل ۳۶-۱ ـ مقایسه نحوه ذخیرهسازی عدد در فایل متنی و فایل باینری
برای خواندن اطلاعات از یک فایل باینری در زبان C از تابع fread استفاده میکنیم. این تابع اطلاعات را از فایل دریافت کرده و در یک ناحیه از حافظه (Buffer) قرار میدهد. ساختار کلی تابع به شکل زیر است:
| 1 | fread(buffer, elementSize, count, file); |
پارامترهای این تابع عبارتاند از:
buffer: آدرس حافظهای که اطلاعات خواندهشده در آن قرار میگیرند.elementSize: اندازه هر عنصر بر حسب بایت.count: تعداد عناصری که قرار است خوانده شوند.file: اشارهگر فایل که قبلاً با fopen باز شده است.تابع fread تعداد عناصر خواندهشده را برمیگرداند. اگر اندازه هر عنصر را برابر 1 قرار دهیم، مقدار بازگشتی در واقع تعداد بایتهای خواندهشده خواهد بود.
به همین دلیل در بسیاری از برنامهها از ساختار زیر استفاده میشود:
| 1 2 3 | size_t bytesRead; bytesRead = fread(buffer, 1, sizeof(buffer), file); |
در این مثال، تابع تلاش میکند به اندازه ظرفیت بافر اطلاعات بخواند. اگر فایل کمتر از این مقدار داده داشته باشد، فقط همان مقدار موجود خوانده میشود.
نکته فنی: نوع بازگشتی fread از نوع size_t است و مقدار منفی برنمیگرداند. برای تشخیص خطای خواندن باید از تابع ferror استفاده کنیم و برای تشخیص رسیدن به انتهای فایل نیز میتوانیم feof را بررسی کنیم.
برای نوشتن اطلاعات در یک فایل باینری از تابع fwrite استفاده میکنیم. این تابع از نظر ساختار بسیار شبیه fread است؛ با این تفاوت که بهجای خواندن اطلاعات از فایل، دادهها را از حافظه دریافت کرده و در فایل ذخیره میکند.
ساختار کلی تابع:
| 1 | fwrite(buffer, elementSize, count, file); |
پارامترهای آن عبارتاند از:
buffer: آدرس دادههایی که قرار است در فایل نوشته شوند.elementSize: اندازه هر عنصر بر حسب بایت.count: تعداد عناصری که باید نوشته شوند.file: اشارهگر فایل مقصد.مقدار بازگشتی fwrite تعداد عناصری است که با موفقیت نوشته شدهاند. بنابراین اگر elementSize برابر 1 باشد، مقدار بازگشتی تعداد بایتهای نوشتهشده را نشان میدهد.
برای مثال:
| 1 2 3 | size_t bytesWritten; bytesWritten = fwrite(buffer, 1, sizeof(buffer), file); |
اگر مقدار بازگشتی با تعداد بایتهایی که قصد نوشتن آنها را داشتیم برابر نباشد، باید احتمال خطای نوشتن را بررسی کنیم.
| ویژگی | fread | fwrite |
|---|---|---|
| عملکرد | خواندن اطلاعات | نوشتن اطلاعات |
| مبدأ داده | فایل | حافظه |
| مقصد داده | حافظه | فایل |
| مقدار بازگشتی | تعداد عناصر خواندهشده | تعداد عناصر نوشتهشده |
شکل ۳۶-۲ ـ نحوه انتقال داده بین حافظه و فایل با استفاده از توابع fread و fwrite
برای درک بهتر عملکرد این توابع، ابتدا برنامهای مینویسیم که تعدادی بایت مشخص را در یک فایل باینری ذخیره کند. در مثال زیر، یک آرایه از نوع unsigned char تعریف میکنیم و مقادیر آن را با استفاده از fwrite در فایل data.bin مینویسیم.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 | #include <stdio.h> #include <stdlib.h> int main(void) { const unsigned char data[] = { 0x10, 0x20, 0x30, 0x40, 0x00, 0xFF }; FILE *file = fopen("data.bin", "wb"); if (file == NULL) { perror("fopen data.bin"); return EXIT_FAILURE; } size_t written = fwrite( data, 1, sizeof(data), file ); if (written != sizeof(data)) { fprintf(stderr, "Error writing binary file.\n"); fclose(file); return EXIT_FAILURE; } if (fclose(file) == EOF) { perror("fclose data.bin"); return EXIT_FAILURE; } printf("Binary file created successfully.\n"); return EXIT_SUCCESS; } |
خروجی برنامه:
| 1 | Binary file created successfully. |
پس از اجرای برنامه، فایلی با نام data.bin در پوشه کاری برنامه ایجاد میشود. این فایل شامل شش بایت اطلاعات است:
| 1 | 10 20 30 40 00 FF |
دقت کنید که مقدار 0x00 نیز بهعنوان یک بایت معتبر در فایل ذخیره شده است. این یکی از تفاوتهای مهم فایل باینری با رشتههای متنی است؛ زیرا در فایل باینری وجود بایت صفر به معنی پایان اطلاعات نیست.
حالا میخواهیم اطلاعاتی را که در مرحله قبل ذخیره کردیم، دوباره از فایل بخوانیم. برای این کار فایل را با حالت rb باز میکنیم. حرف r نشاندهنده حالت خواندن و حرف b نشاندهنده حالت باینری است. سپس با استفاده از fread اطلاعات را داخل یک آرایه قرار میدهیم و با یک حلقه، مقدار هر بایت را به شکل هگزادسیمال نمایش میدهیم.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 | #include <stdio.h> #include <stdlib.h> int main(void) { unsigned char data[16]; FILE *file = fopen("data.bin", "rb"); if (file == NULL) { perror("fopen data.bin"); return EXIT_FAILURE; } size_t bytesRead = fread( data, 1, sizeof(data), file ); if (ferror(file)) { fprintf(stderr, "Error reading binary file.\n"); fclose(file); return EXIT_FAILURE; } printf("Read %zu byte(s):", bytesRead); for (size_t i = 0; i < bytesRead; ++i) { printf(" %02X", (unsigned int)data[i]); } printf("\n"); if (fclose(file) == EOF) { perror("fclose data.bin"); return EXIT_FAILURE; } return EXIT_SUCCESS; } |
خروجی برنامه:
| 1 | Read 6 byte(s): 10 20 30 40 00 FF |
همانطور که مشاهده میکنید، اطلاعاتی که قبلاً در فایل ذخیره کرده بودیم، بدون تغییر خوانده شدهاند.
در این مثال، بافر ظرفیت 16 بایت دارد، اما فقط 6 بایت در فایل موجود است. به همین دلیل fread فقط 6 بایت را برمیگرداند. برای تشخیص اینکه خواندن به دلیل پایان فایل متوقف شده یا خطایی رخ داده است، از ferror و در صورت نیاز feof استفاده میکنیم.
یکی از کاربردهای مهم توابع fread و fwrite، کپیکردن فایلهاست.
فرض کنید فایلی با نام infile.bin داریم و میخواهیم تمام اطلاعات آن را در فایل دیگری با نام outfile.bin ذخیره کنیم.
برای این کار نیازی نیست کل محتوای فایل را یکباره وارد حافظه کنیم. میتوانیم یک بافر موقت ایجاد کنیم و اطلاعات را در بخشهای کوچک بخوانیم و بنویسیم.
در مثال کتاب، اندازه این بافر 512 بایت در نظر گرفته شده است. بنابراین برنامه در هر مرحله حداکثر 512 بایت از فایل مبدأ میخواند و سپس همان مقدار را در فایل مقصد مینویسد.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 | #include <stdio.h> #include <stdlib.h> int main(void) { /* Open the input file */ FILE *inFile = fopen("infile.bin", "rb"); if (inFile == NULL) { perror("Could not open infile.bin"); return EXIT_FAILURE; } /* Open the output file */ FILE *outFile = fopen("outfile.bin", "wb"); if (outFile == NULL) { perror("Could not create outfile.bin"); fclose(inFile); return EXIT_FAILURE; } unsigned char buffer[512]; size_t bytesRead; int failed = 0; while ((bytesRead = fread( buffer, 1, sizeof(buffer), inFile )) > 0) { size_t bytesWritten = fwrite( buffer, 1, bytesRead, outFile ); if (bytesWritten != bytesRead) { fprintf(stderr, "Write error while copying.\n"); failed = 1; break; } } /* Check for a read error */ if (ferror(inFile)) { fprintf(stderr, "Read error while copying.\n"); failed = 1; } /* Close both files */ if (fclose(inFile) == EOF) { perror("Closing input file"); failed = 1; } if (fclose(outFile) == EOF) { perror("Closing output file"); failed = 1; } if (failed) { return EXIT_FAILURE; } printf("File copied successfully.\n"); return EXIT_SUCCESS; } |
خروجی برنامه در صورت موفقیت:
| 1 | File copied successfully. |
این برنامه ابتدا فایل مبدأ را با حالت rb باز میکند تا اطلاعات آن بهصورت باینری خوانده شوند. سپس فایل مقصد با حالت wb ایجاد میشود. در حلقه اصلی برنامه، تابع fread حداکثر 512 بایت از فایل مبدأ میخواند. تعداد بایتهای خواندهشده در متغیر bytesRead قرار میگیرد. سپس همان تعداد بایت با استفاده از fwrite در فایل مقصد نوشته میشود. اگر تعداد بایتهای نوشتهشده با تعداد بایتهای خواندهشده برابر نباشد، برنامه خطای نوشتن را گزارش میکند.
این موضوع اهمیت زیادی دارد؛ زیرا در آخرین مرحله ممکن است حجم اطلاعات باقیمانده کمتر از 512 بایت باشد. بنابراین نباید همیشه کل ظرفیت بافر را بنویسیم، بلکه باید دقیقاً به اندازه دادهای که خواندهایم عملیات نوشتن انجام دهیم. همچنین در این نسخه، برای تشخیص خطای خواندن از ferror استفاده شده است. در پایان نیز نتیجه بستن هر دو فایل بررسی میشود.
شکل ۳۶-۳ ـ فرآیند خواندن اطلاعات از فایل مبدأ، انتقال به بافر حافظه و نوشتن در فایل مقصد
یکی از مفاهیم مهم در سیستم ورودی و خروجی زبان C، Buffering یا بافرگذاری است.
وقتی با استفاده از تابع printf در زبان c اطلاعاتی را نمایش میدهیم یا با fwrite دادههایی را در فایل مینویسیم، لزوماً اطلاعات بلافاصله به مقصد نهایی ارسال نمیشوند.
در بسیاری از مواقع، کتابخانه استاندارد C ابتدا دادهها را در یک فضای حافظه موقت به نام Buffer قرار میدهد و پس از جمعشدن مقدار مناسبی از اطلاعات، آنها را به مقصد ارسال میکند.
این روش باعث افزایش کارایی میشود؛ زیرا بهجای انجام تعداد زیادی عملیات کوچک ورودی و خروجی، میتوانیم دادهها را به شکل دستهای منتقل کنیم.
در کتابخانه استاندارد C سه حالت اصلی برای بافرگذاری جریانها وجود دارد:
| نوع بافرگذاری | توضیح |
|---|---|
| Fully Buffered | دادهها تا پرشدن بافر یا اجرای عملیات تخلیه بافر در حافظه نگهداری میشوند. |
| Line Buffered | معمولاً با رسیدن کاراکتر پایان خط یا پرشدن بافر، دادهها ارسال میشوند. |
| Unbuffered | دادهها بدون نگهداری در یک بافر خروجی معمول، به مقصد ارسال میشوند. |
برای مثال، در بسیاری از محیطها وقتی جریان stdout به یک ترمینال متصل است، خروجی بهصورت خطی بافر میشود؛ یعنی با چاپ کاراکتر پایان خط \n اطلاعات ارسال میشوند. البته رفتار دقیق بافرگذاری میتواند به محیط اجرا و نحوه اتصال جریان خروجی بستگی داشته باشد.
گاهی اوقات لازم است اطلاعاتی که در بافر قرار گرفتهاند، بدون انتظار برای پرشدن بافر یا وقوع یک شرط دیگر، به مقصد ارسال شوند. برای این کار از تابع fflush استفاده میکنیم.
ساختار کلی تابع:
| 1 | fflush(stream); |
با اجرای این دستور، اطلاعات خروجی بافرشده مربوط به جریان مشخصشده به مقصد ارسال میشوند. برای مثال، دستور زیر باعث میشود خروجی بافرشده مربوط به جریان استاندارد خروجی، یعنی stdout، تخلیه شود:
| 1 | fflush(stdout); |
فرض کنید برنامهای داریم که باید قبل از انجام یک عملیات، پیامی را در ترمینال نمایش دهد. اگر پیام را بدون کاراکتر پایان خط چاپ کنیم، ممکن است در بعضی محیطها نمایش آن تا زمان تخلیه بافر به تأخیر بیفتد. برای اطمینان از ارسال پیام، میتوانیم از fflush استفاده کنیم:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | #include <stdio.h> #include <stdlib.h> int main(void) { printf("Preparing the report..."); if (fflush(stdout) == EOF) { perror("fflush"); return EXIT_FAILURE; } /* Perform the operation here */ printf(" done.\n"); return EXIT_SUCCESS; } |
خروجی:
| 1 | Preparing the report... done. |
در این مثال، پس از اجرای printf، تابع fflush(stdout) فراخوانی میشود تا متن موجود در بافر خروجی به مقصد ارسال شود.
این موضوع در زمان دیباگ برنامهها نیز اهمیت دارد. برای مثال، اگر برنامه به دلیل بروز خطا متوقف شود، ممکن است بخشی از پیامهای خروجی هنوز در بافر باشند و فرصت نمایش پیدا نکنند. در چنین شرایطی استفاده درست از fflush میتواند به مشاهده بهتر پیامهای دیباگ کمک کند.
نکته: استفاده مداوم از fflush بعد از هر عملیات کوچک نوشتن، ممکن است مزیت عملکردی بافرگذاری را کاهش دهد. همچنین این تابع برای تخلیه خروجی بافرشده طراحی شده است و نباید از آن بهعنوان روشی قابلحمل برای پاککردن ورودی صفحهکلید استفاده کرد.
شکل ۳۶-۴ ـ ذخیره موقت اطلاعات در بافر و ارسال آنها به مقصد با استفاده از fflush
پس از پایان عملیات خواندن یا نوشتن، باید فایل را ببندیم. برای این کار از تابع fclose استفاده میکنیم. ساختار این تابع به شکل زیر است:
| 1 | int result = fclose(file); |
در این دستور، file همان اشارهگری است که هنگام بازکردن فایل با fopen دریافت کردهایم. تابع fclose پس از پایان کار با فایل، جریان مربوط به آن را میبندد. در صورتی که اطلاعات خروجی هنوز در بافر باشند، تلاش میکند آنها را نیز قبل از بستهشدن جریان ارسال کند. مقدار بازگشتی تابع به شکل زیر تفسیر میشود:
0: عملیات بستن فایل با موفقیت انجام شده است.EOF: هنگام بستن فایل خطایی رخ داده است.به همین دلیل، بهتر است نتیجه اجرای fclose را نیز بررسی کنیم؛ زیرا ممکن است خطای نوشتن اطلاعات بافرشده تنها هنگام بستن فایل مشخص شود.
کار با فایلهای باینری و مدیریت بافرها در پروژههای امبدد اهمیت زیادی دارد؛ بهخصوص زمانی که قرار است حجم زیادی از دادهها از یک حافظه یا رابط ارتباطی به مقصد دیگری منتقل شوند. برای مثال، در یک سیستم ثبت اطلاعات سنسورها (Data Logger)، ممکن است مقادیر اندازهگیریشده بهصورت باینری روی کارت حافظه ذخیره شوند. در چنین شرایطی میتوان از روشهای خواندن و نوشتن دستهای برای انتقال دادهها استفاده کرد.
همچنین در سیستمهای مبتنی بر Embedded Linux، توابع استاندارد C مانند fread و fwrite میتوانند برای کار با فایلهای داده، فایلهای پیکربندی و ذخیرهسازی اطلاعات مورد استفاده قرار بگیرند.
البته در میکروکنترلرهای Bare-metal، وجود این توابع بهتنهایی به معنی در دسترس بودن فایلسیستم نیست. برای ذخیره اطلاعات روی کارت SD یا حافظههای دیگر، باید درایور سختافزاری و لایه فایلسیستم مناسب نیز راهاندازی شوند. برای نمونه، در یک پروژه مبتنی بر STM32 ممکن است از کتابخانه FatFs برای مدیریت فایلهای کارت حافظه استفاده کنیم و سپس دادههای موردنظر را در قالب فایل متنی یا باینری ذخیره کنیم.
rb و برای نوشتن در فایل باینری از wb استفاده کنید.NULL را بررسی کنید.fread و fwrite را بررسی کنید تا مطمئن شوید تمام اطلاعات موردنظر منتقل شدهاند.ferror استفاده کنید؛ مقدار بازگشتی صفر از fread بهتنهایی به معنی خطای خواندن نیست.fflush استفاده کنید.fclose ببندید و نتیجه آن را بررسی کنید.جمع بندی
در این قسمت از آموزش امبدد C با فایلهای باینری و نحوه کار با آنها آشنا شدیم. یاد گرفتیم که چگونه با استفاده از fread اطلاعات را از فایل بخوانیم و با fwrite دادهها را در فایل ذخیره کنیم. همچنین یک برنامه کاربردی برای کپیکردن فایل نوشتیم و دیدیم که چگونه میتوان با استفاده از یک بافر موقت، اطلاعات را بهصورت بخشبخش منتقل کرد؛ بدون اینکه لازم باشد کل فایل را وارد حافظه کنیم. در ادامه نیز مفهوم Buffering را بررسی کردیم و با تابع fflush آشنا شدیم؛ تابعی که امکان ارسال فوری اطلاعات بافرشده را فراهم میکند.
با این مباحث، فصل چهاردهم کتاب Bare Metal C به پایان میرسد. در قسمت بعدی وارد فصل پانزدهم میشویم و با آرگومانهای خط فرمان (Command Line Arguments) و سپس ورودی و خروجی سطح پایین (Raw I/O) آشنا خواهیم شد.
تمرین
printf چاپ کند و سپس با استفاده از fflush(stdout) بافر خروجی را تخلیه کند.منبع آموزشی: کتاب Bare Metal C: Embedded Programming for the Real World نوشته Stephen Oualline، فصل چهاردهم، بخشهای Binary I/O، Copying a File، Buffering and Flushing و Closing Files.
سیسوگ با افتخار فضایی برای اشتراک گذاری دانش شماست. برای ما مقاله بنویسید.