C#-ში დაწერილი პროგრამა შედგება შემდეგი ბლოკებისგან:

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

მარტივი პროგრამის მაგალითი

მოდით შევხედოთ C#-ში დაწერილ მარტივ პროგრამას. ეს იქნება კონსოლის აპლიკაცია, რომელიც ბეჭდავს სტრიქონს "Hello World" (ერთგვარი კლასიკა პირველი პროგრამისთვის პროგრამისტის პრაქტიკაში). ასეთი პროგრამის კოდი მოცემულია ქვემოთ, მოდით შევხედოთ მას:

//სახელთა სივრცის სისტემის დაკავშირება სისტემის გამოყენებით; //სახელთა სივრცის სახელთა სივრცის დეკლარაცია ProgramStructure ( //კლასის კლასის დეკლარაცია Program ( //პროგრამის მთავარი მეთოდი static void Main(string args) ( //გამოიყვანეთ ხაზი Console.WriteLine("Hello World!"); / /დამხმარე ოპერატორი Console.ReadKey () ) )

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

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

მეორე ხაზის ბოლოს არის ";" სიმბოლო, რომელიც მიუთითებს განცხადების დასასრულს. თითოეული პროგრამის განცხადება უნდა დასრულდეს ასეთი სიმბოლოთი.

პროგრამის მეოთხე სტრიქონი ისევ არის კომენტარი, ისევე როგორც 7, 10, 13, 15 სტრიქონები. კომენტარები C#-ში იწყება სიმბოლოებით „//“ (ორი წინ დახრილი, ორი დახრილი) და მოქმედებს მხოლოდ ბოლომდე. ხაზი.

C#-ს ასევე აქვს მრავალხაზოვანი კომენტარები, ზოგჯერ მათი გამოყენება უფრო მოსახერხებელია, მათ მოგვიანებით შევხვდებით.

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

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

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

მეთოდი მთავარიჩვენი პროგრამა შეიცავს მხოლოდ ორ განცხადებას. ეს განცხადებები ჩანს მე-14 და მე-16 სტრიქონებზე. პირველი ბეჭდავს შეტყობინებას "Hello World!" მეორე კი დამხმარეა, ის აიძულებს პროგრამას დაელოდოს კლავიატურაზე კლავიშის დაჭერას და არ აძლევს უფლებას ამ მომენტამდე დაასრულოს შესრულება (ამ ოპერატორის გარეშე პროგრამა ხაზს დაბეჭდავდა და სწრაფად დაიხურებოდა , ისე, რომ დროც არ გვქონდა წაკითხვისთვის, რა გამოვიდა).

ახლა სცადეთ ამ პროგრამის შექმნა და გაშვება Visual Studio-ში. ამისათვის საჭიროა:

• ვიზუალური სტუდიის გაშვება;
• ახალი კონსოლის აპლიკაციის პროექტის შექმნა;
• დააკოპირეთ 13-16 სტრიქონები ზემოთ მოყვანილი მაგალითიდან;
• ჩადეთ ეს ხაზები მეთოდში მთავარი Visual Studio-ში შექმნილი პროექტი;
• დააჭირეთ F5 ღილაკს.

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

C ენაზე დაწერილი ნებისმიერი პროგრამა შედგება ერთი ან მეტი „ფუნქციისაგან“, რომელიც არის ძირითადი მოდული, საიდანაც იგი აწყობილია.

მარტივი C პროგრამის სტრუქტურის მაგალითი:

ზოგადი ხედი	მაგალითი
წინასწარი პროცესორის დირექტივები	#შეიცავს # განსაზღვრეთ N 10
მთავარი ფუნქციის სახელი
ძირითადი ფუნქციის ორგანოს დაწყება
ცვლადების და მასივების დეკლარაციები	int x=1; char str[N];
პროგრამის განცხადებები	აყენებს ("შედი სახელი"); იღებს (str); printf("\n %s, თქვენ %d ხართ ჩემი სტუმარი!",str,x);
ძირითადი ფუნქციის ორგანოს დასასრული

1. წინასწარი პროცესორის დირექტივები

შემდგენელის ნაწილი არის პროგრამა ე.წ წინასწარი პროცესორი. წინასწარი პროცესორი მუშაობს მანამ, სანამ პროგრამა გადაითარგმნება მაღალი დონის ენიდან მანქანურ ენაზე, ახორციელებს მის წინასწარ კონვერტაციას. თითოეული წინაპროცესორის დირექტივა იწყება # (ნომრის) სიმბოლოთი და მოიცავს მთელ ხაზს. დირექტივები, რომლებიც არ ჯდება ერთ ხაზზე, შეიძლება გაგრძელდეს შემდეგ ხაზზე. ხაზის გაგრძელების ნიშანი არის უკუღმა დახაზვის სიმბოლო (\) გასაგრძელებელ ხაზში.

ყველაზე ხშირად გამოყენებული დირექტივა არის ფაილის ჩართვა პროგრამაში

# მოიცავს < სახელი>

სად სახელი– პროგრამის ტექსტში შეტანილი ფაილის სახელი.

ამ დირექტივას ე.წ ჩანაცვლების დირექტივა . ის ავალებს შემდგენელს დააყენოს ფაილი თავის ადგილზე სახელი. სახელიფაილი

# მოიცავს < ე.წ. header. ის შეიცავს პროგრამაში გამოყენებული მონაცემებისა და ფუნქციების დეკლარაციებს. მაგალითად, პროგრამაში დირექტივის ჩათვლით. მათემატიკა>

თ

საშუალებას მოგცემთ გამოიყენოთ პროგრამაში სტანდარტული მათემატიკური ფუნქციები, როგორიცაა sin x, cos x, ln x და ა.შ. ქვემოთ მოცემულია სტანდარტული მათემატიკური ფუნქციების სია.

# მოიცავს < დირექტივა. მათემატიკა>

stdio

შესაძლებელს ხდის პროგრამაში სტანდარტული შეყვანის/გამოსვლის ფუნქციების გამოყენებას.

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

სად #define S1 S2 S1, S2

- სიმბოლოების სიმები. წინასწარი პროცესორი პოულობს სიმბოლოების სტრიქონს პროგრამის ტექსტში1 ს წინასწარი პროცესორი პოულობს სიმბოლოების სტრიქონს პროგრამის ტექსტში2 და ცვლის მას სტრიქონით

