Scanf s c აღწერა. ფორმატირებული შეყვანა და გამომავალი. რეგულარული სიმბოლოების გამოყენება

] SCANF # მოიცავს int scanf(ფორმატი-სტრიქონი[[, არგუმენტი...]]); char *ფორმატი-სტრიქონი. ფორმატის კონტროლის სტრიქონი. აღწერა. არ ემთხვევა საკონტროლო სიმბოლოებს, scanf წყვეტს მუშაობას. ფორმატის სპეციფიკაცია, შეყვანილი % ნიშნით. ამ შემთხვევაში, scanf კითხულობს და გარდაქმნის შეყვანილ სიმბოლოებს მოცემული ტიპის მნიშვნელობებად, არგუმენტების სიიდან შესაბამისი არგუმენტებით განსაზღვრული მნიშვნელობებით. ფორმატის სტრიქონი იკითხება მარცხნიდან მარჯვნივ. სიმბოლოები ფორმატის სპეციფიკაციის მიღმა ვარაუდობენ, რომ ემთხვევა stdin-ის სიმბოლოების თანმიმდევრობას; ეს შესატყვისი სიმბოლოები stdin-ში დასკანირებულია, მაგრამ არ ახსოვს. თუ სიმბოლო stdin-ში ეწინააღმდეგება ფორმატის სტრიქონს, scanf მთავრდება. ეს კონფლიქტური სიმბოლო რჩება stdin-ში, რადგან მისი წაკითხვა შეუძლებელია. როდესაც პირველი ფორმატის სპეციფიკაცია გვხვდება, მაშინ პირველი შეყვანის ველის მნიშვნელობა გარდაიქმნება ფორმატის სპეციფიკაციის მიხედვით და ინახება პირველი არგუმენტით მითითებულ ადგილას. მეორე ფორმატის სპეციფიკაციის მიხედვით, მეორე შეყვანის ველი გარდაიქმნება და ინახება მეორე არგუმენტით; და ასე შემდეგ ფორმატის ხაზის ბოლომდე. შეყვანის ველი შემოიფარგლება პირველი „თეთრი სივრცის“ სიმბოლოთი, ან პირველი სიმბოლოთი, რომელიც არ შეიძლება გადაკეთდეს მითითებულ ფორმატში, ან როდესაც მიიღწევა სიგანის ველი, რომელიც პირველ რიგში მოდის. თუ არჩეული ფორმატის სპეციფიკაცია შეიცავს საჭიროზე მეტი არგუმენტი, დამატებითი არგუმენტები იგნორირებულია. ფორმატის სპეციფიკაციას აქვს შემდეგი ფორმა. % <.precision><{F:N:h:I}> . სპეციფიკაციის ფორმატის თითოეული ველი არის ცალკე სიმბოლო ან რიცხვი, რომელიც გამოხატავს სხვადასხვა ფორმატის ვარიანტს. ტიპი სიმბოლო, რომელიც გამოჩნდება ბოლო არასავალდებულო ფორმატის ველის შემდეგ, განსაზღვრავს შეყვანის ველის ტიპს, როგორც სიმბოლოს, სტრიქონს ან ციფრულს. სპეციფიკაციის უმარტივესი ფორმატი შეიცავს მხოლოდ პროცენტული ნიშნის სიმბოლოს და ტიპის სიმბოლოს (მაგალითად, %S). თითოეული ფორმატის სპეციფიკაციის ველი აღწერილია ქვემოთ. თუ პროცენტის ნიშანს % მოჰყვება სიმბოლო, რომელიც არ არის ფორმატის საკონტროლო სიმბოლო, მაშინ ეს სიმბოლო და მის შემდეგ სიმბოლოები, შემდეგ % ნიშანმდე, განიხილება, როგორც სიმბოლოების რეგულარული თანმიმდევრობა, ე.ი. შესაყვანი თანმიმდევრობა. მაგალითად, % ნიშნის სიმბოლოს შესაყვანად გამოიყენეთ %%. ვარსკვლავი (*) % ნიშნის შემდეგ ახშობს შემდეგი შეყვანის ველის აღნიშვნას, რომელიც მითითებულია, როგორც ტიპის მიხედვით განსაზღვრული ველი. ეს ველი დასკანირებულია, მაგრამ არ მახსოვს. Widht არის დადებითი ათობითი მთელი რიცხვი და აკონტროლებს stdin-დან წაკითხული სიმბოლოების მაქსიმალურ რაოდენობას. მხოლოდ ის სიმბოლოები, რომლებიც არ აღემატება სიგანეს, გარდაიქმნება და ინახება შესაბამისი არგუმენტით. თუ სიგანე შეიცავს "თეთრი სივრცის" სიმბოლოებს, ე.ი. სივრცეები, ჩანართები ან ახალი ხაზები, ისინი არ გარდაიქმნება არჩეულ ფორმატში, სანამ სიგანე არ მიიღწევა. არჩევითი F და N პრეფიქსები არ იცავენ გამოყენებული მეხსიერების მოდელების ნაგულისხმევ მიმართვის კონვენციას. F შეიძლება იყოს არგუმენტის პრეფიქსი, რომელიც მიუთითებს შორეულ ობიექტზე; და N - უახლოეს ობიექტთან. სურვილისამებრ l პრეფიქსი მიუთითებს, რომ გამოიყენება გრძელი ვერსია; ხოლო h პრეფიქსი მიუთითებს მოკლე ვერსიის გამოყენებაზე. შესაბამისი არგუმენტი მიუთითებს გრძელ ან ორმაგ ობიექტზე (l პრეფიქსის გამოყენებით) ან მოკლე ობიექტზე (h პრეფიქსის გამოყენებით). l და h მოდიფიკატორები შეიძლება გამოყენებულ იქნას სიმბოლოების ტიპებთან ერთად d, i, o, x, u. l მოდიფიკატორი ასევე შეიძლება გამოყენებულ იქნას e და f ტიპის სიმბოლოებით. თუ რომელიმე სხვა ტიპი მითითებულია, l და h მოდიფიკატორები იგნორირებულია. ტიპის სიმბოლოები და მათი მნიშვნელობა აღწერილია ცხრილში R.4. ცხრილი R.4 სკანფის სიმბოლოების ტიპები SYMBOL INTENDED TYPE შეყვანის არგუმენტის ტიპი d ათობითი მთელი რიცხვი int. D ათწილადი მთელი რიცხვის მაჩვენებელი გრძელზე. o რვა რიცხვი int. O რვიანი მთელი რიცხვის მაჩვენებელი გრძელზე. x თექვსმეტობითი მაჩვენებელი int. მთელი რიცხვი X თექვსმეტობითი მაჩვენებელი გრძელზე. მთელი რიცხვი მე ათობითი, oc არის მაჩვენებელი int-ზე. მერიკული ან თექვსმეტობითი მთელი რიცხვი I ათწილადი, რვადი მაჩვენებელი გრძელზე. მეტრიკული ან თექვსმეტობითი მთელი რიცხვი u unsigned ათობითი მაჩვენებელი unsigned ათობითი მთელი რიცხვი int. U ხელმოუწერელი ათწილადის მაჩვენებელი გრძელ სიგრძის ხელმოუწერელ მთელ რიცხვზე. e float pointer f float-ზე, რომელიც შეიცავს არასავალდებულო ნიშანს ("+", "-"), ერთი ან მეტი ათობითი ციფრი, რომელიც ჩვეულებრივ შეიცავს ათწილადს და მაჩვენებელს ("e", "E"), რომელიც იწერება შემდეგ ხელმოწერილი მთელი მნიშვნელობა. c სიმბოლურია. სიმბოლოების მითითება: ინტერვალი, ჩანართი ან ახალი ხაზი, ეგრეთ წოდებული „სივრცის“ სიმბოლოები, რომლებიც ჩვეულებრივ იგნორირებულია, იკითხება ამ ტიპის მითითებისას. შემდეგი არა-სივრცის სიმბოლოს წასაკითხად გამოიყენეთ კომბინაცია %1s. s სტრიქონი. სიმბოლოთა მასივის მაჩვენებელი საკმარისად დიდი შეყვანის ველისთვის, ნულოვანი დამთავრებული სიმბოლო "\0" ავტომატურად გამოჩნდება. n წაკითხვა არ ხდება ინდიკატორის int-ზე შეყვანისას, სტრიმიდან ან რომელზედაც არის ჩაწერილი ბუფერი, რიცხვი წარმატებით იკითხება. მონაცემთა სიმბოლოები ნაკადიდან ან ბუფერიდან, სკანფის ზარში მითითებულამდე. p მნიშვნელობა ფორმის მაჩვენებელი far- xxxx: yyyy, სად არის მონაცემთა ჯგუფი. ციფრები x და y არის დიდი თექვსმეტობითი რიცხვები. სტრიქონების წაკითხვისას, რომლებიც არ არის შემოსაზღვრული სივრცით, კვადრატულ ფრჩხილებში სიმბოლოების ნაკრები უნდა შეიცვალოს სტრიქონის ტიპის s. შესაბამისი შეყვანის ველი იკითხება პირველ სიმბოლომდე, რომელიც არ არის კვადრატული ფრჩხილებით შეზღუდული სიმბოლოების სიმრავლეში. თუ ამ ნაკრების პირველი სიმბოლოა caret (^), შედეგი ინახება: შეყვანის ველი იკითხება პირველ სიმბოლომდე, რომელიც არ შედის სიმბოლოების ამ ნაკრებში. სტრიქონის დასამახსოვრებლად ნულოვანი სიმბოლოს "\0" გარეშე, გამოიყენება %nc სპეციფიკაცია, სადაც n არის ათობითი მთელი რიცხვი. ამ შემთხვევაში, სიმბოლოს ტიპი s განსაზღვრავს არგუმენტს, რომელიც მიუთითებს სიმბოლოების მასივზე. შემდეგი n სიმბოლო იკითხება შეყვანის ნაკადიდან კონკრეტულ ადგილას და ნულოვანი სიმბოლო არ იწერება. Scanf ფუნქცია სკანირებს თითოეულ შეყვანის ველს სიმბოლოების მიხედვით. მას შეუძლია შეწყვიტოს ერთი ველის კითხვა, როდესაც ის მიაღწევს ინტერვალის სიმბოლოს, თუ რომელიმე სიგანის ველს მიაღწევს; ან შემდეგი შეყვანის სიმბოლო ვერ გადაიქცევა მითითებული ფორმატის მიხედვით; ან შემდეგი სიმბოლო ეწინააღმდეგება შესაბამის სიმბოლოს ფორმატის მართვის სტრიქონში; ან შემდეგი სიმბოლო არ არის სიმბოლოების შერჩეულ ნაკრებში. როდესაც ხდება წაკითხვის დასრულების იძულებითი პროცესი, შემდეგი შეყვანის ველი განიხილება პირველივე კონფლიქტური სიმბოლოდან. ეს სიმბოლო, თუ არის ერთი, განიხილება როგორც წაუკითხავი, როგორც შემდეგი შეყვანის ველის პირველი სიმბოლო, ან როგორც პირველი სიმბოლო შემდგომი წაკითხვისას stdin-დან. დაბრუნების ღირებულება. ეს ფუნქცია აბრუნებს წარმატებით გარდაქმნილი და მინიჭებული ველების რაოდენობას. დაბრუნებული მნიშვნელობა არ შეიცავს წაკითხული, მაგრამ არ მინიჭებული ველების რაოდენობას. ფაილის ბოლოს წაკითხვის მცდელობა აბრუნებს EOF-ს. დაბრუნებული მნიშვნელობა 0 მიუთითებს, რომ არ არის მინიჭებული ველები. აგრეთვე იხილეთ fscanf, printf, sscanf, vfprintf, vprintf, vsprintf. მაგალითი 1. #include int i; float fp; char c, s; scanf("%d %f %c %s", &i, &fp, და c, s); /* სხვადასხვა მონაცემების შეყვანა */. მაგალითი 2. #include main () /* გადაიყვანეთ თექვსმეტობითი ** ან რვიანი რიცხვი ** ათობითი რიცხვად */ ( int numassigned, val; pintf ("შეიყვანეთ თექვსმეტობითი ან რვადი #, ან 00 guit-ში:\n"); do ( printf("# = "); numassigned = scanf ("%i", &val); printf ("ათწილადი # = %i\n", nal); ) while (val && numassigned); /* ციკლის დასასრული, თუ შეყვანის მნიშვნელობა არის 00, ან თუ scanf-ს არ შეუძლია ველის მინიჭება */ ) მაშინ გამომავალი იქნება შემდეგი. შეიყვანეთ თექვსმეტობითი ან რვიანი #, ან 00, რომლითაც: # = 0xf ათწილადი # = 15 # = 0100 ათწილადი # = 64 # = 00 ათწილადი # = 0.

