آموزش توربو سی بخش هفتم
تابع scanf( )
داده‌هاي ورودي مي‌توانند از طريق يك دستگاه ورودي استاندارد به كمك تابع كتابخانه‌اي scanf وارد كامپيوتر شوند. بطوري كه در گذشته نيز بيان شد، تابع scanf نيز تابع فرمت‌دار مي‌باشد و مشابه تابع printf ولي در جهت عكس عمل مي‌كند. به كمك اين تابع مي‌توان داده‌هاي عددي، كاراكتر، رشته‌ها و يا تركيبي از آنها را وارد كامپيوتر كرد. فرمت اين تابع مشابه فرمت تابع printf است. فرم كلي اين تابع بصورت زير است :
scanf ("control string", arguments list) ;
و يا :
scanf ("control string", argl , arg2 ,…, arg n) ;
نقش رشته كنترل مشابه همان است كه در مورد تابع printf بيان شد، لذا از توضيح بيشتر خودداري مي‌شود.
مشابه printf اين تابع نيز مي‌تواند هر تعداد آرگومان را دارا باشد، كه در آن اولين آرگومان رشته فرمت يا رشته كنترل است. همچنين اين تابع، اغلب همان كد فرمت تابع printf را بكار مي‌برد؛ براي مثال بطوري كه در مثالهاي قبلي نيز مشاهده شد، كدهاي فرمت :
%s, %c , %f , %d
به ترتيب براي خواندن داده‌هايي از نوع مقادير: صحيح، اعشاري (كسري)، كاراكتر و رشته بكار برده مي‌شود. تفاوت مهم بين اين دو تابع آن است كه در جلوي آرگومانها ، اپراتور آدرس يعني "&" نيز قرار مي‌گيرد. براي مثال دستور:
scanf("%d" , &num) ;
سيستم را هدايت مي‌كند كه داده ورودي را به‌صورت عدد صحيح از طريق ترمينال دريافت كند و اين مقدار را در متغير num ذخيره نمايد. البته اگر بخواهيد مقداري را براي متغير رشته‌اي بخوانيد، نيازي به اپراتور "&" نخواهد بود؛ زيرا به‌طوري كه بعد ملاحظه خواهيد كرد، رشته‌ها در زبان c بصورت آرايه‌اي از نوع كاراكتر معرفي مي‌گردد و نام آرايه نيز معرف آدرس آرايه (يعني آدرس اولين عنصر آن) مي‌باشد، مانند مثال زير:
#include<stdio.h>
main ( )
{
char name[6] ;
scanf("%s", name) ;
printf("%s", name) ;
}
و اگر در اين برنامه براي متغير name رشته "book" را وارد كرده باشيم، خروجي برنامه بالا كلمه book خواهد بود.
فرامين يا كدهاي فرمت ، براي داده‌هاي ورودي (كه مشخص‌كننده تبديل نيز ناميده مي‌شوند) در جدول زير نشان داده شده است.
كد يا كاراكترهاي فرمت در تابع scanf ( )
|
شـــرح
|
كد فرمت
|
|
داده ورودي بصورت تك‌كاراكتر تعبير مي‌شود.
|
%c
|
|
داده ورودي بصورت عدد صحيح علامت‌دار (در مبناي 10) تعبير مي‌شود.
|
%d
|
|
داده ورودي بصورت عدد صحيح علامت‌دار تعبير مي‌شود.
|
%i
|
|
داده ورودي بصورت عدد صحيح بدون علامت دهدهي تعبير مي‌شود.
|
%u
|
|
داده ورودي بصورت عدد صحيح اعشاري با مميز شناور (floating_point) تعبير مي‌شود.
|
%f , %e, %g
|
|
داده ورودي بصورت عدد صحيح كوتاه (short integer) تعبير مي‌شود.
|
%h
|
|
داده بصورت يك رشته تعبير مي‌گردد. ورودي به‌وسيلة يك كاراكتر non_white_space آغاز مي‌گردد و با اولين كاراكتر white_space خاتمه مي‌پذيرد (به پايان رشته بطور خودكار كاراكتر "\0" افزوده خواهد شد.)
|
%s
|
|
داده ورودي بصورت عدد صحيح در مبناي 8 تعبير مي‌گردد.
|
%o
|
|
داده ورودي بصورت عدد صحيح در مبناي 16 تعبير مي‌گردد.
|
%x , %X
|
|
داده ورودي بعنوان يك اشاره‌گر تعبير مي‌گردد.
|
%p
|
در استفاده از تابعscanf ، آرگومانها بعنوان متغيرها يا آرايه‌هايي كه نوع آن بايد با كد فرت مربوط تطابق داشته باشد، نوشته مي‌شود و همانطوري كه بيان شد، در جلوي آنها اپراتور آدرس يعني "&" نيز بكار برده مي‌شود (درواقع آرگومانها اشاره‌گرهايي هستند كه مشخص مي‌كنند اقلام داده‌ها در حافظه كامپيوتر، در كجا ذخيره مي‌شود). به هرحال به‌طوري كه بعد در مورد آرايه‌ها توضيح داده خواهد شد، در مورد استفاده از نام آرايه نبايد اپرتور "&" را جلوي آن قرار داد و اين موضوع را در مورد رشته‌اي كه آرايه‌اي از كاراكترها مي‌باشد، ضمن مثال ملاحظه نموديد. مثال زير اين موضوع را روشنتر مي‌سازد.
مثال - برنامه زير را درنظر بگيريد:
#include<stdio.h>
main ( )
{
int id ;
char name[5] ;
float grade ;
..........
..........
scanf("%d %s %f " , &id , name , &grade) ;
..........
..........
}
در تابع scanf استفاده شده در برنامه بالا، رشته كنترلي شامل 3 گروه است :
" %d , %s , %f "
اولين گروه "%d" دلالت بر اين دارد كه آرگومان متناظر با آن (يعني &id) معرف مقدار صحيح در مبناي دهدهي است.
دومين گروه "%s" دلالت بر اين دارد كه دومين آرگومان (يعني name) معرف يك رشته است. و بالاخره سومين گروه "%f" مشخص مي‌كند كه آرگومان سوم (يعني "&grade" )از نوع اعشار با مميز شناور است .
ملاحظه مي‌كنيد كه در جلوي متغيرهاي عددي id و grade اپراتور "&" آورده شده است، ولي در مورد متغير name به لحاظ اينكه نام آرايه مي‌باشد، اپراتور مزبور وجود ندارد.
اقلام واقعي داده‌ها عبارتند از مقادير عددي، كاراكتر تنها يا رشته‌ها و يا تركيبي از آنها كه از طريق دستگاه ورودي استاندارد (معمولاً يك صفحه كليد) وارد مي‌شوند. به هرحال اقلام داده‌ها بايد ازنظر نوع به‌ترتيب ورود، متناظر با آرگومانهاي مربوط باشند. داده‌هاي عددي به‌صورت مقادير ثابت عددي نوشته مي‌شوند كه اگر در مبناي 8 يا 16 باشند، نياز به اينكه با "0" (در مورد مبناي 8) و "0x" يا "x" (در مورد مبناي 16) آغاز گردند، نمي‌باشد.
مقادير اعشاري با مميز شناور ممكن است شامل علامت مميز يا علامت نما و يا هر دو باشد. اگر دو يا چندين اقلام داده وارد شوند، بايد به‌وسيله كاراكترهاي تفكيك‌كننده كه whitespace ناميده مي‌شوند، از يكديگر جدا شوند. كاراكترهاي فضاي خالي يا space يا blank ، tab و خط جديد يا newline متداول‌ترين كاراكترهاي whitespace مي‌باشند.
اقلام داده‌ها را مي‌توان روي دو يا چندين خط ادامه داد؛ زيرا بطوري كه بيان شد، خط جديد نيز كاراكتر whitespace درنظر گرفته مي‌شود.
براي مثال اگر داده‌هاي ورودي برنامه بالا به ترتيب 97.5 , sum , 12345 باشد، مي‌توان آنها را به صورتهاي زير وارد كامپيوتر نمود:
12345 sum 97.5
12345
يا
sum
97.5
يا
12345 sum
97.5
و يا
12345
sum 97.5
رشته‌هايي كه با كد فرمت "%s" بكار برده مي‌شوند، با يك كاراكتر whitespace خاتمه مي‌يابند. بنابراين اگر رشته‌اي شامل كاراكتر whitespace باشد، نمي‌تواند به طريق مذكور در مثال قبل وارد كامپيوتر گردد. به هرحال راههايي براي كار با اين‌گونه رشته‌ها و ورود آن به حافظه كامپيوتر وجود دارد. يك راه استفاده از تابع getchar داخل يك حلقه تكرار است مانند مثال زير:
مثال - برنامه زير يك خط متن حداكثر به طول 79 كاراكتر را مي‌خواند و آن را به همان صورت چاپ مي‌كند.
#include<stadio.h>
main ( ) /* read a line of text */
{
char line[80] ;
int count , k ;
/* read in the line */
for (k=0 ; line[k]=getchar ( )!=’\n’ ; + +k ) ;
count = k ;
for (k=0 ; k<count ; + +k)
putchar( line[k] ) ;
}
در حلقه for ، شمارنده k از صفر شروع مي‌شود و مقدار آن در هر تكرار يك واحد افزايش مي‌يابد و در هر تكرار يك كاراكتر به‌وسيلة تابع getchar از طريق ورودي استاندارد دريافت مي‌شود و به line[k] نسبت داده مي‌شود و وقتي كه كاراكتر خط جديد (يعني \n) وارد شد، عمل ورود كاراكترهاي رشته خاتمه مي‌يابد كه در اين لحظه مقدار k برابر تعداد كاراكترهاي واقعي رشته خواهد بود. سپس در حلقه بعدي محتواي آرايه line[] كه دربردارنده رشته دريافت شده است، چاپ مي‌گردد. (دو تابع getchar و putchar دوباره بررسي خواهد شد). راه ديگر براي ورود رشته‌ها به حافظه كامپيوتر، استفاده از تابع gets است كه در مبحث رشته‌ها مورد بحث قرار خواهد گرفت.
براي خواندن رشته‌هايي كه در آنها فضاي خالي (space يا blank) وجود داشته باشد، مي‌توان به طريقي از تابع scanf نيز استفاده نمود. براي اين كار مي‌توان به جاي كاراكتر تبديل نوع s در رشته كنترلي، دنباله‌اي از كاراكترها را در داخل كروشه بصورت [...] قرار داد كه در اين صورت رشته مورد نظر مي‌تواند شامل هريك از كاراكترهاي موجود در داخل كروشه ازجمله blank باشد.
با چنين روشي وقتي كه برنامه اجرا مي‌گردد، تا زماني كه كاراكترهاي متوالي خوانده شده از طريق دستگاه ورودي، با يكي از كاراكترهاي موجود در درون كروشه‌ها يكسان باشد، عمل خواندن رشته‌ها ادامه مي‌يابد (فضاي خالي نيز مي‌تواند در داخل رشته‌ها منظور گردد.) به محض اينكه كاراكتري خوانده شود كه در داخل كروشه‌ها وجود نداشته باشد، عمل خواندن خاتمه مي‌پذيرد. درضمن يك كاراكتر null بطور اتوماتيك به پايان رشته افزوده خواهد شد.
مثال - برنامه زير كاربرد تابع scanf را براي خواندن رشته‌هايي كه شامل حروف بزرگ و فضاي خالي است، نشان مي‌دهد. طول اين رشته نامشخص خواهد بود. اما حداكثر برابر 79 كاراكتر (يعني با درنظر گرفتن كاراكتر پايان رشته، 80 كاراكتر) خواهد بود.
#include<stdio.h>
main ( )
{
char line[80] ;
..........
scanf("%[ ABCDEFGHIJKLMNOPQRSTUVWXYZ ]", line) ;
..........
}
حال اگر از طريق ورودي ، رشته COMPUTER SCIENCE وارد شود، وقتي كه برنامه اجرا مي‌گردد، تمامي رشته مزبور به آرايه line نسبت داده مي‌شود. به هرحال اگر يكي از حروف رشته مزبور به حرف كوچك تايپ شود، ورود رشته در همان كاراكتر خاتمه مي‌پذيرد. مثلاً اگر در مثال بالا p به‌صورت كوچك تايپ شود، فقط سه حرف com به آرايه line نسبت داده مي‌شود و عمل خواندن در حرف چهارم (حرف p) خاتمه خواهد يافت.
راه ديگر آن است كه به جاي اينكه كاراكترهاي مجاز در رشته مورد نظر را در داخل كروشه ذكر كنيم (كه اين روش در اغلب موارد مانند مثال بالا طولاني خواهد بود)، فقط كاراكترهايي را كه مجاز نيستيم در رشته‌ها بكار ببريم، مشخص نماييم. براي اين كار كافي است كاراكترهاي مورد نظر را به دنبال نماد "^" كه circumflex ناميده مي‌شود، در داخل كروشه قرار دهيم. يعني در اينجا نقش كاراكترهاي كروشه‌اي عكس حالت قبلي است و وجود هركدام از آنها در داخل يك رشته، موجب قطع ورود بقيه كاراكترهاي رشته مي‌گردد و عمل خواندن رشته خاتمه مي‌پذيرد.
اگر كاراكتر داخل كروشه‌ها كه بعد از "^" مي‌آيد، فقط كاراكتر خط جديد "\n" باشد، رشته‌اي كه از طريق دستگاه ورودي استاندارد وارد مي‌شود، مي‌تواند شامل هر كاراكتر آسكي به جز كاراكتر خط جديد باشد؛ بنابراين، كاربر مي‌تواند هرچه خواست به‌عنوان كاراكترهاي رشته وارد كند و در پايان كليد Enterرا فشار دهد. اين كليد كاراكتر خط جديد را صادر مي‌كند و درنتيجه پايان رشته را اعلام خواهد كرد.
مثال- فرض كنيد كه يك برنامه C شامل دستورهاي زير است :
#include<stdio.h>
main ( )
{
char line[80] ;
..........
..........
scanf("%[^\n]", line) ;
..........
..........
}
وقتي كه تابع scanf در برنامه بالا اجرا مي‌گردد، رشته‌اي به طول نامشخص (ولي حداكثر 79 كاراكتر) از طريق دستگاه ورودي استاندارد وارد مي‌گردد و به line نسبت داده مي‌شود. هيچ گونه محدوديتي در مورد كاراكترهاي تشكيل‌دهنده رشته وجود نخواهد داشت، فقط بايد در يك خط بگنجد. براي مثال رشته زير مي‌تواند از طريق صفحه كليد وارد گردد و به line نسبت داده شود.
WE LEARN MATHEMATICS .
تابع getchar( )
براي خواندن يك كاراكتر از طريق دستگاه ورودي، مي‌توان علاوه بر تابع scanf از تابع getchar استفاده نمود. تابع مزبور كه جزء كتابخانه I/O زبان استاندارد C است ، يك كاراكتر از دستگاه ورودي استاندارد (معمولاً صفحه كليد) مي‌خواند. اين تابع داراي آرگومان نيست و بطور متعارف در يك دستور انتساب يا جايگذاري بكار برده مي‌شود و كاراكتر دريافتي از ورودي را به متغيري كه در سمت چپ دستور جايگذاري مورد نظر است، برمي‌گرداند (اختصاص مي‌دهد) و فرم كلي آن بصورت زير است :
character variable = getchar( ) ;
= getchar( ) ; متغير كاراكتري
كه در آن متغير كاراكتري نام متغيري از نوع كاراكتر است كه بايد از قبل توصيف شده باشد .
مثال - دستورهاي زير را در يك برنامه، درنظر بگيريد :
char ch ;
ch = getchar( ) ;
در عبارت اول، متغير ch از نوع كاراكتر توصيف گرديده است. وقتي كه اجراي برنامه به دستور دوم برسد ، برنامه منتظر فشار دادن كليدي از صفحه كليد مي‌شود . حال كاراكتر كليد فشار داده شده، به متغير ch اختصاص داده مي‌شود. چنانچه متغير ch از نوع int معرفي گردد، آسكي كد كاراكتر مربوط به كليد فشار داده شده، به آن متغير اختصاص مي‌يابد .
اگر هنگام خواندن كاراكتر توسط تابع getchar ، شرايط پايان فايل پيش آيد مقدار سمبوليكي EOF بطور خودكار برگشت داده خواهد شد (اين مقدار در داخل فايل stdio.h اختصاص داده خواهد شد. بطور متعارف مقدار 1- به EOF اختصاص داده مي‌شود، اگرچه ممكن است اين مقدار از كامپايلري به كامپايلر ديگر فرق كند.) ظاهر شدن EOF به اين طريق ، راه ساده‌اي براي تشخيص پايان فايل در هنگام اجراي آن است . (اين مورد ، در مبحث فايلها بيشتر مورد بحث قرار خواهد گرفت، لذا به هيچ وجه نگران آن نباشيد). مي‌توان تابع getchar را نيز براي خواندن رشته چند كاراكتري بصورت حلقه تكرار بكار برد كه در هر تكرار يا كاراكتر را بخواند .
تابع putchar( )
تابع putchar را مي‌توان براي شمارش يك كاراكتر روي خروجي استاندارد كه معمولاً صفحه نمايش است بكار برد. درواقع نقش آن مشابه تابع getchar در جهت عكس مي‌باشد. طبيعي است كاراكتري كه انتقال مي‌يابد بصورت ثابت كاراكتري و يا بصورت يك متغير از نوع كاراكتر به‌عنوان آرگومان تابع مزبور بكار برده مي‌شود. فرم كلي اين تابع بصورت زير مي‌باشد:
putchar (character variable) ;
; (متغير كاراكتري) putchar
البته مي‌توان ثابت كاراكتري را نيز بعنوان آرگومان تابع مزبور بكار برد.
مثال - برنامه زير بتدريج در هر بار که يك كاراكتر مي‌خواند، آن را روي خروجي چاپ مي‌كند :
#include<stdio.h>
main ( )
{
char c ;
while (1)
{
c = getchar(c) ;
putchar(c) ;
}
}
در مثال بالا، C كاراكتر توصيف شده است. هر بار كه يك كاراكتر از طريق دستگاه ورودي استاندارد به C خوانده مي‌شود، به همان طريق به خروجي انتقال مي‌يابد. اما به لحاظ اينكه عبارت مربوط به while، يعني مقدار داخل پرانتز بعد از while برابر "1" مي‌باشد، و هميشه غيرصفر است، براساس قوانين زبان c، اين عبارت هميشه درست يا true مي‌باشد. بنابراين ساختار:
while (1)
{
----------
----------
}
يك حلقه نامتناهي است، لذا تنها راه متوقف ساختن برنامه به‌وسيلة يك وقفه يا interrupt مي‌باشد كه اين كار با control-c عملي خواهد شد.
راه ديگر براي نوشتن برنامه بالا بصورت زير است :
#include<stdio.h>
main ( )
{
int c ;
c = getchar( ) ;
while (c!=EOF)
{
putchar(c) ;
c = getchar( ) ;
}
}
همان برنامه مي‌تواند بصورت زير نوشته شود :
#include<stdio.h>
main ( )
{
int c ;
while ((c=getchar( )) != EOF)
putchar(c) ;
}
بطوري كه در گذشته نيز بيان شد EOF در برنامه بالا يك علامت سمبوليك پايان فايل است. آنچه كه در واقعيت به‌عنوان نشانه پايان فايل بكار برده مي‌شود، تابع سيستم است. براي اين كار اغلب عدد 1- بكار برده مي‌شود، ولي سيستمهاي مختلف مي‌تواند مقادير متفاوتي داشته باشد. با گنجانيدن فايل stdio.h و بكار بردن ثابت سمبوليكي EOF ، برنامه را قابل حمل يا قابل اجرا ساخته‌ايم. يعني فايل مبنا مي‌تواند روي سيستمهاي مختلف بدون تغييرات اجرا شود .
ملاحظه مي‌كنيد كه در دو روش اخير، متغير C به جاي char به‌صورت int معرفي گرديده است. هرچه كه براي نشان دادن پايان فايل بكار برده شده باشد، نمي‌تواند مقداري باشد كه يك كاراكتر را معرفي نمايد. حال چون C به‌صورت int معرفي شده است، مي‌تواند مقادير تمام كاراكترهاي ممكن و همينطور مقدار ويژه EOF را نگهداري نمايد.
همانطوري كه بيان شد، هر دو تابع getchar و putchar در فايل stdio.h تعريف شده‌اند و ممكن است در بعضي سيستمها در فايلهاي ديگري نيز مانند فايل conio.h تعريف شده باشند .
حال بعنوان نمونه و براي آشنايي كافي با نحوه استفاده از اين دو تابع، به چند مثال بعدي توجه نماييد.
مثال - برنامه زير يك خط متن را از ورودي با حروف كوچك دريافت داشته، آن را به حروف بزرگ تبديل مي‌كند.
#include<stdio.h>
main ( )
{
char line[80] ;
int count , k ;
/* read in the line */
for (k=0 ; (line[k]=getchar( ))!=’\n’ ; + + k) ;
count = k ;
/* write out the line in upper-case */
for( k=0 ; k<count ; + +k )
putchar( toupper(line[k]) ) ;
}
در برنامه بالا از تابع توكار toupper استفاده شده است. نقش اين تابع آن است كه حروف كوچك را به بزرگ تبديل مي‌كند. بنابراين اگر حروف ورودي بطور اوليه (هنگام تايپ) حروف بزرگ، ارقام و مشابه آن باشند، به فرم اوليه خود نمايش داده خواهند شد. براي مثال اگر ورودي بصورت :
my book is on the table .
باشد، خروجي بصورت زير خواهد بود.
MY BOOK IS ON THE TABLE .
مثال - برنامه زير يك خط از متن را مي‌خواند و در آن هر كاراكتر را (به غير از كاراكتر فضاي خالي يا space) به كاراكتر بعدي تبديل مي‌كند و نمايش مي‌دهد. ( درواقع متن را به شکلی بصورت رمز در مي‌آورد و نمايش مي‌دهد .)
#include<stdio.h>
#define space ’ ’
main ( )
{
char ch ;
ch = getchar ( ) ; /* read a character */
while(ch!=’\n’) /*while not end of line */
{
if (ch= =space) /* leave the space */
putchar(ch) ; /* character unchanged */
else
putchar(ch+1) ; /* change other characters */
ch = getchar( ) ; /* get next character */
}
}
بعنوان مثال اگر ورودي بصورت: computer science باشد، خروجي بصورت زير خواهد بود :
dpnqvufs tdjfodf
با تركيب دو عبارت خواندن و تست كردن پايان متن در يك عبارت، برنامه مزبور را مي‌توان بصورت ساده‌تر و فشرده‌تر زير نوشت :
#include<stdio.h>
#define space ’ ’
main ( )
{
char ch ;
while ((ch=getchar( )) != ’\n’ )
{
if (ch = = space ) /* leave the space */
putchar(ch) ; /* character unchanged */
else
putchar(ch+1) ; /* change other characters */
}
}
که در اين برنامه دستور :
while ((ch=getchar( )) != ’\n’ )
تركيب دو عمل در يك دستور را نشان مي‌دهد كه يك روش متداول در زبان c است. اين دو عمل آن است كه اول به كمك تابع getchar مقداري به ch نسبت داده مي‌شود و سپس مقدار ch با كاراكتر خط جديد مقايسه مي‌گردد. وجود پرانتز دور عبارت :
ch = getchar( )
آن را اپراند چپ اپراتور != مي‌سازد. اگر آن را حذف كنيم نتيجه مطلوب بدست نمي‌آيد زيرا اپراتور != نسبت به اپراتور = تقدم بالاتري دارد. بنابراين اگر دستور مزبور را بصورت :
while (ch = getchar( )!= ’\n’ )
بنويسيم، اول عبارت ’\n’ getchar( )!= ارزيابي مي‌گردد كه يك عبارت رابطه‌اي است (بنابراين كاراكتر خط جديد برنمي‌گرداند، بلكه يك مقدار برمي‌گرداند)، كه ارزش آن يك يا صفر (درست يا نادرست يعني true يا false ) خواهد بود. سپس اين مقدار به ch نسبت داده مي‌شود كه هدف مورد نظر ما را از دستور مزبور تأمين نمي‌كند.
مثال - برنامه زير برنامه ساده‌اي است كه كاراكترها را از طريق ورودي صفحه كليد دريافت مي‌كند و آنها را به صفحه نمايش مي‌فرستد. اين نوع عمل را منعكس كردن ورودي نامند. برنامه مورد نظر هنگام دريافت كاراكتر # از ورودي، خاتمه مي‌پذيرد.
#include<stdio.h>
main ( )
{
char ch ;
while ((ch=getchar( )) != ’#’ )
putchar(ch) ;
}
• توابع ديگر
علاوه بر تابع getchar( ) دو تابع getch( ) و getche( ) نيز براي خواندن يك كاراكتر از ورودي بكار مي‌رود .
تابع getche( )
اگر بخواهيم كاراكتري به كمك تابع scanf و يا تابع getchar خوانده شود، بايد پس از تحرير (فشردن كليد) كاراكتر مورد نظر، كليد Enter نيز تحرير شود؛ يعني درواقع دو تابع مزبور تا موقعي كه كليد برگشت (كه به آن carriage return يا به اختصار CR نيز گفته مي‌شود) فشرده نشود، ورودي را در بافر نگه مي‌دارد. پس از تحرير كليد برگشت يا CR، دادة تايپ شده در اختيار برنامه قرار مي‌گيرد. حسن اين روش آن است كه اگر ما كليدي را اشتباه وارد كرده باشيم، مي‌توانيم آن را با backspace تصحيح كنيم؛ يعني قبلي را پاك كنيم و دوباره كاراكتر صحيح مورد نظر را تحرير كنيم. عيب اين كار آن است كه اين عمل در محيط محاوره‌اي امروز وقت‌گير و دردسرزا است؛ لذا تابع getche به‌وجود آمد كه در آن ديگر نيازي به تحرير كليد برگشت يا CR نيست. اشكال اين تابع آن است كه اگر كاراكتر اشتباه تحرير شود، امكان تصحيح وجود ندارد. ايراد ديگر آن است كه كاراكتر تحرير شده ، روي صفحه تصوير، نمايش داده مي‌شود كه اين عمل را echoing نامند.
تابع getch( )
اين تابع مانند تابع getche است با اين تفاوت كه كاراكتر تحرير شده ديگر در صفحه تصوير، ظاهر نمي‌گردد. درواقع حرف e در آخر تابع getche به مفهوم echo (عكس‌العمل) است .
در مورد هريك از اين سه تابع وقتي كه كنترل اجراي برنامه به اين توابع مي‌رسد، برنامه منتظر فشردن كليدي (تحرير كاراكتري) در صفحه كليد مي‌شود. اگر متغير مورد نظر از نوع كاراكتري باشد (در برنامه با فرمت %c توصيف شده باشد) مقدار كاراكتري كليد فشرده شده به اين متغير، منتقل مي‌شود (نسبت داده مي‌شود) و درصورتي كه اين متغير از نوع عددي باشد (در برنامه با فرمت %d توصيف شده باشد)، اسكي‌كد كاراكتر مربوط به كليد فشرده شده، در اين متغير قرار مي‌گيرد.
توابع puts( ) , gets( )
دو تابع puts( ) , gets( ) اين امكان را فراهم مي‌سازند كه بتوانيد رشته‌هايي از كاراكترها را از طريق كنسول بخوانيد و بنويسيد (دستگاههاي ورودي و خروجي استاندارد را كنسول نامند كه در مورد ريزكامپيوترها معمولاً صفحه كليد ورودي استاندارد و صفحه تصوير، خروجي استاندارد يا به‌عبارت ديگر كنسول را تشكيل مي‌دهند).
تابع gets( ) يك رشته از كاراكترها را كه از طريق صفحه كليد وارد مي‌شود، مي‌خواند و آنها را در آدرسي قرار مي‌دهد كه با آرگومانهاي آن تعيين شده است كه يك اشاره‌گر كاراكتر است. شما كاراكترهاي رشته مورد نظر را تايپ مي‌كنيد و در پايان، كليد برگشت يا CR را تحرير مي‌كنيد. با اين عمل به‌طور خودكار كاراكتر null يا ’\0’ نيز در پايان رشته قرار داده مي‌شود. در اينجا اگر كاراكترهايي اشتباه تايپ شود، مي‌توان آن را قبل از فشردن كليد Enter با استفاده از كليد backspace تصحيح كرد. درواقع در اينجا نيز كاراكترهاي تايپ شده در بافر مي‌ماند و تا موقعي كه كليد برگشت فشرده نشده است، در اختيار برنامه قرار نمي‌گيرد .
تابع puts( ) آرگومانهاي رشته‌اي خود را به صفحه نمايش مي‌فرستند و سپس قلم نوشتار به خط جديد انتقال مي‌يابد .
مثال - برنامه زير رشته‌اي را (حداكثر به طول 79 كاراكتر) از طريق صفحه كليد مي‌خواند و در آرايه str قرار مي‌دهد سپس آن را روي صفحه تصوير، نمايش مي‌دهد :
#include<stdio.h>
main( )
{
char str[80] ;
gets(str) ;
puts(str) ;
}
فراخواني تابع puts در مقايسه با همان فراخواني printf داراي هزينه بالا سري (overhead) كمتري است و درنتيجه سريعتر از آن عمل مي‌كند؛ زيرا تابع puts فقط مي‌تواند يك رشته از كاراكتر را به خروجي بفرستد و نمي‌تواند مشابه printf تبديل فرمت انجام دهد. همچنين نمي‌تواند مقادير عددي را به‌عنوان خروجي داشته باشد؛ بنابراين چون puts فضاي كمتري مي‌گيرد و سريعتر از printf اجرا مي‌گردد، هنگامي كه در برنامه‌سازي حالت خيلي بهينه مورد نظر باشد، از اين تابع استفاده مي‌شود. كاربرد اساسي اين تابع در مبحث رشته‌ها دوباره به‌طور مفصل مورد بحث قرار خواهد گرفت .
جدول زير خلاصه توابع ورودی خروجی مربوط به كنسول را نشان مي‌دهد.
توابع i /o مربوط به كنسول
|
عمــل ( Operation )
|
توابــع
|
|
يك كاراكتر از صفحه كليد مي‌خواند و منتظر CR مي‌ماند.
|
getchar( )
|
|
يك كاراكتر از صفحه كليد مي‌خواند، ولي منتظر CR نمي‌ماند.
|
getche( )
|
|
يك كاراكتر بدون انعكاس روي مونيتور، از صفحه كليد مي‌خواند و منتظر CR نمي‌ماند.
|
getch( )
|
|
يك كاراكتر روي صفحه مونيتور مي‌نويسد.
|
putchar( )
|
|
يك رشته را از صفحه كليد مي‌خواند.
|
gets( )
|
|
يك رشته را روي صفحه تصوير مي‌نويسيد.
|
puts( )
|
|
داده‌هاي ورودي (تركيبي از مقادير عددي، كاراكتر و رشته) را از ورودي استاندارد (صفحه كليد) به كامپيوتر وارد مي‌كند.
|
scanf( )
|
|
داده‌هاي خروجي (تركيبي از مقادير عددي، كاراكتر و رشته) را از كامپيوتر روي دستگاه خروجي استاندارد (صفحه مونيتور) مي‌نويسد.
|
printf( )
|