გაკვეთილის ტიპი:

• საგანმანათლებლო სტუდენტები ეცნობიან ახალ პასკალ ოპერატორს;
• თემის გამეორება " შინაგანი მეხსიერებაკომპიუტერი";
• შეძენილი ცოდნის კონსოლიდაცია.

გაკვეთილის თემა:„პროგრამირება პასკალში. დავალების ოპერატორი“.

მიზნები:

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

გაკვეთილის ხანგრძლივობა: 1 საათი 30 წუთი.

გაკვეთილების დროს

Პირველი გაკვეთილი

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

2. მასწავლებელი ხსნის ახალ თემას მულტიმედიური საპრეზენტაციო გაკვეთილის „პროგრამირება პასკალში. დავალების ოპერატორი“. მოცემულია ცნების „დავალების ოპერატორი“ განმარტება და მოცემულია ოპერატორის ზოგადი და სტრუქტურული ფორმა. სანამ დავალების ოპერატორის მოქმედებას განვიხილავთ, გავიხსენოთ და გავიმეოროთ თემა „შემთხვევითი მეხსიერება, თვისებები. შემთხვევითი წვდომის მეხსიერება». თან ახლავს პრეზენტაცია. დანართი 1 (15 წუთი).

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

მეორე გაკვეთილი

4. მოსწავლეები მუშაობენ დაფაზე და აკეთებენ სავარჯიშოებს (12-15 წუთი).

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

5. მოსწავლეები აკეთებენ პატარა დამოუკიდებელ მუშაობას ბარათებზე, ან წერენ და ასწორებენ პროგრამას ALP Pascal-ში, რომელიც იყენებს დავალების ოპერატორ(ებ)ს (მასწავლებელი ურეკავს ბარათების ნომრებს ამოცანებით). მოსწავლეები იღებენ შეფასებას თავიანთი სამუშაოსთვის. დანართი 3 . დანართი 4(15 წუთი).

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

დასკვნები:

• 1 ბლოკის საშუალებით გაიმეორეთ წინა გაკვეთილის თემა.
• მე-2, მე-3 და მე-4 ბლოკების მეშვეობით შემოტანილია და განმტკიცებულია ახალი თემა „დავალებების ოპერატორი“.
• მე-5 და მე-6 ბლოკების მეშვეობით ხდება ცოდნის კონტროლი.

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

გაკვეთილი No1 (2 საათი). ცვლადები და მუდმივები. დავალების ოპერატორი

1. საშინაო დავალების შემოწმება.
2. Ახალი თემა.
3. Საშინაო დავალება.

საშინაო დავალების შემოწმება.

2. ახალი თემა: „ცვლადები და მუდმივები. დავალების ოპერატორი"

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

ცვლადის სახელი:= გამოხატულება;

გამოხატულება შეიძლება იყოს კონკრეტული მნიშვნელობა (ანუ მთელი რიცხვი ან რეალური რიცხვი, მაგალითად, 22 ან 2.5, სიმბოლური მნიშვნელობა: "ABC", ლოგიკური მნიშვნელობა: TRUE ან FALSE) და ზოგიერთი გამოხატულება (მნიშვნელობები + ოპერაციები მათზე. ), რომლის შედეგი მიენიჭება მარცხენა მხარეს მდებარე ცვლადს.

მაგალითები:

PAG:= 10;(სპეციფიკური მნიშვნელობა, როგორც რიცხვი);
X:= X + 1;(გამოხატვა);
C:=B;(ცვლადის სახელი);
G:= 'HELLO'; (კონკრეტული მნიშვნელობა სიმბოლურია);
X:= (-A + SIN(Y) – 4 * B * X) / (2 * C);(მათემატიკური გამოთქმა);
Y:= TRUE;(სპეციფიკური ლოგიკური მნიშვნელობა).

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

მათემატიკაში გამოთქმა = b ნიშნავს, რომ გამოთვლილი მნიშვნელობები a და b უნდა იყოს ტოლი.
პროგრამირებისას A:=B ნიშნავს, რომ B მეხსიერების მდებარეობაში შენახული მნიშვნელობა მოთავსებულია მეხსიერების ადგილას სახელად A. ამიტომ, შებრუნებული გამოხატულება
B:= A იძლევა განსხვავებულ შედეგს.
მაგალითი: მნიშვნელობები 5 და 9 მოთავსებულია A და B-ში, შესაბამისად.

A: = 5;
B: = 9

ა) ოპერაციის შედეგი A:= B;

ბ) ოპერაციის შედეგი B:= A;

