პროგრამის ზოგადი სტრუქტურა. პროგრამის სტრუქტურა C ენაზე. მარტივი პროგრამის მაგალითი
C პროგრამა შედგება ერთი ან მეტი ქვეპროგრამისგან, რომელსაც ეწოდება ფუნქციები.
C ენა არის ბლოკის სტრუქტურა. თითოეული ბლოკი ჩასმულია ხვეული ბრეკეტებით ().
C კონსოლის აპლიკაციის პროგრამის მთავარი ბლოკი არის მთავარი ფუნქცია, სახელად main().
C ენაში ყოველი მოქმედება მთავრდება მძიმით - ; . მოქმედება შეიძლება იყოს ფუნქციის გამოძახება ან ზოგიერთი ოპერაციების შესრულება.
ფუნქციის სახელი არის დეკლარაციებისა და განცხადებების ჯგუფის კოლექტიური სახელი,
ჩასმული ბლოკში (ხვეული ბრეკეტები). ფუნქციის სახელის შემდეგ, ფუნქციის პარამეტრები მითითებულია ფრჩხილებში.
კომენტარები C ენაზე
C ენა იყენებს სიმბოლოებს კომენტარებისთვის
/* — კომენტარის დასაწყისი;
*/ - კომენტარის დასასრული.
ამ პერსონაჟებს შორის მთელი თანმიმდევრობა არის კომენტარი.
მოსახერხებელია წერისთვის მრავალხაზოვანი კომენტარები:
int a; /* მთელი რიცხვი
ცვლადი */
მრავალხაზოვანი კომენტარები ასევე მოსახერხებელია გამოსაყენებლად გამართვისას, რათა დამალოს კოდის ნაწილი შესრულებისგან.
გარდა ამისა, // სიმბოლოების გამოყენება შესაძლებელია მოკლე კომენტარების დასაწერად. ამ შემთხვევაში, კომენტარი არის ყველაფერი, რომელიც მდებარეობს // სიმბოლოების შემდეგ და სტრიქონის ბოლომდე:
ათწილადი ბ; // რეალური ცვლადი
მთავარი ფუნქცია
C-ზე დაწერილი კონსოლის აპლიკაციის შესრულებისას, კომპიუტერის ოპერაციული სისტემა კონტროლს გადასცემს ფუნქციას, რომელსაც ეწოდება main(). Main() ფუნქცია არ შეიძლება გამოიძახებოდეს პროგრამის სხვა ფუნქციებიდან, ეს არის საკონტროლო ფუნქცია.
ფუნქციის სახელის შემდეგ ფრჩხილები გამიზნულია იმ პარამეტრების (არგუმენტების) მითითებისთვის, რომლებიც გადაეცემა ფუნქციას მისი გამოძახებისას. ამ შემთხვევაში, ოპერაციული სისტემა არ გადასცემს რაიმე არგუმენტს main() ფუნქციას, ამიტომ არგუმენტების სია ფრჩხილებში ცარიელია.
ძირითადი ფუნქცია შეიძლება დაიწეროს სხვადასხვა გზით:
- int main()
- void main().
დაბრუნების ტიპი მითითებულია ფუნქციის სახელის წინ. როდესაც ძირითადი ფუნქცია გამოიძახება, მნიშვნელობა უბრუნდება ოპერაციულ სისტემას. ბოლო ჩანაწერი არ დააბრუნებს მნიშვნელობას. თუმცა void main()- არ არის სრულიად სწორი ჩანაწერი, რადგან ის ეუბნება შემდგენელს, რომ main() ფუნქცია არ აბრუნებს რაიმე მნიშვნელობას.
ამ შემთხვევაში ჩანაწერი int main()ეუბნება შემდგენელს დააბრუნოს ოპერაციული სისტემისთვის საჭირო მთელი მნიშვნელობა და ეუბნება, რომ პროგრამა სწორად დასრულდა. თუ ეს მნიშვნელობა არ დაბრუნდა, მაშინ ოპერაციულ სისტემას ესმის, რომ პროგრამა შეწყდა საგანგებო რეჟიმში.
მთელი რიცხვის დასაბრუნებლად, დაამატეთ ხაზი ფუნქციის დასრულებამდე
დაბრუნება 0; // რეალური ცვლადი
ხუჭუჭა ბრეკეტები აღწერებსა და განცხადებებს აერთიანებს.
ზოგადად, პროგრამა შეიძლება შეიცავდეს რამდენიმე ფუნქციას. თითოეულ ფუნქციას აქვს მასზე გადაცემული პარამეტრების სია, მითითებული ფრჩხილებში და ოპერაციების ნაკრები, ჩასმული ბლოკში, რომელიც შემოიფარგლება ხვეული ბრეკეტებით.
მაგალითი: ნაჩვენებია შეტყობინება "გამარჯობა, სამყარო!" .
1
2
3
4
5
6
7
#შეიცავს
int main() // მთავარი ფუნქცია
{
printf ("გამარჯობა, სამყარო!"); // გამომავალი შეტყობინება
getchar(); // კონსოლის ფანჯრის დაყოვნება
დაბრუნება 0;
}
პროგრამის შედეგი:
ახლა ვცადოთ ტექსტის დაწერა რუსულად.
1
2
3
4
5
6
7
#შეიცავს
int main()
{
printf( "გამარჯობა, სამყარო!");
getchar();
დაბრუნება 0;
}
პროგრამის შედეგი:
კონსოლის აპლიკაციებში რუსული ენის პრობლემა ის არის, რომ კონსოლი და Microsoft Visual Studio კოდის რედაქტორი მხარს უჭერს სხვადასხვა კოდის გვერდებს. იმისათვის, რომ იხილოთ რუსული სიმბოლოები კონსოლში, თქვენ უნდა შეცვალოთ კოდის გვერდი კონსოლში ისე, რომ იგი ემთხვეოდეს რედაქტორის კოდის გვერდს (1251). ამ მიზნით, ფუნქციური სისტემა ( "chcp 1251")შესაბამისი ბრძანების ხაზით. system() ფუნქციის პროტოტიპი შეიცავს ბიბლიოთეკაში
ამ შემთხვევაში, პროგრამის ტექსტი ასე გამოიყურება.
ბოლო განახლება: 18.05.2017
C პროგრამა შედგება წინასწარი პროცესორის დირექტივების, ფუნქციების განსაზღვრებისა და გლობალური ობიექტებისგან. წინაპროცესორის დირექტივები აკონტროლებენ ტექსტის ტრანსფორმაციას მის კომპილაციამდე. გლობალური ობიექტები განსაზღვრავს გამოყენებულ მონაცემებს ან პროგრამის მდგომარეობას. და ფუნქციები განსაზღვრავს პროგრამის ქცევას ან მოქმედებებს. უმარტივესი C პროგრამა, რომელიც წინა თემებში იყო განსაზღვრული:
#შეიცავს
ინსტრუქციები
C პროგრამის უმარტივესი სამშენებლო ბლოკი არის განცხადებები. თითოეული ინსტრუქცია ასრულებს კონკრეტულ მოქმედებას. C ენაში განცხადებებს წინ უძღვის მძიმით (;). ეს ნიშანი მიუთითებს შემდგენელზე, რომ ინსტრუქცია დასრულდა. მაგალითად:
Printf ("გამარჯობა სამყარო!");
გამოძახება printf ფუნქცია, რომელიც ბეჭდავს სტრიქონს "Hello world!" არის ინსტრუქცია და მთავრდება მძიმით.
ინსტრუქციების ნაკრები შეიძლება წარმოადგენდეს კოდის ბლოკს. კოდის ბლოკი ფორმატირებულია ხვეული ბრეკეტებით.
(printf ("გამარჯობა სამყარო!"); printf ("მშვიდობით სამყარო!");
კოდის ამ ბლოკში ორი ინსტრუქციაა. ორივე ინსტრუქცია წარმოადგენს გამოძახებას printf() ფუნქციაზე და ბეჭდავს კონკრეტულ სტრიქონს კონსოლში.
წინასწარი პროცესორის დირექტივები
ზემოთ მოყვანილ მაგალითში კონსოლში მონაცემების გამოსატანად გამოიყენება printf() ფუნქცია, მაგრამ ამ ფუნქციის გამოსაყენებლად, რათა ის ჩვენთვის ზოგადად ხელმისაწვდომი იყოს C პროგრამაში, აუცილებელია ჩართოთ stdio.h სათაური. ფაილი წყაროს კოდის ფაილის დასაწყისში ჩათვლით დირექტივის გამოყენებით.
მოიცავს დირექტივა არის წინასწარი პროცესორის დირექტივა. გარდა ამისა მოიცავს, არსებობს მთელი რიგი წინამორბედი დირექტივები, მაგალითად, განსაზღვრა.
თითოეული წინასწარი პროცესორის დირექტივა მოთავსებულია ერთ ხაზზე. და განსხვავებით ნორმალური C ენის ინსტრუქციებისგან, რომლებიც მთავრდება მძიმით;
, წინაპროცესორული დირექტივის დასრულების ნიშანი არის ახალი ხაზი. გარდა ამისა, დირექტივა უნდა დაიწყოს ფუნტის ნიშნით #.
დირექტივა "include" პირდაპირ განსაზღვრავს, რომელი ფაილი უნდა იყოს ჩართული პროგრამის ტექსტში მოცემულ ადგილას. ნაგულისხმევად, ჩვენ შეგვიძლია შევიტანოთ სტანდარტული ფაილები ეგრეთ წოდებული "header ფაილების" დირექტორიადან, რომლებიც ჩვეულებრივ მიეწოდება კომპილერის სტანდარტულ ბიბლიოთეკებს. და ფაილი "stdio.h" არის მხოლოდ ერთი ამ სათაურის ფაილებიდან.
ზოგადად, ტერმინი „სათაურის ფაილი“ თავისთავად გულისხმობს ფაილის ტექსტის ჩართვას პროგრამის დასაწყისში ან სათაურში. ამიტომ, სათაურის ფაილები ჩვეულებრივ შედის წყაროს კოდის დასაწყისში. გარდა ამისა, სათაურის ფაილი უნდა იყოს ჩართული მის მიერ განსაზღვრული ფუნქციების გამოძახებამდე. ანუ, მაგალითად, ფაილი stdio.h ინახავს printf ფუნქციის განმარტებას, ამიტომ ეს ფაილი უნდა იყოს ჩართული printf ფუნქციის გამოძახებამდე.
მაგრამ ზოგადად, წინასწარი პროცესორის დირექტივები არ უნდა განთავსდეს ფაილის დასაწყისში.
კოდი stdio.h ფაილიდან არის ჩასმული.
ნებისმიერი C პროგრამის საწყისი წერტილი არის main() ფუნქცია. სწორედ ამ ფუნქციით იწყება აპლიკაციის შესრულება. მისი სახელი main არის დაფიქსირებული და ყოველთვის ერთი და იგივეა ყველა C პროგრამისთვის.
ფუნქცია ასევე არის კოდის ბლოკი, ამიტომ მისი სხეული გარშემორტყმულია ხვეული ბრეკეტებით, რომელთა შორის არის ინსტრუქციების ნაკრები.
აღსანიშნავია, რომ ამ ფუნქციის ცვლილებები გვხვდება სხვადასხვა ლიტერატურაში და მაგალითებში. კერძოდ, ზემოაღნიშნული განმარტების ნაცვლად, შეგვიძლია სხვაგვარად დავწეროთ:
#შეიცავს
#შეიცავს
ამ განმარტებების გამოყენება არ იქნება შეცდომა და პროგრამა ასევე დაბეჭდავს სტრიქონს "Hello world" კონსოლში. და კომპილატორების უმეტესობისთვის ეს კარგი იქნება.
შემდეგ ჩვენ უფრო დეტალურად განვიხილავთ ფუნქციების განმარტებას, მაგრამ აქ უნდა გავითვალისწინოთ შემდეგი ასპექტი. ფუნქციის განმარტება სახით int main(void) დაფიქსირებულია C11 ენის სტანდარტში. შემდგენელები პირველ რიგში ყურადღებას ამახვილებენ ენის სტანდარტზე, მის სპეციფიკაციაზე. აქედან გამომდინარე, თუ გამოვიყენებთ ენის სტანდარტში მოცემულ განმარტებას, მაშინ უფრო დიდია შანსი, რომ ის იყოს მხარდაჭერილი ყველა შემდგენელის მიერ. თუმცა, კიდევ ერთხელ ვიმეორებ, მეორე ვარიანტის ან int main() გამოყენებისას დიდი შეცდომა არ იქნება.
სრული უახლესი C11 სტანდარტის ნახვა შეგიძლიათ აქ
C პროგრამებში არის გარკვეული თანმიმდევრობა:
პირველ რიგში, ჩვენ ვამატებთ ბიბლიოთეკებს, რომლებიც გვჭირდება #include თუ ფაილი არის მიმდინარე პროექტის დირექტორიაში, ის მითითებულია ბრჭყალებში. სხვა დირექტორიაში მდებარე ფაილისთვის, თქვენ უნდა მიუთითოთ სრული გზა ბრჭყალებში.
#შეიცავს
#include "math.h"
რის შემდეგაც შეგვიძლია დავამატოთ ჩვენთვის საჭირო მუდმივები #define A 3
ამის შემდეგ ფუნქცია იწყება ბრძანებით Main()
ყველაფრის დასრულების შემდეგ, შეგიძლიათ შეიყვანოთ getchar ()
2. რისთვის გამოიყენება მძიმით C ენაში?
მძიმით გამოიყენება C-ში განცხადების დასასრულის მითითება.
3. ყველა C კომპილერი მოითხოვს პროგრამაში დაბრუნების განაცხადის გამოყენებას?
მთელი რიცხვის დასაბრუნებლად, დაამატეთ ხაზი ფუნქციის დასრულებამდე
ასევე უმეტეს შემთხვევაში დაბრუნება ნიშნავს ფუნქციიდან გასვლას
ფუნქციის სხეულის განცხადებები შესრულებულია პირველი დაბრუნების დებულებამდე. თუ ფუნქციის სხეულში არ არის ასეთი ოპერატორი (ანუ ფუნქცია არ აბრუნებს რაიმე შედეგს), მაშინ შესრულებულია ყველა ოპერატორი ოპერატორის დახურვის ფრჩხილიმდე.
მასივის ელემენტების ბეჭდვის ფუნქცია არანაირ შედეგს არ აბრუნებს, ე.ი. ფუნქციის სხეულში დაბრუნების განცხადება არ არის.
4. რა მიზნით არის შეტანილი კომენტარები პროგრამის ტექსტში?
კომენტარები შეყვანილია კონკრეტული მოქმედების ასახსნელად.
მაგალითად Printf(''Hello World''); // ეკრანზე Hello World-ის ჩვენება
ასევე შეგიძლიათ შეიყვანოთ კომენტარები სიმბოლოების გამოყენებით /* - დასაწყისში */ - კომენტარის ბოლოს
5. რატომ გამოიყენება პარამეტრები ფუნქციის გამოძახებისას?
ბმული არსებითად არის იგივე ობიექტის მეორე სახელი. როდესაც ობიექტი გადაეცემა ფუნქციას მითითებით, ეს ობიექტი რეალურად გადაეცემა. როდესაც ობიექტს გადავცემთ მნიშვნელობის მიხედვით, მისი ასლი გადაეცემა ფუნქციას.
void func_1(int a) // მნიშვნელობის მიხედვით
6. ყველა ფუნქცია მოითხოვს თუ არა პარამეტრების გადაცემას გამოძახებისას?
ჩემი აზრით, საერთოდ არა ყველაფერი, რადგან ჩვენ შეგვიძლია მარტივად დავწეროთ ფუნქცია, როგორიცაა main() პარამეტრების მნიშვნელობით გადაცემის გარეშე.
1. რა არის char მონაცემთა ტიპი?
char მონაცემთა ტიპი არის მონაცემთა მთელი ტიპი, რომელიც გამოიყენება სიმბოლოების წარმოსაჩენად. ანუ, თითოეული სიმბოლო შეესაბამება დიაპაზონის გარკვეულ რიცხვს. char მონაცემთა ტიპს ასევე უწოდებენ სიმბოლოების მონაცემთა ტიპს, რადგან სიმბოლოების გრაფიკული წარმოდგენა C++-ში შესაძლებელია char-ის წყალობით. C++-ში სიმბოლოების წარმოსადგენად, char მონაცემთა ტიპს ენიჭება ერთი ბაიტი, ერთი ბაიტი შეიცავს 8 ბიტს, შემდეგ ორს ავწევთ 8-ის ხარისხზე და ვიღებთ მნიშვნელობას 256 - სიმბოლოების რაოდენობა, რომელთა დაშიფვრა შესაძლებელია. ამრიგად, char მონაცემთა ტიპის გამოყენებით, შეგიძლიათ აჩვენოთ ნებისმიერი 256 სიმბოლო. ყველა დაშიფრული სიმბოლო წარმოდგენილია ASCII ცხრილში.
2. რით განსხვავდება სიმბოლო „3“ 3 რიცხვისგან?
სიმბოლო 3 განსხვავდება მთელი რიცხვი 3-ისგან იმით, რომ სიმბოლო არ შეიძლება გამოყენებულ იქნას არითმეტიკულ ოპერაციებში
3. რა განსხვავებაა მუდმივსა და ცვლადს შორის?
განსხვავება ცვლადსა და მუდმივას შორის საკმაოდ აშკარაა: პროგრამის შესრულებისას ცვლადის მნიშვნელობა შეიძლება შეიცვალოს (მაგალითად, დავალების გამოყენებით), მაგრამ მუდმივის მნიშვნელობა არ შეიძლება.
4. როგორ განვსაზღვროთ მუდმივი?
მუდმივები C++-ში მუდმივების მსგავსია C-ში. C-ში მუდმივის წარმოსადგენად გამოყენებული იყო მხოლოდ #define preprocessor დირექტივა:
const typeVariableName = InitialValue;
მუდმივის ფარგლები იგივეა, რაც ჩვეულებრივი ცვლადის. თქვენ შეგიძლიათ გამოიყენოთ const საკვანძო სიტყვა მუდმივზე მაჩვენებლის გამოსაცხადებლად
5. აქვს თუ არა C მხარდაჭერა სიმებიანი მონაცემთა ტიპს?
C ენა არ უჭერს მხარს ცალკეული სტრიქონის მონაცემთა ტიპს, მაგრამ ის საშუალებას აძლევს სტრიქონებს განისაზღვროს ორი განსხვავებული გზით. პირველი იყენებს სიმბოლოთა მასივს, ხოლო მეორე იყენებს მაჩვენებელს მასივის პირველ სიმბოლოზე.
6. ინარჩუნებს თუ არა ცვლადი თავის მნიშვნელობას მთელი პროგრამის შესრულების განმავლობაში?
პროგრამის შესრულებისას ცვლადის მნიშვნელობა შეიძლება შეიცვალოს (მაგალითად, დავალების გამოყენებით), მაგრამ მუდმივის მნიშვნელობა არ შეიძლება.
7. როგორ შევცვალოთ მუდმივის მნიშვნელობა?
1. რა განსხვავებაა გაქცევის მიმდევრობებს შორის \n და \r?
უხეშად რომ ვთქვათ, \r უნდა აღედგინა სიმბოლოს ნომერი. დატოვებს სტრიქონის ნომერს უცვლელად (ანუ გადაიყვანს საბეჭდი მანქანის ეტლს ხაზის დასაწყისში ქაღალდის შეხების გარეშე) და \n, პირიქით, გადავა შემდეგ სტრიქონზე, უცვლელი რჩება ბეჭდვის მიმდინარე პოზიციაზე (ეს იქნება გადაახვიეთ ქაღალდი ეტლთან შეხების გარეშე).
2. როგორ გამოვაჩინოთ „ციტატის“ სიმბოლო ეკრანზე?
printf("ჩემი ტექსტი არის: \"ჩემი ტექსტი\"\n");
3. რა ორი ნაწილისგან შედგება printf() ფუნქციის პარამეტრების სია?
ნებისმიერი რიცხვის ან გამონათქვამის დაბეჭდვისას, პირველ რიგში იწერება Printf().
ფრჩხილებში, დასაწყისში ბრჭყალებში ვწერთ ჩვენთვის საჭირო მონაცემებს, კერძოდ
%с – ერთი სიმბოლო
%d – ხელმოწერილი ათობითი მთელი რიცხვი
%f – მცურავი წერტილის ნომერი (ათწილადი აღნიშვნა)
%s – სიმბოლოების სტრიქონი (სტრიქონი ცვლადებისთვის)
%u – ათობითი მთელი რიცხვი
%% - დაბეჭდეთ პროცენტის ნიშანი
მაგალითად:
printf("x=%5i\ty=%f\tz=%7.3f\n",x, y, z);
4. რა უპირატესობა აქვს printf() puts()-თან შედარებით?
5. რა არის ფორმატის მაჩვენებელი?
კითხულობს მცურავი წერტილის მნიშვნელობას (მხოლოდ C99)
იგივეა, რაც %a (მხოლოდ C99)
კითხულობს ერთ პერსონაჟს
კითხულობს ათობითი მთელ რიცხვს
კითხულობს მთელ რიცხვს ნებისმიერ ფორმატში (ათწილადი, რვადი ან თექვსმეტობითი)
იგივეა რაც %e
კითხულობს მცურავი წერტილის რიცხვს
%f კოდის მსგავსი (მხოლოდ C99)
კითხულობს მცურავი წერტილის რიცხვს
იგივეა რაც %g
კითხულობს რვა რიცხვს
კითხულობს სტრიქონს
კითხულობს თექვსმეტობით რიცხვს
იგივეა რაც კოდი %x
კითხულობს მაჩვენებელს
იღებს მთელ რიცხვს, რომელიც უდრის აქამდე წაკითხული სიმბოლოების რაოდენობას
კითხულობს ათობით მთელ რიცხვს
ათვალიერებს პერსონაჟების ერთობლიობას
კითხულობს პროცენტის ნიშანს
6. როგორ გამოვაჩინოთ რიცხვითი ცვლადის მნიშვნელობა?
მისი მნიშვნელობის დაბეჭდვა შეგიძლიათ Printf() ფუნქციის გამოყენებით
printf("%7.3f\t%7.3f\n",x,y);
%<количество_позиций_под_значение>.<количество_позиций_под_дробную_часть>ვ
%<количество_позиций_под_значение>მე
ენის შემადგენლობა ნებისმიერ ბუნებრივ ენაზე ტექსტში შეიძლება გამოიყოს ოთხი:
ძირითადი ელემენტები: სიმბოლოები, სიტყვები, ფრაზები და წინადადებები.
ალგორითმული ენა ასევე შეიცავს მსგავს ელემენტებს:
ენის ანბანი ან მისი სიმბოლოები ძირითადი განუყოფელი ნიშნებია
რომლის დახმარებითაც ენაში ყველა ტექსტი იწერება.
ლექსემა არის ენის მინიმალური ერთეული, რომელსაც აქვს დამოუკიდებელი
მნიშვნელობა.
გამოთქმა განსაზღვრავს წესს გარკვეული მნიშვნელობის გამოსათვლელად.
ოპერატორი განსაზღვრავს ზოგიერთი მოქმედების სრულ აღწერას.
რთული მოქმედების აღწერისთვის საჭიროა თანმიმდევრობა
ოპერატორები. ოპერატორები შეიძლება გაერთიანდეს ნაერთად
ოპერატორი ან ბლოკი (განიხილება ბლოკი 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
#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);
პროგრამის სტრუქტურა C ენაზე.
C პროგრამირების ენის გამოყენება ეკონომიკური პრობლემების გადაჭრაში
პროგრამები და მონაცემები
C ენის უპირატესობები
1) C არის თანამედროვე ენა, მისი სტრუქტურა ხელს უწყობს პროგრამისტს გამოიყენოს მეთოდები თავის მუშაობაში: ზემოდან ქვევით დიზაინი, სტრუქტურირებული პროგრამირება, მოდულური პროგრამის სტრუქტურა.
2) C არის ეფექტური ენა. C პროგრამები კომპაქტური და სწრაფი შესასრულებელია.
3) C – პორტატული ან მობილური ენა.
4) C არის ძლიერი და მოქნილი ენა.
5) C-ზე დაწერილი პროგრამები გამოიყენება სხვადასხვა დონეზე პრობლემების გადასაჭრელად. C-ს აქვს რამდენიმე ძლიერი ასამბლერის კონსტრუქცია.
6) C არის მოსახერხებელი ენა, ის სტრუქტურირებულია და ამავე დროს ზედმეტად არ ზღუდავს პროგრამისტების თავისუფლებას.
7) C არის კომპილაციის ტიპის ენა. იმის გამო, რომ C არის სტანდარტიზებული, ტექნიკისგან დამოუკიდებელი, ფართოდ ხელმისაწვდომი ენა, C-ში დაწერილი აპლიკაცია ხშირად შეიძლება იმუშაოს მცირედი ან ყოველგვარი მოდიფიკაციით მრავალფეროვან კომპიუტერულ სისტემაზე. კომპიუტერი, მიუხედავად მისი სიჩქარისა და გამოთვლითი სიმძლავრისა, არის მარტივი მოწყობილობა, რომელიც მანიპულირებს ორობითი რიცხვებით. ზოგიერთი ბინარული რიცხვი კომპიუტერის მიერ ინტერპრეტირებულია, როგორც ბრძანებები, ზოგიც, როგორც მონაცემები. იმისათვის, რომ კომპიუტერმა რაიმე სასარგებლო გააკეთოს, თქვენ უნდა დაწეროთ პროგრამა.
პროგრამირება – პროგრამის შემუშავების აქტივობები.
პროგრამა არის კომპიუტერულ ენაზე მითითებული პრობლემის გადაჭრის ალგორითმის აღწერა.
გუნდი – ბრძანება, რომელიც განსაზღვრავს შემდეგ ნაბიჯს.
მაგალითი გუნდები: C=A+B, სადაც A, B არის ოპერანდები, + არის ოპერაცია.
ოპერაცია - ეს არის ის, რაც კომპიუტერმა უნდა გააკეთოს თითოეული ბრძანების მიხედვით.
ოპერანდები - ოპერაციის მონაწილეები, რა და რითი კეთდება ოპერაცია. ელემენტარული ოპერაციების ნაკრები მათი აღწერის მეთოდებიდან ქმნის ბრძანებების სისტემას პროგრამირების ენაზე.
მაგალითი #1:
#შეიცავს
(void main(void) //პროგრამის ძირითადი ფუნქციის სათაური
გარეთ<< “Здравствуй, С!\ n”;
1 ხაზი: დამხმარე ბიბლიოთეკების დაკავშირება, რომლებიც ორიენტირებულია ნაკადში სხვადასხვა ტიპის მონაცემების შეყვანასა და გამოტანაზე.
მე-2 ხაზი:პროგრამის ძირითადი ფუნქციის სათაური. Cout ოპერატორი ინფორმაციის ჩვენებისთვის<< – помещение в класс данных, \n-переход к новой строке вывода.
პროგრამა არის ინსტრუქციების თანმიმდევრობა, რომელიც ახორციელებს ალგორითმს, რომელიც ცალსახად განსაზღვრავს მოქმედებების შინაარსს და თანმიმდევრობას პრობლემების გადასაჭრელად;
გამოყენება S.
1. პროგრამები და მონაცემები.
2. პროგრამის შესრულების სქემა კომპიუტერზე:
მაგალითი #1:
#შეიცავს< stdio.h>
printf ("მე ვსწავლობ BSUIR\ n");
ხაზი 1: include preprocessor ბრძანება მოიცავს stdio.h ფაილს, რომელიც აღწერს printf ბიბლიოთეკის ფუნქციას.
ხაზი 2: ფუნქციის განმარტება სახელწოდებით main, რომელიც არ იღებს არგუმენტებს. მთავარი განცხადება ჩასმულია ხვეული ბრეკეტებში. მთავარი ფუნქცია იძახებს printf ბიბლიოთეკის ფუნქციას სიმბოლოების მითითებული თანმიმდევრობის დასაბეჭდად. Slash (\n) - ახალი ხაზის სიმბოლო, გადასვლა ახალ ხაზზე.
პროგრამის PCEM-ზე შესასრულებლად, თქვენ უნდა გააკეთოთ შემდეგი:
1) შექმენით პროგრამა პროგრამირების ენაზე.
2) თარგმნეთ ამ ენის სტანდარტით.
3) დააკავშირეთ იგი საჭირო პროგრამებთან და ფუნქციებთან.
4) ჩატვირთეთ RAM-ში.
5) შეასრულეთ და მიიღეთ შედეგი.
დასრულების სქემა
მთარგმნელი არის კომპიუტერული პროგრამა პროგრამირების ენაზე დაწერილი პროგრამის კომპიუტერისთვის გასაგებ ფორმაში გადასათარგმნად. შემდგენელის გამომავალი არის ფაილი გაფართოებით obj. შესრულებადი ფაილი ან ჩატვირთვის მოდული არის ფაილი, რომელიც შეიცავს პროგრამას, რომელიც შედგენილია და მზად არის შესასრულებლად. Borland C++ არის პროგრამის განვითარების გარემო, რომელიც მოიცავს როგორც შემდგენელს, ასევე სხვა ინსტრუმენტებს.
პროგრამის სტრუქტურა C ენაზე.
ნებისმიერი C პროგრამა შედგება ერთი ან მეტი ფუნქციისა და ელემენტისგან. სხვადასხვა ფუნქციებს შეიძლება მიენიჭოთ ნებისმიერი სახელი. ფუნქციები შეიცავს ინსტრუქციებს (ბრძანებებს), რომლებიც განსაზღვრავენ მოქმედებებს შესრულების კონკრეტულ ეტაპზე და ცვლადი ინახავს ამ მოქმედებების დროს გამოყენებულ მნიშვნელობებს. ასეთი ქმედებები შეიძლება იყოს ცვლადებისთვის მნიშვნელობების მინიჭება ან რაიმე მდგომარეობის შემოწმება. ფუნქცია სახელად main. ნებისმიერი პროგრამის შესრულება იწყება მთავარი ფუნქციით.
ა) C პროგრამის ზოგადი სტრუქტურა ქვეპროგრამის გამოყენების გარეშე:
ბ) C პროგრამის ზოგადი სტრუქტურა ქვეპროგრამის მითითებით:
არგუმენტები ფუნქციებს შორის ურთიერთქმედების ერთ-ერთი მექანიზმია. არგუმენტების სია ფრჩხილებში მიჰყვება ფუნქციის სახელს. ხვეული ბრეკეტები აღნიშნავს პროგრამის დასაწყისს და დასასრულს. ინსტრუქციები, რომლებიც ქმნიან ოპერატორებისა და ოპერანდების პროგრამულ სხეულს. C-ში, ყველა განცხადება და ფუნქციის გამოძახების ყველა ხაზი მთავრდება მძიმით. გამონაკლისი არის წინასწარი პროცესორის ბრძანებები და ფუნქციების სახელები პროგრამის ერთეულის დასაწყისში. პროგრამების უმეტესობის მიზანია პრობლემის გადაჭრა წყაროს მონაცემების სხვადასხვა ტრანსფორმაციის გზით. ამისთვის აუცილებელია.