| DL1MP1K | Date: ხუთშაბათი, 2012-02-09, 7:45 PM | Message # 1 |
|
Lieutenant colonel
Group: VIP
Messages: 77
Awards: 0
Reputation: 1
Status: გასული
| ჩვენს წინა ლექციაში ვისწავლეთ ფუნქციის განსაზღვრისა და მისი გამოძახების წესები, ავღნიშნეთ აგრეთვე ისიც, თუ რას წარმოადგენს ფუნქციის ბოლოში დასმული ფრჩხილები ( ). კერძოდ კი ის რომ ამ ფრჩხილებში შესაძლებელია განვსაზღვროთ ცვლადები, რომელთაც ვუწოდებთ პარამეტრებს. ამ ფრჩხილებში განსაზღვრული ცვლადები, ანუ ფუნქციის პარამეტრები მოქმედებენ მხოლოდ ფუნქციის არეში, ანუ მათ ფუნქციის გარეთ არავითარი დანიშნულება არ გააჩნიათ.
ის მნიშვნელობები, რომლებიც ფუნქციის გამოძახებისას ამ პარამეტრებს გადეცემათ, ეწოდებათ არგუმენტები. მათ ზოგიერთი პროგრამისტი ასევე პარამეტრს უწოდებს.
ახლა შევხედოთ ჩვენს წინა მაგალითს, სადაც შემოვიტანეთ ფუნქცია misalmeba(), რომელიც ერთ მარტივ ტექსტურ ჩანაწერს შიცავს.
void misalmeba()
{
cout << "gamarjobaT xalxooo!" << endl;
}
ახლა წარმოვიდგინოთ, რომ ჩვენს ამ მისალმების ფუნქციაში გვინდა ეს მისალმება თითოეულ კონკრეტულ პიროვნებას მივმართოთ. შემოვიტანოთ პარამეტრი saxeli, რომელიც უნდა string ტიპისა უნდა იყოს. მის განსაზღვრას ვახდენთ ზუსტად ამ მისალმების ფუნქციის ფრჩხილებში.
void misalmeba (string saxeli)
{
cout << "gamarjobaT xalxoo!" << endl;
}
ახლა შევეცადოთ ჩვენი პარამეტრის გამოყენებას, ისე რომ მან ანუ პარამეტრმა გადმოგვცეს ჩვენთვის სასურველი სახელი;
void misalmeba( string saxeli)
{
cout <<"gamarjoba" << saxeli << " ! " << endl;
}
ახლა კი გამოვიძახოთ ფუნქცია თავისივე არგუმენტით;
int main()
{
....................
misalmeba("xinkala");
....................
misalmeba("kaxfonso");
....................
ამ შემთხვევაში ყველაზე მნიშვნელოვანი არის ის, რომ არგუმენტის ტიპაჟი უნდა იგივე იყოს, რაც პარამეტრის ტიპაჟია, ჩვენს შემთხვევაში string.
არგუმენტების სახით შესაძლებელია პარამეტრს გადავცეთ, როგორც ცვლადები, ასევე კონსტანტები, მაგრამ როდესაც ვახდენთ ცვლადების გადაცემას, აქ ისმება კითხვა, თუ როგორ გადაეცემიან ეს ცვლადები თვით ფუნქციას.
ერთი შესაძლებლობა ამისა არის ის, რომ ეს ცვლადები ფუნქციაში აისახოს, როგორც ფუნქციის შიგნით განსაზღვრული ცვლადები. ამ შემთხვევაში პარამეტრები და ცვლადები იდენტურნი იქნებიან და ფუნქციას ექნება შესაძლებლობა ცვლადების მნიშვნელობები ასე ვთქვათ პარამეტრების გავლით შეცვალოს. ამ გადაცემის ხერხს პროგრამირებაში call by reference ეწოდება.
რაც შეეხება მეორე ხერხს, რომელსაც call by value ქვია, აქ პარამეტრები არგუმენტის კოპირებით ინიციალიზირდებიან. ეს ნიშნავს რომ ფუნქციის გამოძახებისას ცვლასდების მნიშვნელობები პარამეტრბში კოპირების სახით გადადიან. ამ შემთხვევაში შესაძლებელია პარამეტრის მნიშვნელობის ისე შეცვლა, რომ ცვლადის მნიშვნელობა ფუნქციაში არ შეიცვალოს. სწორედ ეს მეორე ხერხი გვაქვს ჩვენს მაგალითში გამოყენებული.
სხვა და სხვა პარამეტრები
აქამდე საქმე გვქონდა ფუნქციაში მხოლოდ ერთ პარამეტრთან, მაგრამ ფუნქციას შეუძლია აგრეთვე ბევრი პარამეტრების აღება. ამ შემთხვევაშიც ყველა პარამეტრი თავსდება ფუნქციის ფრჩხილებში ( ), და მათ შორის გამყოფია მხოლოდ მძიმე, ,
void demo(string paramtri1, int parametri2, int parametri3)
{
პროგრამის კოდი
}
ფუნქციის გამოძახებისას პარამეტრებს შესატყვისი ტიპაჟის არგუმენტები გადაეცემიან
demo("ტექსტი", 12, 4940);
ასეთი მარტივი ხერხით ხდება პარამეტრებზე მნიშვნელობის გადაცემა, ასევე მარტივად ხდება ფუნქციიდან ამ მნიშვნელობების გამოძახებაც.
აქ მოვიყვანთ ერთ მარტივ მაგალითს, რომელიც რიცხვის კვადრატს ანგარიშობს:
void kvadrati (int ricxvi);
{
long kvadrati;
kvadrati = ricxvi * ricxvi;
cout << kvadrati << endl;
}
გამოძახება ხდება ასეთი სახით:
int mniSvneloba = 12;
kvadrati (mniSvneloba); // გადმოიცემა: 144
აქმდე ვიხილავდით ყოველთვის ფუნქციას და არ ვფიქრობდით მისი მნიშვნელობის გადმოცემაზე, ამიტომ ვიყენებდით აღნიშვნას void. დავუშვათ ახლა, რომ გვჭირდება ფუნქციის მნიშვნელობის პირდაპირი გადმოცემა, ამისათვის როგორც ვიცით ფუნქციას განსაზღვერისას უნდა სახელის წინ მივუთითოთ ტიპაჟის სახეობა. შევხედოთ ამ მაგალითს:
long kvadrati (int ricxvi);
{
long kvadrati;
kvadrati = ricxvi * ricxvi;
cout << kvadrati << endl;
}
შედეგის მნიშვნელობის გადმოცემას ვახდენთ return ბრძანებით
long kvadrati (int ricxvi);
{
long kvadrati;
kvadrati = ricxvi * ricxvi;
return kvadrati;
}
ფუნქციის გამოძახებისას კი შემოგვაქვს ცვლადები, როგორც მნიშვნელობისათვის, ასევე შედეგისათვის.
int mniSvneloba = 12;
long Sedegi;
Sedegi = kvadrati(mniSvneloba);
cout << Sedegi << endl;
შედეგად ამ შემთხვევაშიც მივიღებთ 144-ს.
გლობალური და ლოკალური ცვლადები
აქამდის ჩვენ ლაპარაკი გვქონდა მხოლოდ იმ ცვლადებზე, რომლებსაც ვსაზღვრავდით ფუნქციის ბლოკში, ანუ იქ სადაც იხსნება ამ ფრჩხილით { და მთაცრდება ამით } . ასეთ მონაკვეთს ვუწოდებთ ფუნქციის ბლოკს. ამ ბლოკში განსაზღვრულ ცვლადებზე ზემოქმედება შესაძლებელია მხოოოდ ფუნქციის ბლოკში, ან ფუნქციის პარამეტრების საშუალებით. ასეთ ცვლადებს უწოდებენ ლოკალურ ცვლადებს.
თუ ჩვენ ცვლადებს ფუნქციის გარეთ განვსაზღვრავთ, მაშინ ისინი მიიღებენ ფართო დანიშნულებას და შესაძლებელია მათი გამოყენება პროგრამის მთლიან კოდში. ასეთი სახის ცვლადევს უწოდებენ გლობალურ ცვლადებს
ჩვენ ახლა შემოგთავაზებთ ერთ მარტივ მაგალითს საიდანაც ადვილად მიხვდებით ამ ორი ცვლადის განსაზღვრის და მათი გამოძახების, უფრო ზუსტად მათი მოქმედების სფეროს წესებს.
#include < iostream >
using namespace std;
int globCvladi = 1;
void funkcia()
{
globCvladi = 33;
}
int main()
{
cout << globCvladi << endl; // გადმოიცემა = 1
funkcia();
cout << globCvladi << endl; // გადმოიცემა = 33
return 0;
}
ნათლად ჩანს ის რაზედაც ზემოთ გვქონდა საუბარი, კერძოდ ერთი და იგივე ცვლადი განვსაზღვრეთ ორ ადგილზე, ერთი თავში, ანუ ფუნქციის გარეთ (გლობალური) და ერთიც ფუნქციის შიგნით (ლოკალური), ხოლო მათი გამოძახება მოვახდინეთ აგრეთვე ორ ადგილზზე, მაგრამ უკვე main() ფუნქციის ბლოკში. შედეგად მივიღეთ ის, რომ გლობალური ცვლადი მოქმედებს ყველგან, ხოლო ლოკალურო კი, მხოლოდ ფუნქციის შიგნით.
ფუნქციის სინტაქსი
და ფუნქციის შესახებ გვინდა სულ ბოლოს გადმოვცეთ მისი დაწერის, ანუ შექმნის სინტაქსი, ახლა როდესაც თქვენთვის ყველაფერი გასაგებია, ეს სინტაქსიც არ დაგრჩებათ გაუგებარი:
FunkciisTipi FunkciisSaxeli (parametrebi)
{
ფუნქციის კოდი ;
}
მიზანი ამართლებას საშუალებას !
ვინც ეძებს ის პოულობს : http://therealgta.ucoz.com
ითამაშე ფლეშ თამაშები : http://gamesforboys.in
|
| |
| |