აქ არის კიდევ ერთი მნიშვნელოვანი განსხვავება ტოლობის ნიშანსა და დავალების ოპერატორს შორის: A = A + 1;
მათემატიკაში ასეთი გამოთქმა უბრალოდ უაზროა, რადგან იდენტურობა ყალბია. არ არსებობს A-ს რიცხვითი მნიშვნელობები, რომლებისთვისაც ეს სიმართლე იქნებოდა. პროგრამირებისას ეს ნიშნავს, რომ A უჯრედში შენახულ მნიშვნელობას ემატება 1 და ახლად მიღებული მნიშვნელობა ცვლის ძველს A უჯრედში. მაგალითად, თუ ამ განცხადების შესრულებამდე A-ს ჰქონდა მნიშვნელობა 5, მაშინ მისი შესრულების შემდეგ. იქნება 6-ის ტოლი.

შემდეგი განსხვავება: მათემატიკური გამოსახულება A + 9 – B = X საკმაოდ გონივრულია და შეიძლება ნიშნავს, რომ როდესაც თქვენ ჩაანაცვლებთ რამდენიმე რიცხვს A და B-ის ნაცვლად გამოსახულების მარცხენა მხარეს, მიიღებთ H. ამავე დროს, ამ გამოთქმის პროგრამირება უაზროა, რადგან გამონათქვამის მარცხენა მხარე უნდა შეიცავდეს მეხსიერების არეალის სახელს, რომელსაც ენიჭება მარჯვენა მხარეს გამოთვლილი მნიშვნელობა. თუ თქვენ ცდილობთ ასეთი გამონათქვამის ჩასმას თქვენს პროგრამაში, მიიღებთ შეცდომის შეტყობინებას, რადგან ცვლადის სახელია A + 9 – B. ვერ გაიგებს.

ჩაწერეთ სტანდარტული ფორმით:

(– b + sqrt(sqr(b) – 4 * a * c))/(2 * a);
a/b * (c + d) – (a – b)/b/c + 1E – 8;

ბიბლიოგრაფია:

• ვ.ბ. პოპოვი"TURBO PASCAL სკოლის მოსწავლეებისთვის", "ფინანსები და სტატისტიკა", მოსკოვი, 1996 წ.
• ᲐᲐ. ჩერნო "კომპიუტერული მეცნიერების გაკვეთილების შენიშვნები 9-11 კლასებში", "მასწავლებელი", ვოლგოგრადი, 2004 წ.
• დ.მ. ზლატოპოლსკი”მე მივდივარ კომპიუტერული მეცნიერების გაკვეთილზე. პროგრამირების ამოცანები, 7 - 11 კლასები, "პირველი სექტემბერი", მოსკოვი, 2001 წ.

ოპერატორი- ბრძანება კონკრეტული მოქმედებების შესასრულებლად. პასკალის პროგრამირების ენა შეიცავს 11 ოპერატორს.

დავალების ოპერატორი პასკალში

დავალების ოპერატორი არის ყველაზე ხშირად გამოყენებული ოპერატორი Turbo Pascal ენაში.

ჩაწერის ფორმატი: X:=A;
სად: X– ცვლადის სახელი;
A-გამოხატულება ;
:= - დავალების ნიშანი.

ოპერატორის სამუშაო:ოპერატორის შესრულებისას გამოითვლება გამოთქმის მარჯვენა მხარეს არსებული მნიშვნელობა და ენიჭება ცვლადის სახელს.

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

მაგალითი 9.1.დაწერეთ პროგრამა ფუნქციების გამოსათვლელად:

y=cosa+lnb; n=k+1; r=ord (#65).

ვარ
a, b, y: რეალური;
k, n: მთელი რიცხვი;
r:char;
t, v, u: ლოგიკური;
* * *
y:= cos(a)+ln(b);
n:=k+1;
r:=ord(#65);
t:=(v და u) ან (v და არა u);
* * *
Დასასრული.

გარდამავალი ოპერატორი პასკალში

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

ჩაწერის ფორმატი: GoTo m;

სად: Წადი- წადი;
მ-ეტიკეტი

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

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

მინიჭების ოპერატორი უმარტივესი და ყველაზე გავრცელებული ოპერატორია.

დავალების ოპერატორის ფორმატი

დავალების ოპერატორი არის ჩანაწერი, რომელიც შეიცავს = (ტოლობის ნიშანი) სიმბოლოს, ცვლადის სახელით მარცხენა მხარეს და გამოხატულება მარჯვენა მხარეს. დავალების ოპერატორი მთავრდება ნიშნით; (წერტილი).

ცვლადი = გამოხატულება ; // დავალების ოპერატორი

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

დავალების ოპერატორის შესრულების წესი

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

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

მინიჭების ოპერატორში შესაძლებელია გამოაცხადოთ ცვლადის ტიპი ტოლობის ნიშნის მარცხნივ:

int In = 3;
ორმაგი Do = 2.0;
bool Bo = მართალია;
ფერი Co = 0 x008000; // ცვლად Co-ს ენიჭება მუდმივის მნიშვნელობა
string St = "sss"; // ცვლადს St ენიჭება მუდმივის მნიშვნელობა
თარიღი Da = D "01/01/2004"; // ცვლად Da-ს ენიჭება მუდმივის მნიშვნელობა

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

In = 7; // ცვლად In-ს ენიჭება მუდმივის მნიშვნელობა
Do = 23.5; // ცვლადს Do ენიჭება მუდმივის მნიშვნელობა
Bo = 0; // ცვლადს Bo ენიჭება მუდმივის მნიშვნელობა

მინიჭების ოპერატორში ცვლადის ტიპის დეკლარაცია ტოლობის ნიშნის მარჯვენა მხარეს დაუშვებელია:

In = int In_2; // მარჯვენა მხარეს ცვლადების ტიპის გამოცხადება აკრძალულია
Do = ორმაგი Do_2; // მარჯვენა მხარეს ცვლადების ტიპის გამოცხადება აკრძალულია

მინიჭების ოპერატორი არ იძლევა ცვლადების ტიპის ხელახლა დეკლარირებას.

Int In; // ცვლადის ტიპის დეკლარაცია In
int In = In_2; // ცვლადის ხელახალი გამოცხადება (In) დაუშვებელია

მორგებული და სტანდარტული ფუნქციების გამოყენების მაგალითები მარჯვენა მხარეს:

In = My_Function () ; // In ენიჭება მომხმარებლის მნიშვნელობა. ფუნქციები
Do = Gipo(Do1, Do1); // Do ენიჭება მომხმარებლის მნიშვნელობა. ფუნქციები
Bo = IsConnected () ; // Bo დაყენებულია სტანდარტზე. ფუნქციები
St = ობიექტის სახელი (0); // St დაყენებულია სტანდარტზე. ფუნქციები
Da = TimeCurrent(); // და დაყენებულია სტანდარტზე. ფუნქციები

გამოყენების მაგალითები გამონათქვამების მარჯვენა მხარეს:

In = (My_Function() + In2) / 2; // ენიჭება ცვლადს In
// ..გამოხატვის მნიშვნელობა
Do = MathAbs (Do1 + Gipo (Do2, 5) + 2.5); // ენიჭება ცვლადს Do
// ..გამოხატვის მნიშვნელობა

მინიჭების ოპერატორში გამოთვლების შესრულებისას გამოიყენება მონაცემების ტიპების ჩამოსხმის წესები (იხ. Type casting).

მოკლე ფორმის მინიჭების ოპერატორების მაგალითები

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

In /= 33;
In = In / 33;

St += "_exp7"; // მინიჭების ოპერატორის მოკლე ფორმა
St = St + "_exp7"; // დავალების ოპერატორის სრული ფორმა

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

განვიხილოთ რამდენიმე ცვლადი M და N, რომლებსაც აქვთ გარკვეული მნიშვნელობები, მაგალითად, M = 12, N = 34. თითოეულ ამ მნიშვნელობებს კომპიუტერი გამოყოფს მეხსიერების ცალკეულ განყოფილებას, რომელიც არის უჯრედების ან ბიტების გარკვეული რაოდენობა (1 უჯრედი). = 1 ბიტი). მრავალი რიცხვის (ან სხვა ტიპის მონაცემების) შენახვა შეუძლებელია იმავე მეხსიერების ადგილას იმავე მიზეზით, რომ ორი ლიტრი წყალი არ შეიძლება იყოს ერთ ლიტრიან ქილაში.

ძალიან ხშირად ხდება საჭირო M ცვლადის მნიშვნელობის ამოღება, რომელიც არის 12, და ამის ნაცვლად ცვლადის N მნიშვნელობის ტოლი გახდება, ანუ 34. რას აკეთებს კომპიუტერი? ის პოულობს მეხსიერების ადგილს, სადაც N-ის მნიშვნელობა არის „დამალული“, აკოპირებს მას (რიცხვი 34), უბრუნდება შენახვის ადგილს M (უდრის 12-ს), წაშლის მის მნიშვნელობას და ჩასვამს ახალს, ანუ 34. როგორც. შედეგად, M = 12 გადაიქცა M = 34-ად.

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

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

დავალება.მოცემული რიცხვები: M = 12, N = 34. შეცვალეთ მათი მნიშვნელობები.

M რიცხვს უნდა მივაკუთვნოთ 34, ხოლო N რიცხვს 12 (პირიქით). ძალიან ხშირად, დამწყები პროგრამისტები ასე წერენ:

კოდის პირველ სტრიქონში M ენიჭება N-ს, ანუ M:= 34. მეორე სტრიქონში N ენიჭება M-ს, მაგრამ ბოლო ცვლადი აღარ არის 12-ის ტოლი, რადგან მან შეცვალა მნიშვნელობა წინა სტრიქონი 34-მდე. ამიტომ ორივე ცვლადი იქნება 34-ის ტოლი. დემონსტრირებისთვის მოდით დავწეროთ სრული კოდი, რომელიც უნდა გადაწეროთ PascalABC.Net პროგრამირების გარემოში:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ვარ M, N: ტიპი მთელი რიცხვი; აღწერა: ")" onmouseout="toolTip()">მთელი რიცხვი; დაიწყოსდავწერე ( "შეიყვანეთ ნომრები M და N:" <-- вводим 12 } write (" N = " ) ; readln (N) ; { <-- вводим 34 } M := N; { <== M присваивается N, поэтому M = 34 } N := M; { <== N присваивается M, поэтому N = 34 } დასასრული.

გაუშვით პროგრამა შესასრულებლად; როდესაც მოგეთხოვებათ M შეიყვანეთ 12, N-სთვის შეიყვანეთ 34 და დააჭირეთ Enter. თუ ყველაფერი სწორად გაკეთდა, უნდა ნახოთ:

შეიყვანეთ ნომრები M და N:
M=12
N=34
შედეგი:
M = 34 N = 34

როგორც ბოლო სტრიქონიდან ხედავთ, ეს არ არის ის, რაც ჩვენ გვინდოდა - შევცვალოთ M და N-ის მნიშვნელობები.

სწორი შედეგის მისაღწევად, თქვენ უნდა დააფიქსიროთ M ცვლადის საწყისი მნიშვნელობა, მაგალითად, s:= M („დაიმახსოვრეთ“ M მისი მნიშვნელობის s ცვლადზე ჩაწერით). შედეგად, N რიცხვს მივანიჭებთ არა M ცვლადის მნიშვნელობას, რომელიც უკვე შეიცვალა, არამედ გამოვიყენებთ მის ტოლ მნიშვნელობას:

უახლესი ცვლილებების შესაბამისად, წინა პროგრამა მიიღებს ფორმას:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ვარ M, N, s: ტიპი მთელი რიცხვი; აღწერა: წარმოადგენს 32-ბიტიან ხელმოწერილ მთელ რიცხვს. ღირებულების დიაპაზონი: -2 147 483 648 .. 2 147 483 647")" onmouseout="toolTip()">მთელი რიცხვი; დაიწყოსდავწერე ( "შეიყვანეთ ნომრები M და N:") ; write("M ="); readln(M); (<-- вводим 12 } write (" N = " ) ; readln (N) ; { <-- вводим 34 } s := M; { <== запоминаем M, равное 12 } M := N; (M = 34, რადგან N = 34) N := s; ( N = 12 რადგან s = 12 ) writeln("შედეგი:"); writeln(" M = ", M, " N = ", N); წაკითხული დასასრული.

გადაწერეთ ეს პროგრამა PascalABC.Net-ში და გაუშვით (კლავიატურაზე ღილაკი F9). თუ პასუხი ასეთია:

შეიყვანეთ ნომრები M და N:
M=12
N=34
შედეგი:
M = 34 N = 12

მაშინ პროგრამა მუშაობს სწორად. როგორც ბოლო სტრიქონიდან ჩანს, M და N რიცხვების მნიშვნელობებმა შეცვალეს ადგილები.

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

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

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

კომპლექტი<целевая_переменная> <выражение>

ეს ჩანაწერი ფუნქციის გამოძახების ტოლფასია. ანალოგიურად, ძველი სტილის COBOL-ში:

გაამრავლე 2 2-ზე და მიეცი ოთხი.

მუშაობის ალგორითმი

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

Დანიშნულება

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

ცნობილი ცუდი მაგალითია თანაბარი ნიშნის არჩევა დავალების აღსანიშნავად, რომელიც თარიღდება 1957 წელს Fortran-ით და დღესაც ბრმად იმეორებს მრავალი ენის შემქმნელის მიერ. ეს ცუდი იდეა არღვევს = ნიშნის გამოყენების მრავალსაუკუნოვან ტრადიციას თანასწორობის შედარების აღსანიშნავად, პრედიკატი, რომელიც იღებს მნიშვნელობებს „ჭეშმარიტი“ ან „მცდარი“. მაგრამ Fortran-ში ეს სიმბოლო ნიშნავდა დავალებას, აიძულებს თანასწორობას. ამ შემთხვევაში ოპერანდები არათანაბარ მდგომარეობაშია: მარცხენა ოპერანდი, ცვლადი, უნდა იყოს ტოლი მარჯვენა ოპერანდის, გამოხატვის. ამიტომ x = y არ ნიშნავს იგივეს, რაც y = x.

ორიგინალური ტექსტი (ინგლისური)

ცუდი იდეის ცნობილი მაგალითი იყო ტოლობის ნიშნის არჩევა დავალების აღსანიშნავად. იგი ბრუნდება 1957 წელს Fortran-ში და ბრმად იქნა კოპირებული ენის დიზაინერების არმიის მიერ. რატომ არის ცუდი იდეა? იმის გამო, რომ ეს არღვევს საუკუნოვან ტრადიციას, რომ "=" აღნიშნავს თანასწორობის შედარებას, პრედიკატს, რომელიც არის ჭეშმარიტი ან მცდარი. მაგრამ ფორტრანმა ეს ნიშნავს დავალებას, თანასწორობის აღსრულებას. ამ შემთხვევაში, ოპერანდები არათანაბარ მდგომარეობაშია: მარცხენა ოპერანდი (ცვლადი) უნდა იყოს ტოლი მარჯვენა ოპერანდის (გამოხატვა). x = y არ ნიშნავს იგივეს, რაც y = x.

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

თანასწორობის ოპერატორის სიმბოლოს არჩევა ენაში = დავალების გამოყენებისას მოგვარებულია:

• თანასწორობის ოპერატორის ახალი ენის სიმბოლოს შემოღებით.

A = B = C

A ცვლადს ენიჭება B = C მიმართების ლოგიკური მნიშვნელობა. ეს აღნიშვნა იწვევს წაკითხვის შემცირებას და იშვიათად გამოიყენება.

სემანტიკური მახასიათებლები

დავალების ინტერპრეტაციის „ინტუიციური“ (იმპერატიული ენების პროგრამისტებისთვის) გზა ყოველთვის არ არის ერთადერთი სწორი და შესაძლებელი.

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

A = b = a a = 1000

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

ოპერაციის ჩანაცვლება

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

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

გაფართოებული დიზაინები

დავალების კონსტრუქციები პროგრამირების სხვადასხვა ენაზე

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

მრავალი სამიზნე

მარტივი ოპერატორის ერთ-ერთი ალტერნატივა არის გამოხატვის მნიშვნელობის მინიჭების შესაძლებლობა მრავალ ობიექტზე. მაგალითად, PL/1 ენაზე ოპერატორი

ჯამი, სულ = 0

SUM და TOTAL ცვლადებს ერთდროულად ანიჭებს ნულს. Ada ენაზე დავალება ასევე არის ოპერატორი და არა გამოხატულება, ამიტომ მრავალჯერადი დავალების აღნიშვნა არის:

ჯამი, სულ: მთელი რიცხვი:= 0;

Python-ში მსგავს დავალებას აქვს შემდეგი სინტაქსი:

ჯამი = ჯამი = 0

განსხვავებით PL/1, Ada-სა და Python-ისგან, სადაც მრავალჯერადი მინიჭება განიხილება მხოლოდ ნოტაციის შემცირებულ ფორმად, C, Lisp და სხვა ენებში ამ სინტაქსს აქვს მკაცრი საფუძველი: დავალების ოპერატორი უბრალოდ აბრუნებს მათთვის მინიჭებულ მნიშვნელობას (იხ. ზემოთ. ). ასე რომ, ბოლო მაგალითი რეალურად არის:

ჯამი = (სულ = 0)

ასეთი ხაზი იმუშავებს C-ში (თუ ბოლოში დაამატებთ მძიმით), მაგრამ გამოიწვევს შეცდომას Python-ში.

პარალელური დავალება

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

a ||= 10

ეს კონსტრუქცია ანიჭებს მნიშვნელობას a ცვლადს მხოლოდ იმ შემთხვევაში, თუ მნიშვნელობა ჯერ არ არის მინიჭებული ან უდრის false-ს.

რთული ოპერატორები

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