# . მაგალითად, პროგრამაში დირექტივის ჩათვლით განსაზღვრა პ

printf განსაზღვრასაშუალებას გაძლევთ აკრიფოთ ასო კლავიატურაზე პ.

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

1. არ ვრცელდება ბრჭყალებით, აპოსტროფებით და კომენტარებში მოთავსებულ ტექსტებზე.

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

ამრიგად, ხაზი ძირითადი ფუნქციის სახელწოდებით ჩვეულებრივ ასე გამოიყურება:

ბათილად მთავარი (ბათილი)

1. void main()

ცვლადები და მასივები

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

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

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

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

k = sizeof(int); პ(„ტიპის ცვლადის ქვეშინტგამოყოფილია %d მეხსიერების ბაიტი”,კ);

ეს გაიდლაინები განიხილავს ცვლადებისა და მასივების სამ ძირითად ტიპს და იძლევა ტიპიურ მნიშვნელობებს დაკავებული მეხსიერების რაოდენობისა და მნიშვნელობების დიაპაზონისთვის (ცხრილი 1):

ცხრილი 1

	ტიპის სპეციფიკატორი (საკვანძო სიტყვა)	მნიშვნელობა	ზომა მეხსიერება (ბაიტი)	ღირებულებების დიაპაზონი
		მთელი რიცხვი		32768 . . . +32767
				2147483648 . . . +2147483647
მოქმედებს		რეალური ნომერი		3.4¼10 -38. . . 3.4ּ10 38 (მოდული)
სიმბოლური				128 . . . +127

მოდით უფრო ახლოს მივხედოთ ტიპის ცვლადს char. როგორც ცხრილიდან ჩანს. 1, ტიპის ცვლადი char იკავებს მეხსიერების ერთ ბაიტს. მეხსიერების ერთი ბაიტი შეიძლება შეიცავდეს ან ხელმოუწერელ მთელ რიცხვს დიაპაზონიდან, ან ხელმოწერით რიცხვს დიაპაზონიდან [–128, 127]. ეს რიცხვი არის 256 სიმბოლოდან ერთ-ერთის კოდი. მოცემული კოდის შესაბამისი სიმბოლო განისაზღვრება გამოყენებული კოდის ცხრილით. ამრიგად, მსგავსი ცვლადის მნიშვნელობა charშეიძლება განიხილებოდეს როგორც მთელი რიცხვი ან როგორც სიმბოლო, რომლის კოდიც ამ რიცხვის ტოლია.

ლექცია No1

თემა: C++ ენის შესავალი. ოპერატორები და მონაცემთა ტიპები

დაგეგმეთ

3. ცვლადები და მათი ტიპები

4. ოპერატორები და მათემატიკური ფუნქციები

5. I/O ოპერატორები C++-ში

6. სამაგალითო პროგრამა C++-ში

1. C++ პროგრამირების ენის განვითარების ისტორია

C++ ენა, რომელიც აერთიანებს C ენის თვისებებს და ობიექტზე ორიენტირებულ პროგრამირებას, 90-იან წლებში გახდა ერთ-ერთი მთავარი პროგრამირების ენა და მტკიცედ აგრძელებს ასე დარჩენას 21-ე საუკუნის დასაწყისში. C++ ენამ C ენიდან მიიღო ისეთი თვისებები, როგორიცაა ეფექტურობა, კომპაქტურობა, შესრულების სიჩქარე და პროგრამების პორტაბელურობა. ობიექტზე ორიენტირებული პროგრამირებიდან C++ ენამ მიიღო პროგრამირების ახალი მეთოდოლოგია, რომელიც საშუალებას აძლევს მას გაუმკლავდეს თანამედროვე პროგრამირების პრობლემების გაზრდილ სირთულეს. და ენის მახასიათებლებმა, როგორიცაა გაუმჯობესებული შაბლონები, C++-ს კიდევ ერთი ახალი პროგრამირების მეთოდოლოგია შემოაქვს: ზოგადი პროგრამირება. ეს სამმაგი მემკვიდრეობა ერთდროულად კურთხევაა და წყევლაც C++ ენისთვის. ისინი ენას ძალიან ძლიერ, მაგრამ ამავე დროს ართულებენ; რაც ნიშნავს, რომ პროგრამისტებმა მეტი უნდა ისწავლონ.

ბოლო რამდენიმე ათწლეულის განმავლობაში კომპიუტერული ტექნოლოგია განსაცვიფრებელი ტემპით განვითარდა. პროგრამირების ენებმა ასევე განიცადეს მნიშვნელოვანი ევოლუცია. 1970-იან წლებში, პროგრამირების ენებმა, როგორიცაა C და Pascal, დაეხმარნენ სტრუქტურირებული პროგრამირების ეპოქას და წესრიგში მოჰყავდათ ის სფერო, რომელსაც ეს ძალიან სჭირდებოდა. C ენა უზრუნველყოფდა პროგრამისტს სტრუქტურირებული პროგრამირებისთვის საჭირო ინსტრუმენტებით, ასევე კომპაქტური, სწრაფად გაშვებული პროგრამების შესაქმნელად და აპარატურის მისამართის უნარს, როგორიცაა საკომუნიკაციო პორტების და მაგნიტური დისკის მართვის უნარი. ამ თვისებებმა დაეხმარა C გამხდარიყო დომინანტური პროგრამირების ენა 1980-იან წლებში. ამავდროულად, ამ წლების განმავლობაში გაჩნდა პროგრამირების ახალი მოდელი: ობიექტზე ორიენტირებული პროგრამირება, ან OOP, განსახიერებული ისეთ ენებში, როგორიცაა SmallTalk და C++.

C ენა

Bell Laboratories-ის თანამშრომელმა კენ ტომპსონმა შეიმუშავა B (bi) ენა 1969 წელს სხვა პროგრამული სისტემების შესაქმნელად. ამასთან, ეს ენა იყო ინტერპრეტირებული, რაც არ იძლეოდა მასში დამოუკიდებელი შესრულებადი ფაილების შექმნის საშუალებას. მიუხედავად ამისა, ეს ენა იყო S ენის წინამორბედი.

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

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

C ენა, ისევე როგორც ჩვენი დროის უმეტესი პროგრამირების ენები, პროცედურულია.

C++ ენა