printf() ფუნქცია საშუალებას გაძლევთ აჩვენოთ ინფორმაცია ეკრანზე კონსოლის რეჟიმში პროგრამირებისას. ეს ფუნქცია განსაზღვრულია stdio.h ბიბლიოთეკაში და აქვს შემდეგი სინტაქსი:

int printf(const char *format [, არგუმენტი]...);

აქ პირველი *format არგუმენტი განსაზღვრავს სტრიქონს, რომელიც იბეჭდება ეკრანზე და შეიძლება შეიცავდეს სპეციალურ საკონტროლო სიმბოლოებს ცვლადების გამოსატანად. ამას მოჰყვება არასავალდებულო არგუმენტების სია, რომლებიც ახსნილია ქვემოთ. ფუნქცია აბრუნებს ან ნაჩვენები სიმბოლოების რაოდენობას, ან უარყოფით რიცხვს, თუ ის სწორად არ მუშაობს.

მისი მარტივი განხორციელებისას, printf() ფუნქცია უბრალოდ ბეჭდავს მოცემულ სტრიქონს მონიტორის ეკრანზე:

printf ("გამარჯობა სამყარო");

თუმცა, ის შეიძლება გამოყენებულ იქნას სხვადასხვა ტიპის ცვლადების საჩვენებლად: რიცხვითიდან სტრიქონამდე. ამ ოპერაციის შესასრულებლად გამოიყენება სპეციალური საკონტროლო სიმბოლოები, სახელწოდებით specifiers, რომლებიც იწყება % სიმბოლოთი. შემდეგი მაგალითი გვიჩვენებს მთელი რიცხვის ცვლადის num გამომავალს მონიტორის ეკრანზე printf() ფუნქციის გამოყენებით:

int num;
რაოდენობა = 5;
printf(“%d”, num);

ამ პროგრამის პირველი ორი ხაზი ადგენს ცვლადს, რომელსაც ეწოდება num ტიპის int. მესამე ხაზი ბეჭდავს ცვლადს ეკრანზე. printf() ფუნქცია მუშაობს შემდეგნაირად. პირველი, ფუნქცია აანალიზებს სტრიქონს, რომელიც უნდა იყოს ნაჩვენები. ამ შემთხვევაში არის "%d". თუ ამ სტრიქონში მოიძებნება სპეციფიკატორი, მაშინ მის ადგილას იწერება ცვლადის მნიშვნელობა, რომელიც არის printf() ფუნქციის მეორე არგუმენტი. შედეგად, ორიგინალური სტრიქონის ნაცვლად „%d“, ეკრანზე გამოჩნდება სტრიქონი „5“, ე.ი. გამოჩნდება ნომერი 5.

უნდა აღინიშნოს, რომ "%d" სპეციფიკატორი გამოსცემს მხოლოდ მთელი რიცხვის ცვლადის ტიპებს, როგორიცაა int. სხვა ტიპების დასკვნით, თქვენ უნდა გამოიყენოთ სხვადასხვა სპეციფიკატორები. სპეციფიკატორების ძირითადი ტიპები ჩამოთვლილია ქვემოთ:

%с – ერთი სიმბოლო
%d – ხელმოწერილი ათობითი მთელი რიცხვი
%f – მცურავი წერტილის ნომერი (ათწილადი აღნიშვნა)
%s – სიმბოლოების სტრიქონი (სტრიქონი ცვლადებისთვის)
%u – ათობითი მთელი რიცხვი
%% - დაბეჭდეთ პროცენტის ნიშანი

printf() ფუნქციის გამოყენებით შეგიძლიათ დაბეჭდოთ რამდენიმე ცვლადი ერთდროულად. ამისათვის გამოიყენება შემდეგი კონსტრუქცია:

int num_i;
float num_f;
num_i = 5;
num_f = 10,5;
printf("num_i = %d, num_f = %f", num_i, num_f);

პროგრამის გაშვების შედეგი ასე გამოიყურება:

num_i = 5, num_f = 10.5

გარდა სპეციფიკატორებისა, printf() ფუნქცია იყენებს საკონტროლო სიმბოლოებს, როგორიცაა newline \n, tabs \t და ა.შ. მაგალითად, თუ ადრე განხილულ მაგალითში აუცილებელია ცვლადების მნიშვნელობების ჩვენება, რომლებიც არ არიან ხაზში. , მაგრამ სვეტში, მაშინ აუცილებელია printf() ფუნქციის გადაწერა შემდეგი გზით:

printf("num_i = %d,\n num_f = %f", num_i, num_f);

ჩანართის სიმბოლო გამოიყენება ანალოგიურად.

კლავიატურიდან ინფორმაციის შესატანად მოსახერხებელია stdio.h ბიბლიოთეკის scanf() ფუნქციის გამოყენება, რომელსაც აქვს შემდეგი სინტაქსი:

int scanf(const char *format [,არგუმენტი]...);

აქ, როგორც printf() ფუნქციის შემთხვევაში, *format ცვლადი განსაზღვრავს ფორმატის სტრიქონს შეყვანის მონაცემების ტიპის დასადგენად და შეიძლება შეიცავდეს იგივე სპეციფიკატორებს, როგორც printf() ფუნქციას. შემდეგ მოდის არჩევითი არგუმენტების სია. scanf() ფუნქციის მოქმედება ნაჩვენებია სიაში 1.4.

ჩამონათვალი 1.4. scanf() ფუნქციის გამოყენების მაგალითი.

#შეიცავს
int main()
{
int ასაკი;
მცურავი წონა
printf ("შეიყვანეთ თქვენი ასაკის ინფორმაცია: ");
scanf („%d“, & ასაკი);
printf ("შეიყვანეთ თქვენი წონის ინფორმაცია: ");
scanf(“%f”, &წონა);
printf(„შენი ასაკი = %d, შენი წონა = %f“, ასაკი, წონა);

დაბრუნება 0;
}

მთავარი განსხვავება scanf() ფუნქციისა და printf() ფუნქციის გამოყენებას შორის არის & ნიშანი ცვლადის სახელის წინ, რომელშიც ჩაწერილია შეყვანის შედეგები.

scanf() ფუნქციას შეუძლია ერთდროულად იმუშაოს რამდენიმე ცვლადთან. დავუშვათ, თქვენ უნდა შეიყვანოთ ორი მთელი რიცხვი კლავიატურიდან. ფორმალურად, შეგიძლიათ ორჯერ გამოიძახოთ scanf() ფუნქცია ამისათვის, მაგრამ უმჯობესია გამოიყენოთ ეს კონსტრუქცია:

scanf(“ %d, %d ”, &n, &m);

scanf() ფუნქცია ამას ისე განმარტავს, თითქოს მომხმარებლისგან ელოდება რიცხვის, შემდეგ მძიმის და შემდეგ მეორე რიცხვის შეყვანას. ყველაფერი ისე მუშაობს, თითქოს ორი მთელი რიცხვი უნდა შეიყვანოთ შემდეგნაირად:

scanf() ფუნქცია აბრუნებს წარმატებით წაკითხული ელემენტების რაოდენობას. თუ არ მოხდა წაკითხვის ოპერაცია, რაც ხდება, როდესაც ასო შეიყვანება მოსალოდნელი რიცხვითი მნიშვნელობის ნაცვლად, მაშინ დაბრუნებული მნიშვნელობა არის 0.

scanf() ფუნქცია არის მრავალფუნქციური ფუნქცია, რომელიც საშუალებას გაძლევთ შეიყვანოთ ნებისმიერი ტიპის მონაცემები თქვენს კომპიუტერში. ფუნქციის სახელწოდება ასახავს მის დანიშნულებას - ფუნქცია სკანირებს (ნახულობს) კლავიატურას, განსაზღვრავს რომელი ღილაკების დაჭერას და შემდეგ ინტერპრეტაციას ახდენს შეყვანის SCAN ფორმატირებული სიმბოლოების საფუძველზე. ისევე, როგორც printf() ფუნქციას, scanf()-ს შეუძლია მიიღოს მრავალი არგუმენტი, რაც საშუალებას მოგცემთ ერთდროულად შეიყვანოთ რიცხვითი, სიმბოლოების და სიმებიანი ცვლადების მნიშვნელობები.

ისევე როგორც printf() პარამეტრების სია, scanf() ფუნქციის პარამეტრების სია შედგება ორი ნაწილისგან: ფორმატის სტრიქონი და მონაცემთა სია (ნახ. 5.7). ფორმატის ხაზი შეიცავს ფორმატის ინდიკატორებს, აქ მათ უწოდებენ სიმბოლოების გადამყვანები*, რომელიც განსაზღვრავს, თუ როგორ უნდა იქნას ინტერპრეტირებული შეყვანის მონაცემები. მონაცემთა სია შეიცავს ცვლადებს, რომლებშიც უნდა შეიყვანოთ შეყვანილი მნიშვნელობები.

ბრინჯი. 5.7. scanf() ფუნქციის პარამეტრების სია დაყოფილია ორ ნაწილად

ფორმატის ინდიკატორები მსგავსია printf() ფუნქციით გამოყენებული:

რიცხვითი ან სიმბოლოების მონაცემების შეყვანისას, scanf() ფუნქციის მონაცემთა სიაში უნდა მიუთითოთ ცვლადის მისამართი და არა მხოლოდ მისი სახელი:

scanf("%f", &amount);

* INორიგინალურიკონვერტაციის სიმბოლოები.(დაახლოებით თარგმანი)

ამ მაგალითში, scanf() ფუნქცია იღებს მცურავი წერტილის რიცხვს და ათავსებს მას მეხსიერების ზონაში, რომელიც რეზერვირებულია ცვლადი ოდენობისთვის. როგორც კი რიცხვი განთავსდება ამ მეხსიერების ზონაში, ის ავტომატურად ხდება ცვლადის მნიშვნელობა.

სანამ scanf() ფუნქცია მუშაობს, პროგრამის შესრულება შეჩერებულია და პროგრამა ელოდება მონაცემთა შეყვანას. შეყვანა მთავრდება ღილაკის დაჭერით შედი.