ობიექტზე ორიენტირებული ტექნოლოგიის განვითარებით, სტანდარტული C ენის შესაძლებლობები აღარ იყო საკმარისი. შედეგი იყო C++ ენა.

C++ ენა, ისევე როგორც C ენა, არის Bell Laboratories-ის შემოქმედება. ავტორმა ბჟარნი სტროსტრუპმა ეს ენა 80-იანი წლების დასაწყისში შეიმუშავა. მისივე სიტყვებით, „C++ შეიქმნა ძირითადად ისე, რომ მე და ჩემს მეგობრებს არ გვქონდეს პროგრამირება ასამბლეის, C ან სხვადასხვა თანამედროვე მაღალი დონის ენებზე. მისი მთავარი მიზანი ეს იყო: ცალკეული პროგრამისტებისთვის კარგი პროგრამების დაწერა უფრო მარტივი და სასიამოვნო ყოფილიყო“.

სტროუსტრუპმა შექმნა C++ C ენიდან, რადგან C იყო ლაკონური, კარგად შეეფერებოდა სისტემების პროგრამირებას, ფართოდ ხელმისაწვდომი და მჭიდროდ იყო დაკავშირებული UNIX ოპერაციულ სისტემასთან. C++ ენის ობიექტზე ორიენტირებულ ნაწილზე გავლენა მოახდინა Simula67 მოდელირების ენამ. Stroustrup-მა დაამატა OOP ელემენტები C ენას, თავად C ენის მნიშვნელოვანი შეცვლის გარეშე.

სახელი C++ მომდინარეობს C ენის ++ increment ოპერატორიდან, რომელიც ერთს ამატებს ცვლადის მნიშვნელობას. სახელი C++ გულისხმობს, რომ ენა არის C ენის გაუმჯობესებული (++) ვერსია.

განზოგადებული პროგრამირება

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

2. პროგრამის სტრუქტურა C++-ში

C++ პროგრამა აგებულია ცალკეული ბლოკებისგან, რომელსაც ფუნქციები ეწოდება. როგორც წესი, პროგრამა იყოფა უამრავ დიდ დავალებად და შემდეგ მუშავდება ინდივიდუალური ფუნქციები ამ ამოცანების შესასრულებლად.

C++ პროგრამების უმეტესობა ასე გამოიყურება:

განყოფილება სათაურის ფაილების ჩათვლით

პროგრამის (ფუნქციის) სათაური

ფუნქციური სხეული

პროგრამის სათაური

C++ პროგრამა შედგება ერთი ან მეტი მოდულისაგან, რომელსაც ეწოდება ფუნქციები. პროგრამის შესრულება იწყება ფუნქციით, რომელსაც ეწოდება main(), ამიტომ პროგრამა უნდა შეიცავდეს ამ სახელწოდების ფუნქციას. თუ პროგრამას არ აქვს ასეთი ფუნქცია, მაშინ არ არსებობს სრული პროგრამა; შემდგენელი ამ შემთხვევაში მიუთითებს, რომ main() ფუნქცია არ იყო განსაზღვრული.

ასეთი ფუნქციის აღწერა შესრულებულია პროგრამის სათაურის განყოფილებაში და იწერება ფორმით:

მნიშვნელოვანია გავითვალისწინოთ ის ფაქტი, რომ C++ შემდგენელი არის რეგისტრის მგრძნობიარე. ამიტომ, სხვა შემთხვევაში აკრეფილი ფუნქციის სახელი (მაგალითად: Main() ან MAIN()) არასწორად იქნება აღიარებული.

სათაურის ფაილის კავშირის განყოფილება

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

ყოველ C++ პროგრამას ჯერ აქვს ფორმის დირექტივა:

#შეიცავს

ეს დირექტივა აიძულებს წინასწარ პროცესორს პროგრამაში დაამატოთ iostream ფაილის შინაარსი. ეს არის ტიპიური წინასწარი პროცესორი: ტექსტის დამატება ან შეცვლა საწყის კოდში კომპილაციამდე.

#include დირექტივა იწვევს iostream ფაილის შიგთავსის გადაცემას შემდგენელზე წყაროს ფაილის შინაარსთან ერთად. არსებითად, iostream ფაილის შინაარსი ცვლის #include ხაზს პროგრამაში . წყაროს ფაილი არ არის შეცვლილი და წყაროს ფაილიდან და iostream ფაილიდან შექმნილი კომბინირებული ფაილი მუშავდება შედგენის შემდეგ ეტაპზე.

ფაილებს, როგორიცაა iostream, ეწოდება მოიცავს ფაილებს (რადგან ისინი შედის სხვა ფაილებში) ან სათაურის ფაილებს (რადგან ისინი შედის ფაილის დასაწყისში). C++ შემდგენლები მოყვება მრავალი სათაურის ფაილს, რომელთაგან თითოეული მხარს უჭერს ინსტრუმენტების სხვადასხვა ოჯახს. სათაურის ფაილებს C ენაზე ტრადიციულად აქვთ გაფართოება h, ეს არის უმარტივესი გზა ფაილის ტიპის იდენტიფიცირებისთვის მისი სახელით. მაგალითად, სათაურის ფაილი math.h მხარს უჭერს C++ ენის სხვადასხვა მათემატიკურ ფუნქციებს.

სათაურის ფაილები განთავსებულია Turbo C++ განვითარების გარემოს Include საქაღალდეში. თუ პროგრამის დაწყებისას მიიღებთ შეცდომას, რომელიც მიუთითებს, რომ ჩართული სათაურის ფაილი აკლია, მაშინ თქვენ უნდა დააკონფიგურიროთ იგი Turbo C++ გარემოში. ამისათვის გაუშვით ბრძანება Options – Directories, შეიყვანეთ ..\INCLUDE ველში Include Directories და შეიყვანეთ ..\LIB ბიბლიოთეკის დირექტორიების ველში.

ფუნქციის სხეული

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

ფუნქციის სხეული ასე გამოიყურება:

ცვლადების აღწერა;

ოპერატორები;

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

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

RETURN 0 ინსტრუქცია მიუთითებს, რომ ფუნქცია გადის და უბრუნდება გამოძახების პროგრამას. ეს ინსტრუქცია შეიძლება არ იყოს მითითებული main() ფუნქციაში.