scanf() ფუნქციის მონაცემებთან მუშაობის პრინციპი ძირეულად განსხვავდება gets() და getchar() ფუნქციების მუშაობისგან. იმისათვის, რომ გაიგოთ, რა ხდება ზუსტად scanf(-ის გამოყენებით აკრეფისას, თქვენ უნდა დაათვალიეროთ ეს განსხვავებები დეტალურად.

შეყვანის ნაკადი

როდესაც მონაცემები შეიყვანება gets() ფუნქციის გამოყენებით, ყველა სიმბოლო, რომელიც აკრეფილი იყო კლავიატურაზე დაჭერამდე შედი, გახდეს ცვლადის მნიშვნელობა. როდესაც სიმბოლო შეიყვანება getchar() ფუნქციის გამოყენებით, ღილაკის დაჭერით ავტომატურად ხდება შესაბამისი სიმბოლოს მინიჭება ცვლადზე.

scanf() ფუნქცია სხვაგვარად მუშაობს. იმის ნაცვლად, რომ უბრალოდ აიღოს მონაცემები და მიაკუთვნოს ისინი ცვლადს, scanf() ჯერ იყენებს ფორმატის მაჩვენებლებს, რათა დადგინდეს, თუ როგორ უნდა იქნას გამოყენებული შეყვანის სიმბოლოები.

ჩვეულებრივ ამბობენ, რომ scanf() იღებს მონაცემებს შეყვანის ნაკადი. შეყვანის ნაკადი არის სიმბოლოების თანმიმდევრობა, რომელიც მოდის გარკვეული წყაროდან. scanf() ფუნქციის შემთხვევაში წყარო არის კლავიატურა. გასაღების დაჭერის შემდეგ შედიამ დროისთვის შეყვანილი ყველა მონაცემი გადაეცემა scanf() ფუნქციას სიმბოლოების ჯერ კიდევ უაზრო ნაკრების სახით, იმავე თანმიმდევრობით, რომლითაც ისინი აკრეფილია. scanf() შემდეგ განსაზღვრავს რომელი სიმბოლოები ემთხვევა ფორმატის სპეციფიკატორის მიერ მითითებულ ტიპს და რომელი უნდა იყოს იგნორირებული. ფორმატის მაჩვენებლებს უწოდებენ სიმბოლოების გადამყვანებს, რადგან ისინი იღებენ დაუმუშავებელ სიმბოლოებს შეყვანის ნაკადიდან და გარდაქმნიან მათ კონკრეტული ტიპის მონაცემებად. სურათი 5.8 ასახავს ამ პროცესს.

scanf() ფუნქცია უგულებელყოფს არაინფორმაციულ სიმბოლოებს: ინტერვალებს, ჩანართებს და ახალ ხაზებს, გარდა იმ შემთხვევისა, როდესაც მონაცემთა მიმდინარე ტიპი არის char. მოდით გადავხედოთ პროგრამას:

puts("გთხოვთ შეიყვანოთ ნომერი:");

scanf("%d", &count);

printf("რიცხვი არის %d", count);

ბრინჯი. 5.8. scanf() ფუნქცია კითხულობს შეყვანის ნაკადს და ადგენს რა მონაცემები უნდა იყოს შეყვანილი და რა მონაცემების იგნორირება.

რიცხვის შეყვანამდე შეგიძლიათ დააჭიროთ ინტერფეისს რამდენიც გინდათ - C უგულებელყოფს სივრცეებს ​​და ელოდება პირველ მნიშვნელოვან სიმბოლოს. შემდეგ C შეეცდება გადაიყვანოს სიმბოლოები scanf() ფუნქციის ფორმატის სტრიქონში ფორმატის სპეციფიკატორების მიხედვით. თუ ეს სიმბოლოები ემთხვევა ფორმატს (ამ შემთხვევაში, თუ ისინი რიცხვებია), ისინი შეიყვანება ცვლადში. მონაცემთა შეყვანა შეჩერდება, თუ შეგხვდებათ სიმბოლო, რომელიც არ არის მოსალოდნელ ფორმატში, ანუ ის არ არის რიცხვი. მაგალითად, თუ კლავიატურაზე აკრიფებთ თანმიმდევრობას „123abc“, მაშინ ჩვენს მაგალითში რიცხვი 123 მიენიჭება count ცვლადს, ხოლო ასოები „abc“ იგნორირებული იქნება, როგორც ნაჩვენებია ნახ. 5.9-ზე. სივრცემ შეიძლება გამოიწვიოს მონაცემთა შეყვანის შეჩერება. მაგალითად, თუ აკრიფებთ „123“, ცვლადს მიენიჭება მნიშვნელობა 12 და რიცხვი 3 იგნორირებული იქნება.

ბრინჯი. 5.9. scanf() ფუნქცია წყვეტს მონაცემების შეყვანას, როდესაც შეხვდება პირველ არაციფრულ სიმბოლოს.

პირველი მნიშვნელოვანი სიმბოლო უნდა ემთხვეოდეს scanf() ფუნქციის არგუმენტში მითითებულ ფორმატს. ასე რომ, თუ თქვენ აკრიფებთ თანმიმდევრობას "ABC123", პროგრამა უგულებელყოფს მთელ თანმიმდევრობას და სიბნელეში დაგტოვებთ ცვლადის მნიშვნელობის შესახებ.

რომელი სიმბოლოები მიიჩნევს პროგრამას „შესაბამისად“, დამოკიდებულია ფორმატის ინდიკატორებზე. თუ მაჩვენებელი არის %d, მაშინ მხოლოდ რიცხვები და მინუს ნიშანია „შესაფერისი“. თუ დააყენებთ %x მაჩვენებელს, მაშინ სიმბოლოები 0123456789ABCDE შეესაბამება ფორმატს, რადგან ისინი ყველა გამოიყენება თექვსმეტობით რიცხვთა სისტემაში რიცხვების ჩაწერისას. თუ %c მაჩვენებელი არსებობს, ნებისმიერი სიმბოლო მიიღება, შეყვანის ნაკადში არსებული ადგილებიც კი არ არის იგნორირებული scanf() ფუნქციის მიერ ამ შემთხვევაში. თუ დაწერთ ინსტრუქციას:

scanf("%c", &ასო);

და დააჭირეთ spacebar-ს მნიშვნელოვანი სიმბოლოების თანმიმდევრობის დასაწყისში, scanf() დააყენებს ცვლადს სივრცეში, უგულებელყოფს შემდგომ სიმბოლოებს. ამიტომ, როდესაც საქმე ეხება char ტიპის, თქვენ არ შეგიძლიათ განათავსოთ სივრცეები სხვა სიმბოლოების წინ.

სტრიქონის შეყვანისას, scanf() ფუნქცია დაიწყებს მნიშვნელობის მინიჭებას პირველ მნიშვნელოვან სიმბოლოზე, უგულებელყოფს წამყვანი სივრცეებს ​​და შეწყვეტს მინიჭებას, როდესაც ის შეხვდება პირველ სივრცეს მნიშვნელოვან სიმბოლოებს შორის. გადახედე პროგრამას:

puts("გთხოვთ შეიყვანოთ თქვენი სახელი:");

scanf("%s", სახელი);

გთხოვთ გაითვალისწინოთ, რომ get address ოპერატორი არ გამოიყენება სიმებიანი ცვლადის სახელთან ერთად. თუ კლავიატურაზე აკრიფებთ "Nancy" და დააჭირეთ Enter-ს, ეს სიმბოლოები მიენიჭება სახელის ცვლადს. მაშინაც კი, თუ თქვენ აკრიფებთ „Nancy Chasin“, scanf() დაიწყებს სიმბოლოების მინიჭებას პირველ მნიშვნელოვან სიმბოლოზე და შეჩერდება, როდესაც ის შეხვდება პირველ სივრცეს, ასე რომ, ცვლადის მნიშვნელობა მაინც იქნება მხოლოდ ნენსის სახელი, ხოლო პროგრამა უგულებელყოფს დანარჩენს. (სურათი 5.10).

ბრინჯი. 5.10. scanf() ფუნქცია აჩერებს სიმბოლოების კითხვას სტრიქონში პირველ სივრცეში

scanf() ფუნქციის ამ მახასიათებლის გამო, ის არ არის ძალიან მოსახერხებელი სტრიქონების შეყვანისთვის. ამ შემთხვევაში, უმჯობესია გამოიყენოთ gets() ფუნქცია.

scanf() ფუნქცია არის ზოგადი დანიშნულების შეყვანის რუტინა, რომელიც კითხულობს მონაცემებს stdin-იდან. მას შეუძლია წაიკითხოს ყველა ძირითადი მონაცემთა ტიპი და ავტომატურად გადაიყვანოს ისინი სასურველ შიდა ფორმატში. თუ printf() ახორციელებდა შეყვანას და არა გამომავალს, მას შეიძლება ეწოდოს scanf() ანალოგი.

საკონტროლო სტრიქონი, რომელზეც მითითებულია ფორმატი, შედგება სამი ტიპის სიმბოლოსგან:

• ფორმატის სპეციფიკატორები
• სპეციალური სიმბოლოები
• სხვა პერსონაჟები (არა განსაკუთრებული)

ფორმატის დამახასიათებლები მიჰყვებიან პროცენტულ სიმბოლოს და ეუბნებიან scanf() რა ტიპის მონაცემები წაიკითხება შემდეგ. სპეციფიკაციის კოდები მოცემულია ცხრილში.

მაგალითად, %s კითხულობს სტრიქონს, ხოლო %d კითხულობს მთელ ცვლადს.

ფორმატის სტრიქონი იკითხება მარცხნიდან მარჯვნივ, ფორმატის კოდების შესაბამისობაში არგუმენტების სიაში.

საკონტროლო სტრიქონში სპეციალური სიმბოლოები იწვევს scanf()-ის გამოტოვებას ერთი ან მეტი სპეციალური სიმბოლოს შეყვანის ნაკადში. სპეციალური სიმბოლოები არის სივრცე, ჩანართი ან ახალი ხაზი. ერთი სპეციალური სიმბოლო საკონტროლო ხაზზე იწვევს scanf()-ის წაკითხვას, შენახვის გარეშე, ნებისმიერი რაოდენობის (ნულის ჩათვლით) თანმიმდევრული სპეციალური სიმბოლოების შეყვანის ნაკადიდან, სანამ არ შეხვდება სიმბოლოს, რომელიც არ არის სპეციალური სიმბოლო.

რეგულარული სიმბოლოს არსებობა იწვევს scanf()-ის წაკითხვას და გაუქმებას შესაბამისი სიმბოლოს. მაგალითად, "%d,%d" იწვევს scanf()-ს წაიკითხოს მთელი რიცხვი, წაიკითხოს და გაუქმდეს მძიმით და შემდეგ წაიკითხოს სხვა მთელი რიცხვი. თუ მითითებული სიმბოლო არ არის ნაპოვნი შეყვანის ნაკადში, scanf() ჩერდება.

ყველა ცვლადი, რომელიც გამოიყენება მნიშვნელობების მისაღებად scanf() ფუნქციის გამოყენებით, უნდა მოძებნოთ მათი მისამართებით. ეს ნიშნავს, რომ ფუნქციის ყველა არგუმენტი უნდა იყოს ცვლადის მითითება. ამრიგად, C ქმნის მითითებით გადაცემის უნარს და ეს საშუალებას აძლევს ფუნქციას შეცვალოს არგუმენტის შინაარსი.

Scanf("%d", &count);

სტრიქონები იკითხება სიმბოლოთა მასივებში, ხოლო მასივის სახელი, ყოველგვარი მაჩვენებლის გარეშე, არის მასივის პირველი ელემენტის მისამართი. ამიტომ, სიმბოლოების მასივის მისამართში სტრიქონის წასაკითხად, შეგიძლიათ გამოიყენოთ ბრძანება

Scanf("%s", მისამართი);

ამ შემთხვევაში, სახელის მისამართი უკვე არის მაჩვენებელი და არ სჭირდება & პრეფიქსი.

შეყვანის მონაცემთა ელემენტები უნდა იყოს გამოყოფილი ინტერვალით, ჩანართებით ან ახალი ხაზებით.
სასვენი ნიშნები, როგორიცაა მძიმეები, მძიმით და ა.შ. არ განიხილება გამიჯვნად. ეს ნიშნავს, რომ ოპერატორისთვის

Scanf("%d%d", &r, &с);

თანმიმდევრობა 10 20 მიიღება, მაგრამ თანმიმდევრობა 10,20 არა. scanf() ფორმატის სპეციფიკატორები იმავე თანმიმდევრობითაა, როგორც ცვლადები არგუმენტების სიაში, რომლებსაც ენიჭებათ მიღებული ცვლადების მნიშვნელობები.

* ნიშანი %-ის შემდეგ და ფორმატის მითითების წინ კითხულობს მითითებული ტიპის მონაცემებს, მაგრამ თრგუნავს მისთვის მინიჭებას. ასე რომ კოდი

Scanf("%d%*c%d", &x, &y);

10/20 მიმდევრობაში შეყვანისას, ანიჭებს მნიშვნელობას 10 x ცვლადს, უგულებელყოფს / სიმბოლოს და ანიჭებს მნიშვნელობას 20 ცვლადს y.

ფორმატირების ბრძანებებს შეუძლიათ განსაზღვრონ მოდიფიკატორი ველის მაქსიმალური სიგანისთვის. ეს არის მთელი რიცხვი, რომელიც მოთავსებულია % ნიშანსა და ფორმატის სპეციფიკატორს შორის. ის ზღუდავს წაკითხული სიმბოლოების რაოდენობას რომელიმე მოცემულ ველზე. მაგალითად, თუ თქვენ გჭირდებათ არაუმეტეს 20 სიმბოლოს წაკითხვა მისამართების მასივში, დაწერეთ

Scanf("%20s", მისამართი);

თუ შეყვანის ნაკადი შეიცავდა 20-ზე მეტ სიმბოლოს, მაშინ, როდესაც შეყვანის ფუნქცია გამოიძახება, ის დაიწყებს შეყვანას იმ ადგილიდან, სადაც შეყვანა შეჩერდა მიმდინარე ზარის დროს. ველის შეყვანა შეიძლება შეწყდეს ველის მაქსიმალური სიგრძის მიღწევამდე, თუ სივრცეს შეხვდება. ამ შემთხვევაში, scanf() გადადის შემდეგ ველზე.

მიუხედავად იმისა, რომ სივრცეები, ჩანართები და ახალი ხაზები გამოიყენება ველების გამყოფებად, ისინი იკითხება როგორც ნებისმიერი სხვა სიმბოლო ერთი სიმბოლოს შეყვანისას. მაგალითად, მოცემული შეყვანის ნაკადი x y ფუნქცია

Scanf("%c%c%c", &a, &b, &c);

ათავსებს x ცვლადში a, სივრცეს b ცვლადში და y ცვლადში c.

ერთი რამ, რაზეც ფრთხილად უნდა იყოთ, არის ის, რომ ნებისმიერი სხვა სიმბოლო საკონტროლო სტრიქონში - მათ შორის ინტერვალი, ჩანართები და ახალი ხაზები - გამოიყენება შეყვანის ნაკადიდან სიმბოლოების აღსანიშნავად და გასაუქმებლად. მაგალითად, 10t20 შეყვანის ნაკადით, ფუნქცია

Scanf("%st%s", &x, &y);

ადგილები 10 x-ში და 20 y-ში. სიმბოლო t გაუქმდება, რადგან საკონტროლო სტრიქონში არის t.

scanf() ფუნქციის კიდევ ერთ მახასიათებელს ეწოდება სკანირების ნაკრები. სკანირების ნაკრები განსაზღვრავს სიმბოლოებს, რომლებიც წაიკითხება scanf() ფუნქციით და მიენიჭება შესაბამისი სიმბოლოების მასივის ელემენტებს. სკანირების ნაკრების დასაყენებლად, თქვენ უნდა მოათავსოთ სიმბოლოები, რომელთა შეყვანა მისაღებია კვადრატულ ფრჩხილებში. პირველ კვადრატულ ფრჩხილს წინ უძღვის პროცენტის ნიშანი. მაგალითად, შემდეგი სკანირების ნაკრების სიაში მითითებულია, რომ scanf() კითხულობს მხოლოდ A, B და C სიმბოლოებს:

არგუმენტი, რომელიც შეესაბამება სკანირების ნაკრების სიას, უნდა იყოს სიმბოლოთა მასივის მაჩვენებელი. სკანირების ნაკრების გამოყენებისას, scanf() კითხულობს სიმბოლოებს და ათავსებს მათ მითითებულ მასივში, სანამ არ შეხვდება სიმბოლოს, რომელიც არ არის სკანირების კომპლექტში (ანუ იკითხება მხოლოდ სკანირების ნაკრების სიმბოლოები).

scanf()-ით დაბრუნებული მასივი შეიცავს null-შეწყვეტილ სტრიქონს. წასაკითხი სიმბოლოების სია ასევე შეიძლება განისაზღვროს შებრუნებული ფორმით. ამისათვის მოათავსეთ ^, როგორც პირველი სიმბოლო. შემდეგ scanf() მიიღებს ნებისმიერ სიმბოლოს, რომელიც არ არის სკანირების კომპლექტში.

თქვენ შეგიძლიათ გამოიყენოთ ციტატები, რათა მიუთითოთ მიღებულ სიმბოლოთა დიაპაზონი. მაგალითად, შემდეგი გამონათქვამი ავალებს scanf()-ს მიიღოს ასოები "A" "Z"-მდე:

მრავალმხრივი სკანირება განასხვავებს დიდ და პატარა ასოებს. თუ გსურთ, რომ scanf()-მა ორივე მიიღოს, თქვენ უნდა ჩამოთვალოთ ისინი ცალკე სკანირების კომპლექტში.

scanf() ფუნქცია აბრუნებს რიცხვს, რომელიც ტოლია იმ ველების რაოდენობას, რომელთა მნიშვნელობები რეალურად მინიჭებული იყო ცვლადებზე. ეს რიცხვი არ შეიცავს წაკითხულ ველებს, მაგრამ მათი მნიშვნელობები არ იყო მინიჭებული არაფერზე * მოდიფიკატორის გამოყენების გამო დავალების ჩასახშობად. თუ შეცდომა მოხდა პირველი ველის მინიჭებამდე, EOF ბრუნდება.

Borland C++-ის გამოყენებისას 16-ბიტიან გარემოში, შეგიძლიათ შეცვალოთ ნაგულისხმევი მეხსიერების მოდელი, რომელიც გამოიყენება პროგრამის შედგენისთვის, ცალსახად მიუთითეთ თითოეული მაჩვენებლის ზომა scanf(-ის) გამოძახებისას. ახლო მაჩვენებელი მითითებულია N მოდიფიკატორის მიერ, ხოლო შორს მაჩვენებელი F მოდიფიკატორის მიერ (თქვენ არ შეგიძლიათ გამოიყენოთ N მოდიფიკატორი, თუ პროგრამა შედგენილია უზარმაზარი მეხსიერების მოდელისთვის.)

scanf() ფუნქცია არის ზოგადი დანიშნულების პროცედურა, რომელიც კითხულობს stdin-ს და ინახავს ინფორმაციას არგუმენტების სიაში ჩამოთვლილ არგუმენტებში მითითებულ ცვლადებში. მას შეუძლია წაიკითხოს ყველა ჩაშენებული მონაცემთა ტიპი და ავტომატურად გადაიყვანოს ისინი შესაბამის შიდა ფორმატში.

C99 ვერსიაში, შეზღუდვის კვალიფიკატორი გამოყენებული იყო ფორმატის პარამეტრზე.

ფორმატის პარამეტრით მითითებული საკონტროლო სტრიქონი შედგება სამი კატეგორიის სიმბოლოებისგან:

• ფორმატის დამახასიათებლები;
• სივრცის სიმბოლოები;
• სიმბოლოები, გარდა ცარიელი სივრცისა.

ფორმატის დამახასიათებლები - წინ უძღვის პროცენტის ნიშანი (%) - მიუთითებს, თუ რა ტიპის მონაცემები წაიკითხება შემდეგ. მაგალითად, %s სპეციფიკატორი წაიკითხავს სტრიქონს, ხოლო %d წაიკითხავს მთელ მნიშვნელობას. ფორმატის სტრიქონი იკითხება მარცხნიდან მარჯვნივ და ფორმატის სპეციფიკატორები ემთხვევა არგუმენტების სიაში ჩამოთვლილ არგუმენტებს. ეს კოდები ნაჩვენებია შემდეგ ცხრილში.

ნაგულისხმევად, a, f, e და g სპეციფიკატორები იწვევენ scanf()-ს მონაცემების მინიჭებას float ცვლადებისთვის. თუ ამ ფორმატის ერთ-ერთ მახასიათებელს პრეფიქსი l მოდიფიკატორთან დაამაგრებთ, scanf() ფუნქცია მის მიერ წაკითხულ მონაცემებს მიანიჭებს double ტიპის ცვლადს. L მოდიფიკატორის გამოყენება ნიშნავს, რომ მნიშვნელობის მიმღები ცვლადი არის long double ტიპის.

თუ იყენებთ თანამედროვე შემდგენელს, რომელიც მხარს უჭერს 1995 წელს დამატებულ ორბაიტი სიმბოლოების მახასიათებლებს, შეგიძლიათ გამოიყენოთ l მოდიფიკატორი c სპეციფიკატორზე, რათა მიუთითოთ ორმაგი ბაიტიანი სიმბოლო მონაცემთა ტიპის whcar_t. l მოდიფიკატორი ასევე შეიძლება გამოყენებულ იქნას s ფორმატის კოდთან ერთად, რათა მიუთითოს ორმაგი ბაიტიანი სიმბოლოების სტრიქონი. გარდა ამისა, l მოდიფიკატორი შეიძლება გამოყენებულ იქნას სკანირებული ორმაგი ბაიტიანი სიმბოლოების ნაკრების შესაცვლელად.

ფორმატის სტრიქონში თეთრი სივრცის სიმბოლოები იწვევს scanf() ფუნქციის გამოტოვებას ერთი ან მეტი სივრცის სიმბოლოს შეყვანის ნაკადში. ცარიელი სივრცის სიმბოლო ნიშნავს ინტერვალს, ჩანართს ან ახალი ხაზის სიმბოლოს. არსებითად, ერთი უფსკრული სიმბოლო საკონტროლო სტრიქონში გამოიწვევს scanf()-ის წაკითხვას, მაგრამ არ შეინახავს უფსკრული სიმბოლოების ნებისმიერი რაოდენობის (თუნდაც ნულს) პირველი არა-სივრცის სიმბოლომდე.

ფორმატის სტრიქონში არა-თეთრი სიმბოლო იწვევს scanf()-ის წაკითხვას და გაუქმებას შესაბამისი სიმბოლოს. მაგალითად, %d, %d ფორმატის სტრიქონის გამოყენებისას, scanf() ჯერ წაიკითხავს მთელ რიცხვს, შემდეგ წაიკითხავს და გააუქმებს მძიმეს და ბოლოს წაიკითხავს სხვა მთელ რიცხვს. თუ მითითებული სიმბოლო ვერ მოიძებნა, scanf() გამოვა.

ყველა ცვლადი, რომელიც გამოიყენება scanf() ფუნქციის გამოყენებით მნიშვნელობების მისაღებად, უნდა გადავიდეს მათი მისამართებით. ეს ნიშნავს, რომ ყველა არგუმენტი უნდა იყოს ცვლადის მითითება.

შეყვანის ნაკადის ელემენტები უნდა იყოს გამოყოფილი ინტერვალით, ჩანართებით ან ახალი ხაზებით. სიმბოლოები, როგორიცაა მძიმით, მძიმით და ა.შ. არ არის აღიარებული როგორც გამსაზღვრელი. ეს ნიშნავს, რომ ოპერატორი

Scanf("%d%d", &r, &c);

მიიღებს 10 20-ად შეყვანილ მნიშვნელობებს, მაგრამ კატეგორიულად უარს იტყვის 10.20 მოწოდებულ „კერძზე“.

* სიმბოლო % ნიშნის შემდეგ და ფორმატის კოდის წინ წაიკითხავს მითითებული ტიპის მონაცემებს, მაგრამ აკრძალავს მის მინიჭებას. ამიტომ, ოპერატორი

Scanf("%d%*c%d", &x, &y);

როდესაც შეიყვანება როგორც 10/20, მოათავსებს მნიშვნელობას 10 x ცვლადში, გააუქმებს გაყოფის ნიშანს და მიანიჭებს მნიშვნელობას 20 y ცვლადს.

ფორმატირების ბრძანებები შეიძლება შეიცავდეს ველის მაქსიმალური სიგრძის მოდიფიკატორს. ეს არის მთელი რიცხვი, რომელიც მოთავსებულია % ნიშანსა და ფორმატის კოდს შორის, რომელიც ზღუდავს მოცემული ველისთვის წაკითხული სიმბოლოების რაოდენობას. მაგალითად, თუ გსურთ წაიკითხოთ მაქსიმუმ 20 სიმბოლო მისამართების ცვლადში, გამოიყენეთ შემდეგი განცხადება.

Scanf("%20s", მისამართი);

თუ შეყვანის ნაკადი შეიცავს 20-ზე მეტ სიმბოლოს, მაშინ შეყვანის ოპერაციაზე წვდომის შემდეგ, კითხვა დაიწყება იმ ადგილიდან, სადაც წინა scanf() ფუნქციის გამოძახება "შეჩერდა". თუ შეგხვდებათ ველის სიმბოლო, ველის მონაცემების შეყვანა შეიძლება დასრულდეს ველის მაქსიმალური სიგრძის მიღწევამდე. ამ შემთხვევაში, scanf() ფუნქცია გადადის შემდეგი ველის კითხვაზე.

მიუხედავად იმისა, რომ სივრცეები, ჩანართები და ახალი ხაზები გამოიყენება როგორც ველის გამყოფები, ერთი სიმბოლოს კითხვისას ისინი იკითხება როგორც ნებისმიერი სხვა სიმბოლო. მაგალითად, თუ შეყვანის ნაკადი შედგება x y სიმბოლოებისგან, მაშინ ოპერატორი

Scanf("%c%c%c", &a, &b, &c);

განთავსდება სიმბოლო x a ცვლადში, სივრცე b ცვლადში და სიმბოლო y c ცვლადში.

გახსოვდეთ, რომ ნებისმიერი სხვა საკონტროლო სტრიქონის სიმბოლო, რომელიც არ არის ფორმატის სპეციფიკატორი (მათ შორის, სივრცეები, ჩანართები და ახალი ხაზები) გამოიყენება შეყვანის ნაკადიდან სიმბოლოების შესატყვისად და გასაუქმებლად. მაგალითად, თუ შეყვანის ნაკადი ჰგავს 10t20, განცხადება

Scanf("%st%s", &x, &y);

დააყენებს 10-ს x ცვლადში და 20-ს y ცვლადში. t სიმბოლო გაუქმებულია, რადგან ის იმყოფება საკონტროლო სტრიქონში.

scanf() ფუნქციის გამოყენების სხვა გზას ეწოდება scanset. ამ შემთხვევაში, განსაზღვრულია სიმბოლოების ნაკრები, რომელიც შეიძლება წაიკითხოს scanf() ფუნქციით და მიენიჭოს შესაბამის სიმბოლოთა მასივს. ასეთი ნაკრების დასადგენად, კვადრატულ ფრჩხილებში უნდა ჩართოთ დასასკანერებელი სიმბოლოები. გახსნის კვადრატული ფრჩხილი დაუყოვნებლივ უნდა მიჰყვეს პროცენტის ნიშანს. მაგალითად, დასკანირებული სიმბოლოების შემდეგი ნაკრები მიუთითებს, რომ მხოლოდ A, B და C სიმბოლოები უნდა წაიკითხონ.

%[ABC]

სკანირებისთვის სიმბოლოების ნაკრების გამოყენებისას, scanf() აგრძელებს სიმბოლოების კითხვას და განათავსებს მათ შესაბამის სიმბოლოთა მასივში, სანამ არ შეხვდება სიმბოლოს, რომელიც არ არის მითითებული სიმბოლოების კომპლექტში. შესაბამისი ნაკრები ცვლადი უნდა იყოს სიმბოლოთა მასივის მაჩვენებელი. როდესაც scanf() დაბრუნდება, ეს მასივი შეიცავს წაკითხული სიმბოლოების null-შეწყვეტილ სტრიქონს.

თუ ნაკრების პირველი სიმბოლო არის caret (^), მაშინ მივიღებთ საპირისპირო ეფექტს: შეყვანის ველი იკითხება მოცემული სიმბოლოების ნაკრებიდან პირველ სიმბოლომდე, ე.ი. caret იწვევს scanf()-ს მიიღოს ნებისმიერი სიმბოლო, რომელიც არ არის განსაზღვრული ნაკრებში.

ბევრი შემდგენელი საშუალებას გაძლევთ მიუთითოთ დიაპაზონი დეფისის გამოყენებით. მაგალითად, შემდეგი განცხადება იწვევს scanf() ფუნქციას A-დან Z-მდე სიმბოლოების მიღებას.

მნიშვნელოვანია გვახსოვდეს, რომ დასკანირებული სიმბოლოების ნაკრები განასხვავებს დიდ და პატარა ასოებს. ამიტომ, თუ გსურთ როგორც დიდი, ასევე პატარა ასოების სკანირება, დააყენეთ ისინი ცალკე.

scanf() ფუნქცია აბრუნებს რიცხვს, რომელიც უდრის იმ ველების რაოდენობას, რომლებსაც წარმატებით მიენიჭათ მნიშვნელობები. ეს ველები არ შეიცავს ველებს, რომლებიც წაიკითხეს, მაგრამ არ იყო მინიჭებული დავალების ჩასახშობად * მოდიფიკატორის გამოყენების გამო. თუ შეცდომა გამოვლინდა პირველი ველის დაყენებამდე, scanf() აბრუნებს EOF-ს.

Scanf()-ს დაემატა ფორმატის მოდიფიკატორები C99 სტანდარტით

C99-მა დაამატა რამდენიმე ფორმატის მოდიფიკატორი scanf() ფუნქციაში გამოსაყენებლად: hh, ll, j, z და t. hh მოდიფიკატორი შეიძლება გამოვიყენოთ d, i, o, u, x და n მითითებებზე, ეს ნიშნავს, რომ შესაბამისი არგუმენტი არის მაჩვენებელი char-ის ტიპის ან ხელმოუწერელი char. ll მოდიფიკატორი ასევე შეიძლება გამოვიყენოთ d, i, o, u, x და n მახასიათებლებზე, ეს ნიშნავს, რომ შესაბამისი არგუმენტი არის ინდიკატორი ტიპის მნიშვნელობისა, რომელიც ხელმოწერილია long long int ან unsigned long long int.

j ფორმატის მოდიფიკატორი, რომელიც ვრცელდება d, i, o, u, x და n სპეციფიკატორებზე, ნიშნავს, რომ შესაბამისი არგუმენტი არის მაჩვენებელი intmax_t ან uintmax_t ტიპის მნიშვნელობის მიმართ. ეს ტიპები გამოცხადებულია სათაურში და ემსახურება მაქსიმალური სიგრძის მთელი რიცხვების შენახვას.

z ფორმატის მოდიფიკატორი, რომელიც ვრცელდება d, i, o, u, x და n სპეციფიკატორებზე, ნიშნავს, რომ შესაბამისი არგუმენტი არის მაჩვენებელი ზომის_t ტიპის ობიექტის მიმართ. ეს ტიპი გამოცხადებულია სათაურში და ემსახურება ოპერაციის ზომის შედეგის შენახვას.

ფორმატის მოდიფიკატორი t, რომელიც ვრცელდება d, i, o, u, x და n სპეციფიკატორებზე, ნიშნავს, რომ შესაბამისი არგუმენტი არის მაჩვენებელი ptrdiff_t ტიპის ობიექტის მიმართ. ეს ტიპი გამოცხადებულია სათაურში და ემსახურება ორ მაჩვენებელს შორის სხვაობის მნიშვნელობის შესანახად.