კომენტარები შეიძლება გამოყენებულ იქნას პროგრამის ტექსტში. C++-ში კომენტარები აღინიშნება ორმაგი ხაზებით (//). C++ პროგრამებს შეუძლიათ გამოიყენონ კომენტარები C ენიდან, რომლებიც ჩასმულია /* და */ სიმბოლოებს შორის.

ვინაიდან C კომენტარი მთავრდება არა ხაზის ბოლო სიმბოლოთი, არამედ */ სიმბოლოთი, ის შეიძლება გაგრძელდეს რამდენიმე სტრიქონზე. პროგრამებს შეუძლიათ გამოიყენონ ამ ორი ტიპის კომენტარიდან რომელიმე, ან ორივე ერთად. (დაწყება)

გთხოვთ შეაჩეროთ AdBlock ამ საიტზე.

ვიმედოვნებ, რომ თქვენ უკვე დააინსტალირეთ IDE თქვენს კომპიუტერში და ისწავლეთ მასში პროგრამების შედგენა. თუ არა, მაშინ

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

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

სურ.1 რუკა "პროგრამების სტრუქტურა C ენაზე." შესვლის დონე.

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

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

ჩამონათვალი 1. პროგრამა 1. ბეჭდავს „Hello, World!“

#შეიცავს

ჩამონათვალი 2. პროგრამა 2

Int main(void) ( int a, b, c; a = 5; b = 10; c = a+b; დაბრუნება 0; )

ჩამონათვალი 3. პროგრამა 3

#შეიცავს int main(void) ( FILE *fp; fp = fopen("input.txt", "w"); fprintf(fp, "ეს არის სპარტა!"); fclose(fp); დაბრუნება 0; )

დაუთმეთ დრო გაკვეთილის გაგრძელებას და ამ პრობლემაზე სწორ პასუხს. პირველ რიგში, შეეცადეთ უპასუხოთ საკუთარ თავს. ამის შემდეგ დააჭირეთ ღილაკს "ყურება გაგრძელება!"

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

ჩამონათვალი 4. ნებისმიერი C პროგრამის მთავარი ფუნქცია არის მთავარი ფუნქცია.

Int main(void) (return 0;)

როგორი დიზაინია ეს? ეს არის მთავარი ფუნქციის დეკლარაცია. ყველა პროგრამას, რომელიც დაწერილია C ენაზე, უნდა ჰქონდეს ასეთი ფუნქცია: დიდი თუ პატარა, კომპიუტერული თამაში ან პროგრამა "Hello, World!", თუ პროგრამა დაწერილია C ენა - მას აქვს მთავარი ფუნქცია. ეს არის, ასე ვთქვათ, ჩვენი პროგრამის მთავარი ფუნქცია. როდესაც ჩვენ ვატარებთ პროგრამას, შეგვიძლია ვიფიქროთ, რომ ის მუშაობს პროგრამის მთავარი ფუნქციით.

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

სურ.2 რუკა "პროგრამების სტრუქტურა C ენაზე." ფუნქცია მთავარი.

ახლა რუკა არ გვაწუხებს თავისი უფსკრული სიცარიელის გამო. გავაგრძელოთ ჩვენი კვლევა.

ნება მომეცით გითხრათ ცოტა ძირითადი ფუნქცია და ზოგადად ფუნქციების შესახებ.

ფუნქციის სახელს წინ უძღვის int, რომელიც არის სიტყვის მთელი რიცხვის აბრევიატურა, რომელიც ინგლისურიდან ითარგმნება როგორც „მთელი“. ეს აღნიშვნა ნიშნავს, რომ როდესაც მთავარი ფუნქცია ასრულებს თავის მუშაობას, მან უნდა დააბრუნოს გარკვეული მთელი რიცხვი გამოძახების პროგრამაში (ჩვენს შემთხვევაში, ოპერაციულ სისტემაში). როგორც წესი, ძირითადი ფუნქციისთვის ეს არის რიცხვი ნულოვანი, რომელიც აცნობებს ოპერაციულ სისტემას: „ყველაფერი კარგადაა, არანაირი ინციდენტი არ მომხდარა.

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

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

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

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

შეიძლება იკითხოთ, რატომ ზუსტად ნული? და ეშმაკმა იცის! ჩვეულებრივ ასე აკეთებენ. თქვენ შეგიძლიათ, პრინციპში, დააბრუნოთ სხვა მთელი რიცხვი, მაგალითად 100, ან -236. ეს რომ იყოს მთელი რიცხვი. გახსოვთ ინტ-ის შესახებ? ამიტომ მთელი.

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

ახლა დავუბრუნდეთ ჩვენს პირველ გადაცემას "გამარჯობა, სამყარო" და ვნახოთ რა არის.

ჩამონათვალი 5. გამარჯობა, მსოფლიო პროგრამა

#შეიცავს int main(void) ( printf("Hello, World!\n"); return 0;)

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

ჩამონათვალი 6. მოიცავს დირექტივას

#შეიცავს

ეს სტრიქონი არის შეტყობინება შემდგენელისთვის. ამ შეტყობინებებს, დაწყებული # სიმბოლოთი, ეწოდება შემდგენელი დირექტივები. სიტყვასიტყვით: "დააკავშირეთ stdio.h ფაილი." კომპილაციის დროს ამ ხაზის ნაცვლად ჩასმული იქნება stdio.h ფაილის შინაარსი. ახლა მოდით ვისაუბროთ ცოტა ამ ფაილზე. stdio.h (ინგლისური STanDart Input Output-დან) არის სათაურის ფაილი, რომელიც აღწერს სხვადასხვა სტანდარტულ ფუნქციებს, რომლებიც დაკავშირებულია შეყვანასთან და გამომავალთან.

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

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

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

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

სურ.3 რუკა "პროგრამების სტრუქტურა C ენაზე." ბლოკი სათაურის ფაილების დასაკავშირებლად.

გავაგრძელოთ ჩვენი პროგრამა.

ჩამონათვალი 7. printf() ფუნქცია

Printf ("გამარჯობა, მსოფლიო!\n");

ამ ხაზზე ჩვენ მოვუწოდებთ სტანდარტულ printf() ფუნქციას. ამ უმარტივეს შემთხვევაში, ჩვენ მას გადავცემთ ერთ პარამეტრს, ბრჭყალებში დაწერილ სტრიქონს, რომელიც უნდა გამოჩნდეს ეკრანზე, ჩვენს შემთხვევაში ეს არის Hello, World! \n. მაგრამ დაელოდე, რა არის ეს\n? პროგრამის დაწყებისას არ იყო \n ეკრანზე. მაშინ რატომ დავწერეთ ეს აქ? ეს თანმიმდევრობა არის სპეციალური სიმბოლო, რომელიც არის ბრძანება შემდეგ სტრიქონზე გადასასვლელად. ეს ჰგავს Enter კლავიშის დაჭერას MS Word-ში. არსებობს რამდენიმე ასეთი სპეციალური სიმბოლო, ყველა მათგანი იწერება "\" სიმბოლოს - უკანა ხაზის გამოყენებით. ამ სპეციალურ სიმბოლოებს საკონტროლო სიმბოლოებს უწოდებენ. მერე ისევ გაჩვენებ მათ. წინააღმდეგ შემთხვევაში, ეკრანზე გამოჩნდება ის, რაც ორმაგ ბრჭყალებში დაწერეთ.

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

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

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

ჩამონათვალი 8. სტანდარტული შაბლონი პროგრამებისთვის C ენაზე.

#შეიცავს int main(void) ( return 0; )

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

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

საფოსტო ბარათის პროგრამის საწყისი კოდი არის არქივში ამ გაკვეთილის წყაროს კოდებით. ექსპერიმენტი! თქვენ წარმატებას მიაღწევთ.

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

პროგრამის შესრულების პროცესი

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

C++ ენის ანბანი

C ანბანი მოიცავს:
ლათინური ანბანის დიდი და პატარა ასოები (A,B,...,Z, a, b,..., z) და და
ხაზგასმა;
ნომრები: 0,1,2,3,4,5,6,7,8,9
სპეციალური სიმბოლოები: " , () | () * + - / % \ ; " . :?< = >_! & # არაჩვენებადი სიმბოლო ("საერთო უფსკრული"),
გამოიყენება ტოკენების ერთმანეთისგან გამოსაყოფად (მაგალითად, სივრცე,
ჩანართი, ახალი ხაზი).
ანბანის სიმბოლოებიდან
ყალიბდება ენის ლექსემები:
იდენტიფიკატორები;
საკვანძო სიტყვები (რეზერვირებული) სიტყვები;
ოპერაციის ნიშნები;
მუდმივები;
განმსაზღვრელი (ფრჩხილი, წერტილი, მძიმე, უფსკრული).
ტოკენის საზღვრები განისაზღვრება სხვა ნიშნებით, მაგ
გამყოფები ან ოპერაციის ნიშნები.

იდენტიფიკატორები

იდენტიფიკატორი არის პროგრამული უზრუნველყოფის ობიექტის სახელი. IN
ლათინური იდენტიფიკატორების გამოყენება შესაძლებელია
ასოები, რიცხვები და ხაზგასმული. დიდი და
მცირე ასოები განსხვავებულია. პირველი პერსონაჟი
იდენტიფიკატორი შეიძლება იყოს ასო ან ნიშანი
ხაზგასმა. ამ შემთხვევაში:
იდენტიფიკატორი არ უნდა ემთხვეოდეს გასაღებს
გამოყენებული სტანდარტული სიტყვები და სახელები
ენის ობიექტები;
არ არის რეკომენდებული იდენტიფიკატორების სიმბოლოთი დაწყება
ხაზგასმა;
იდენტიფიკატორები შეიძლება იყოს ნებისმიერი სიგრძის, მაგრამ
შემდგენელი ითვალისწინებს არაუმეტეს 31-ე სიმბოლოს
იდენტიფიკატორის დაწყება;
იდენტიფიკატორების მაგალითები:
KOM_16, ზომა88, _MIN, TIME, დრო

საკვანძო სიტყვები

საკვანძო სიტყვები არის რეზერვირებული იდენტიფიკატორები, რომლებსაც აქვთ
შემდგენლისთვის განსაკუთრებული მნიშვნელობა. მათი გამოყენება შესაძლებელია მხოლოდ
გაგებით, რომლითაც ისინი განისაზღვრება. მოცემულია C++ საკვანძო სიტყვების სია
მაგიდა:
INT
CHAR
FLOAT
ორმაგი
STRUCT
გაერთიანება
გრძელი
მოკლე
ხელმოუწერელი
AUTO
CONST
მართალი
გარე
რეგისტრაცია
TYPEDEF
სტატიკური
GOTO
დაბრუნება
SIZEOF
BREAK
გააგრძელე
თუ
ბათილად
ახალი
სხვა
FOR
გააკეთე
სანამ
გადართვა
საქმე
ნაგულისხმევი
შესვლა
და
STRUCT
TYPEDEF
BOOL

ოპერაციის ნიშნები

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

მონაცემთა მარტივი ტიპები

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

მონაცემთა ტიპები
ტიპის დამახასიათებლები მოიცავს:
char
- სიმბოლური;
ორმაგი - რეალური ორმაგი სიზუსტის მცურავი წერტილი;
float - რეალური მცურავი წერტილი;
int - მთელი რიცხვი;
გრძელი
- მთლიანი გაზრდილი სიგრძე (გრძელი მთლიანი);
მოკლე - შემცირებული სიგრძის მთელი რიცხვი (მოკლე მთელი რიცხვი);
ხელმოწერილი - ხელმოწერილი, ე.ი. ხელმოწერილი მთელი რიცხვი (განიხილება ყველაზე მნიშვნელოვანი ბიტი
ხატოვანი);
ხელმოუწერელი - ხელმოუწერელი, ე.ი. ხელმოუწერელი მთელი რიცხვი (ყველაზე მნიშვნელოვანი ბიტი არა
მნიშვნელოვნად ითვლება);
ბათილად
- მნიშვნელობის ნაკლებობა;
bool - ლოგიკური (შეიძლება მხოლოდ ჭეშმარიტი და ყალბი მნიშვნელობების მიღება.
მცდარი მნიშვნელობის წარმოდგენის შიდა ფორმა არის 0 (ნულოვანი).
ნებისმიერი სხვა მნიშვნელობა განიმარტება როგორც ჭეშმარიტი.)
მუდმივების აღსაწერად გამოიყენეთ სერვისის სიტყვა const მანამდე
ტიპის აღწერა. მაგალითად, const float g=9.8;

10. C პროგრამის სტრუქტურა

C++ პროგრამა არის
ერთი ან მეტი ფუნქცია. ერთ-ერთი ფუნქცია
უნდა ეწოდოს main(). ეს არის ამით
ფუნქცია პროგრამა იწყებს შესრულებას და დან
ეს ფუნქცია, საჭიროებისამებრ,
სხვა ფუნქციები ეწოდება.
ფუნქციის უმარტივეს განმარტებას აქვს შემდეგი ფორმატი:
return_type name ([ პარამეტრები ])
{
განცხადებები, რომლებიც ქმნიან ფუნქციის სხეულს
}
როგორც წესი, ფუნქცია გამოიყენება ზოგიერთის გამოსათვლელად
მნიშვნელობები, ამიტომ ფუნქციის სახელს წინ უძღვის მისი ტიპი. თუ
ფუნქციამ არ უნდა დააბრუნოს მნიშვნელობა;
ამ შემთხვევაში:
– ფუნქციის სხეული ჩასმულია ხვეული ბრეკეტებით.
- ფუნქციების ჩადგმა შეუძლებელია.
– ყველა განცხადება მთავრდება მძიმით (გარდა
რთული ოპერატორი).

11. C პროგრამის სტრუქტურა

პროგრამა შეიძლება შედგებოდეს რამდენიმე მოდულისგან (წყაროს ფაილი) და, როგორც წესი,
შეიცავს წინასწარი პროცესორის დირექტივებს. პროგრამის სტრუქტურის მაგალითი, რომელიც შეიცავს
ძირითადი, f1 და f2 ფუნქციები:
წინასწარი პროცესორის დირექტივები
აღწერილობები
int main()
{
ძირითადი ფუნქციის განცხადებები
}
int f1() (
f1 ფუნქციის ოპერატორები
}
int f2() (
f2 ფუნქციის ოპერატორები
}
/* მარტივი პროგრამის მაგალითი */
#შეიცავს
int main()
{
printf ("გამარჯობა სამყარო!");
დაბრუნება 0;
}

12. C სტილის I/O ფუნქციები

ძირითადი C სტილის I/O ფუნქციები:
int scanf (const char* ფორმატი...) // შეყვანა
int printf(const char* ფორმატი...) // გამომავალი
ისინი ასრულებენ ფორმატირებულ შეყვანას და გამოტანას მნიშვნელობების თვითნებური რაოდენობის მიხედვით სტრიქონის მიხედვით
ფორმატის ფორმატი. ფორმატის სტრიქონი შეიცავს სიმბოლოებს, რომლებიც გამოტანისას კოპირდება ნაკადში (ეკრანი) ან
მოთხოვნილი იქნება ნაკადიდან (კლავიატურა) აკრეფისას და კონვერტაციის სპეციფიკაციები დაწყებული
% ნიშანი, რომელიც შეიცვლება კონკრეტული მნიშვნელობებით შეყვანისა და გამოტანის დროს.
#შეიცავს
int main() (
int i;
printf("შეიყვანეთ მთელი რიცხვი\n");
scanf("%d", &i);
printf("თქვენ შეიყვანეთ რიცხვი %d, მადლობა!", i);
დაბრუნება 0; )
ამ პროგრამის პირველი ხაზი არის წინასწარი პროცესორის დირექტივა, რომელიც ჩასმულია
სათაურის ფაილი , რომელიც შეიცავს პროგრამაში გამოყენებული შეყვანის/გამოსვლის ფუნქციების აღწერას. ყველა
წინასწარი პროცესორის დირექტივები იწყება # ნიშნით.
მესამე ხაზი არის მთელი რიცხვის ტიპის ცვლადის აღწერა, სახელად i.
printf ფუნქცია მეოთხე სტრიქონზე ბეჭდავს Enter-ის მოთხოვნას და გადადის ახალ ხაზში
გაქცევის თანმიმდევრობის მიხედვით \n.
scanf ფუნქცია ათავსებს კლავიატურიდან შეყვანილ მთელ რიცხვს i ცვლადში და იბეჭდება შემდეგი განცხადება.
აკრიფეთ მასში მითითებული სტრიქონი, ჩაანაცვლეთ კონვერტაციის სპეციფიკაცია ამ ნომრის მნიშვნელობით.

13. I/O ფუნქციონირებს C++ სტილში

იგივე პროგრამა ბიბლიოთეკის გამოყენებით
C++ კლასები :
#შეიცავს
namespace std-ის გამოყენებით;
int main()
{
int i;
კოუტ<< "Введите целое число\n";
cin >> i;
კოუტ<< "Вы ввели число" << i << ", спасибо!"; return 0;
}

14. სტანდარტული ბიბლიოთეკები

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

15. წინაპროცესორული დირექტივები

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

16. წინაპროცესორული დირექტივა # მოიცავს

ბიბლიოთეკების დასაკავშირებლად გამოიყენება
წინასწარი პროცესორის დირექტივა
# მოიცავს [ფაილის სახელი]
#შეიყვანეთ დირექტივა<имя_файла>ჩანართები
მითითებული ფაილის შინაარსი იმ მომენტში
წყაროს ფაილი, სადაც ის არის ჩაწერილი.
მაგალითად:
#შეიცავს
#include „mylib.h“

17. #define preprocessor დირექტივა

#define დირექტივა განსაზღვრავს ჩანაცვლებას ტექსტში
პროგრამები. იგი გამოიყენება დასადგენად
სიმბოლური მუდმივები.
სიმბოლური მუდმივის განსაზღვრის ფორმატი:
#define name of wildcard_text /*ყველა შემთხვევა
სახელები იცვლება შემცვლელი ტექსტით */
მაგალითები:
#განსაზღვრე M 1000
#განსაზღვრე ვასია "ვასილი ივანოვიჩი"

18. ზოგიერთი სტანდარტული ბიბლიოთეკა

ALLOC.H
მეხსიერების მართვის ფუნქციების აღწერა
(განაწილება, განაწილება და ა.შ.)
BIOS.H
გამოყენებული სხვადასხვა ფუნქციების აღწერა, როდესაც
BIOS-ის რუტინებზე წვდომა (ბაზა
შეყვანის/გამოსვლის სისტემა).
CONIO.H გამოყენებული სხვადასხვა ფუნქციების აღწერა
DOS I/O რუტინებთან წვდომა
კლავიატურები.
GRAPHICS.H შეიცავს გრაფიკული ფუნქციების პროტოტიპებს.
MATH.H შეიცავს მათემატიკური პროტოტიპების აღწერას
ფუნქციები
STDIO.H განსაზღვრავს ტიპებსა და მაკროებს, რომლებიც საჭიროა
სტანდარტული I/O პაკეტი. იგივეს განსაზღვრავს
სტანდარტული შეყვანის/გამოსვლის ნაკადები stdin, stdout და
აღწერს შეყვანის/გამოსვლის რუტინებს.
STDLIB.H აღწერს ზოგადი დანიშნულების რუტინას:
კონვერტაცია, ძებნა, დახარისხება და სხვა.
STRING.H
აღწერს სტრიქონების დამუშავების რამდენიმე რუტინას და
მეხსიერებასთან მუშაობა.

19. PRINTF ფორმატის გამომავალი ფუნქცია

ჩვენ უკვე გამოვიყენეთ ყველაზე გავრცელებული
გამომავალი ფუნქცია C-ში არის printf ქვეპროგრამა. მისი
მიზანი არის ინფორმაციის ეკრანზე ჩაწერა.
მისი ფორმატი არის მარტივი და მოქნილი:
printf(<строка формата>, <объект>, <объект>, ...);

20. SCANF ფორმატის შეყვანის ფუნქცია

ინტერაქტიული შეყვანის რეჟიმში, ის შეიძლება გამოყენებულ იქნას
უმეტეს შემთხვევაში სკანირების ფუნქცია. scanf არის შეყვანის ფუნქცია, მნიშვნელობა
printf-ის ექვივალენტი; მისი ფორმატი ასე გამოიყურება:
scanf(<строка формата>,<адрес>,<адрес>,...)
თუმცა, სკანფს აქვს ერთი ძალიან მნიშვნელოვანი განსხვავება: შემდეგი ობიექტები
ფორმატის სტრიქონი უნდა იყოს მისამართები და არა მნიშვნელობები. მაგალითად, in
პროგრამა შეიცავს შემდეგ ზარს:
scanf("%d %d", &a, &b);
ეს ზარი ეუბნება პროგრამას, რომ ის უნდა მოელოდეს თქვენგან წვდომას
ორი ათობითი (მთლიანი) რიცხვი, რომლებიც გამოყოფილია ინტერვალით; პირველი იქნება
ენიჭება a-ს, ხოლო მეორე - b. გაითვალისწინეთ, რომ აქ გამოყენებული ოპერაცია არის
მისამართები (&) a და b მისამართების გადასაცემად scanf ფუნქციას.

21. სტრიქონის ფორმატირება

ფორმატის სტრიქონი არის ხაზი, რომელიც იწყება
და მთავრდება ორმაგი ბრჭყალებით („ასე“);
printf-ის დანიშნულებაა ამ სტრიქონის ეკრანზე ჩაწერა. მანამდე
printf გამომავალი ცვლის ყველაფერს დამატებით
ჩამოთვლილი ობიექტების მიხედვით
ფორმატის სპეციფიკაციებით, რომელიც მითითებულია
თავად ხაზი. printf განცხადების მაგალითი:
printf(“ d= %f \n”,d);

22. სტრიქონის ფორმატირება

%f ფორმატის სტრიქონში არის ფორმატის სპეციფიკაცია. ყველა
ფორმატის სპეციფიკაციები იწყება პროცენტის სიმბოლოთი (%) და
(ჩვეულებრივ) თან ახლავს ერთი ასო, რომელიც მიუთითებს ტიპზე
მონაცემები და როგორ გადაიყვანოთ ისინი.
სპეციფიკაციაში გამოყენებული %f მიუთითებს იმაზე, თუ რა არის მოსალოდნელი
რაღაც რეალური რიცხვი. აქ არის რამდენიმე სხვა ხშირად გამოყენებული ფორმატის სპეციფიკაცია:
- %u ხელმოუწერელი მთელი რიცხვი
- %ld გრძელი მთელი რიცხვი
- %p მაჩვენებლის მნიშვნელობა
- %d მთელი რიცხვი
- %e არის მცურავი წერტილის რიცხვი ექსპონენციალური ფორმით
- %c სიმბოლო
- %s სტრიქონი
- %x ან %X მთელი რიცხვი თექვსმეტობით ფორმატში.

23. სტრიქონის ფორმატირება

თქვენ შეგიძლიათ დააყენოთ ველის სიგანე მისი განთავსებით
% და ასოს შორის, მაგალითად ათობითი ველი
სიგანე 4 მითითებულია როგორც %4d. ღირებულება იქნება
დაბეჭდილი გადავიდა მარჯვნივ (წინ
სივრცეები), ასე რომ, ველის მთლიანი სიგანე არის 4.
ან მაგალითად %6.2f ნიშნავს ამას
რეალური რიცხვებისთვის გამოყოფილია 6 პოზიცია,
და 2 – წილადი ნაწილისთვის.
თუ გჭირდებათ % ნიშნის დაბეჭდვა, ჩადეთ %%.

24. სტრიქონის ფორმატირება

\n სტრიქონში არ არის ფორმატის სპეციფიკაცია, მაგრამ
გამოიყენება (ისტორიული მიზეზების გამო) როგორც
გაქცევის თანმიმდევრობა და წარმოადგენს
სტრიქონში ჩასმული სპეციალური სიმბოლო. ამ შემთხვევაში
\n ჩასვამს სიმბოლოს ახალი ხაზის დასაწყისში, ასე რომ
ხაზის გამოტანის შემდეგ, კურსორი გადავა ახლის დასაწყისში
ხაზები.
- \f (ფორმატის თარგმანი ან ეკრანის გასუფთავება)
- \t (ჩანართი)
- \b (ქვემოთ<-)
- \xhhh (ჩასვით სიმბოლო ASCII კოდით hhh, სადაც hhh
შეიცავს 1-დან 3 თექვსმეტობით ციფრს)
თუ თქვენ გჭირდებათ უკანა ხაზის დაბეჭდვა მაშინ
ჩასმა \\.

25. C პროგრამის მაგალითი

#შეიცავს
#შეიცავს
მთავარი ()
{
ათწილადი x1,y1,x2,y2;
printf("შეიყვანეთ ორი ნომერი: ");
scanf("%f %f %f %f",&x1,&y1,&x2,&y2);
float d = sqrt(pow((x2-x1),2)+pow((y2-y1),2));
printf(“d= %f \n”, d);
}

26. სხვა გამომავალი ფუნქციები PUTS, PUTCHAR

არსებობს ორი სხვა გამომავალი ფუნქცია, რომელიც დაგეხმარებათ
ინტერესი: პუტჩარი. puts ფუნქცია ბეჭდავს სტრიქონს
ეკრანზე და ამთავრებს გამოსავალს ახალი ხაზის სიმბოლოთი.
მოდით შევხედოთ პროგრამის მაგალითს:
#შეიცავს
მთავარი ()
{
აყენებს ("გამარჯობა, VKI NSU-ის სტუდენტი");
}
გაითვალისწინეთ, რომ \n გამოტოვებულია ხაზის ბოლოს; ეს არ არის აუცილებელი, რადგან
აყენებს თავად ამატებს ამ ხასიათს.
პირიქით, putchar ფუნქცია წერს ერთ სიმბოლოს
ეკრანზე და არ ამატებს \n. putchar(ch) ოპერატორი ექვივალენტურია
printf("%c",ch).

27. ფუნქციები GETS, GETCH

მთავარი ()
{
char სახელი;
printf("რა გქვია:");
scanf("%s",სახელი);

}
თუ შეიყვანთ გვარს და სახელს, გამოჩნდება მხოლოდ გვარი. იმიტომ რომ
სივრცე, რომელსაც შეიყვანთ სახელის სიგნალის შემდეგ, სკანირებს შეყვანის დასასრულს
ხაზები.
ამ პრობლემის გადაჭრა შეგიძლიათ gets ფუნქციის გამოყენებით.
მთავარი ()
{
char სახელი;
printf("რა გქვია:");
იღებს (სახელი);
printf("გამარჯობა, %s\n", სახელი);
}

28. ფუნქციები GETS, GETCH

#შეიცავს
#შეიცავს
მთავარი ()
{
clrscr();
char სახელი;
printf("რა გქვია:");
იღებს (სახელი);
printf("გამარჯობა, %s\n", სახელი);
getch();
}
აქ getch ფუნქცია ელოდება რომელიმე სიმბოლოს შეყვანას.
getch ფუნქცია კითხულობს ერთ სიმბოლოს კლავიატურიდან დაბეჭდვის გარეშე
ის ეკრანზე (განსხვავებით scanf და იღებს). გაითვალისწინეთ, რომ მას არ აქვს
პარამეტრი. თუ ფუნქციას მივანიჭებთ სიმბოლურ ცვლადს, მაშინ
ის მიიღებს დაჭერილი სიმბოლოს მნიშვნელობას.
მაგალითად: c=getch();

29. დავალების ოპერაცია

ყველაზე გავრცელებული ოპერაცია არის დავალება.
მაგალითად p=a/b ან ch = getch(). C-ში
დავალება მითითებულია ერთი ნიშნით
უდრის (=); ამ შემთხვევაში მნიშვნელობა ნიშნის მარჯვნივ
თანასწორობა ენიჭება მარცხნივ ცვლადს.
ასევე შეგიძლიათ გამოიყენოთ თანმიმდევრული
დავალებები, მაგალითად: sum=a= b. ასეთებში
იმ შემთხვევებში, როდესაც დავალება შესრულებულია მარჯვნიდან
მარცხნივ, ანუ b მიენიჭება a-ს, რომელიც არის in
თავის მხრივ მიენიჭება ჯამი, ასე რომ ეს არის
სამი ცვლადი მიიღებს იგივე მნიშვნელობას (და
კერძოდ, ბ).

30. არითმეტიკული მოქმედებები. მატება. შემცირება.

C მხარს უჭერს არითმეტიკული მოქმედებების ჩვეულებრივ კომპლექტს:
- გამრავლება (*)
- გაყოფა (/)
- გაყოფის დარჩენილი ნაწილის განსაზღვრა (%)
- დამატება (+)
- გამოკლება (-)
ცვლადის მნიშვნელობის ერთით გასაზრდელად გამოიყენეთ ნამატი (++),
შემცირდეს ერთი შემცირებით (--).
ასე რომ:
x++; //ზრდის x-ს ერთით
y--; // ამცირებს y-ს ერთით
პოსტფიქსის და პრეფიქსის ოპერაციების მაგალითები:
a=2;
a=2;
x=18-2*a++;
x=18-2*(++a);
ჩვენ ვიღებთ:
a=3
a=3
x= 14
x=12

31. კომბინირებული ოპერაციები

ქვემოთ მოცემულია რამდენიმე გამონათქვამის მაგალითი
და მათი შემცირების გზები:
a = a + b; ამცირებს a += b-მდე;
a = a - b; მცირდება a -= b-მდე;
a = a * b; მცირდება a *= b-მდე;
a = a / b; შემცირდა a /= b;
a = a % b; მცირდება a %= b-მდე;

32. მაგალითი 1

გამოთვალეთ X3 და X10 ოთხი გამრავლების მოქმედების გამოყენებით
მოცემულია მთელი რიცხვი X.
#შეიცავს
int x,x2,x3,x5,x10;
მთავარი () (
printf("\n გაანგარიშების პროგრამა X^3 და X^10\n");
puts ("შეიყვანეთ მნიშვნელობა X");
scanf("%i",&x);
x2=x*x;
x3=x*x2;
x5=x2*x3;
x10=x5*x5;
printf("%i მე-3 ხარისხამდე = %i \n",x,x3);
printf("%i მე-10 ხარისხამდე = %i",x,x10);
}

33. მაგალითი 2

კუთხე მოცემულია რადიანებში. გამოთვალეთ კუთხის სინუსი და კოსინუსი.
#შეიცავს
#შეიცავს
მცურავი კუთხე, შედეგი1, შედეგი2;
მთავარი ()
{
printf("\nSin და cos კუთხის გამოთვლის პროგრამა\n");
puts("კუთხის დაყენება რადიანებში");
scanf("%f",&კუთხე);
შედეგი1=ცოდვა(კუთხე);
შედეგი2=cos(კუთხე);
printf("კუთხის სინუსი არის %f \n", შედეგი1);
printf("კუთხის კოსინუსი არის %f", შედეგი2);