| DL1MP1K | Date: ხუთშაბათი, 2012-02-09, 7:48 PM | Message # 1 |
|
Lieutenant colonel
Group: VIP
Messages: 77
Awards: 0
Reputation: 1
Status: გასული
| როგორც წინა თავში ავღნიშნეთ, კლასები წარმოადგენენ ობიექტორიენტირებული პროგრამირების ძირითად საფუძველს. კლასის განსაზღვრისათვის შეიძლება შემოვიტანოთ ოთხი საფეხური:
1) თვისებები (ინსტანცის ცვლადები);
2) მეთოდები;
3) კონსტრუქტორი;
4) არტიბუტები.
მთლიანი კლასის საერთო სინტაქსი შეიძლება წარმოვადგინოთ ასეთი სახით.
class vektor // კლასის სახელი
{
//ატრიბუტი
public:
//თვისებები
double x;
double y;
//კონსტრუქტორი
vektor ()
{
x = 0;
y= 0;
}
// მეთოდები
void sekreba (vektor v2)
{
x += v2 . x;
y += v2 . y;
}
void gadmocema ()
{
cout << " ( " << x
<< " , " << y << " ) ";
}
};
// დაიხსომეთ, რომ ყველა კლასის ბოლოში ისმება წერტილ მძიმე };
საერთოდ კლასების განსაზღვრისას პროგრამისტმა უკვე უნდა იცოდეს, თუ რა დანიშნულებისა იქნება ესა თუ ის კლასი, რომელსაც იგი შექმნის და თუ ვისთვის იქნება იგი განკუთვნილი, საკუთრივ თვითონ პროგრამისტისათვის ვინც ამ კლას ქმნის თუ, სხვა პროგრამისტისათვის ვინც ამ კლასს გამოიყენებს. ასე რომ შეიძლება კლასების შექმნის ორ ფაზასთან გვქონდეს საქმე: ჩვენც დავიწყოთ თავიდან და შემოვიტანოთ მაგალითი, რომელიც შეეხება ვექტოთა მარტივ შეკრებას და მათ გადმოცემას, ეს მაგალითი წარმოვადგინოთ ორივე ფაზით.
ფაზა პირველი (კლასის შექმნა საკუთრივ პროგრამისტისათვის)
1) გავხსნათ ახალი პროექტი
// klasi1.cpp - კლასი ვექტორებისათვის
#include < iostream >
using namespace std;
int main()
{
return 0;
}
საერთოდ რაც ჩვენს მაგალითში შავად იქნება დაწერილი, ეს უკვე იცით თქვენ და ყოველი ახალი ნაბიჯი იქნება ლურჯი ფერით. აქვე თავშივე ვთქვათ აგრეთვე ერთიც, რომ სიტყვა class არის კლასის განმსაზღვრელი სიტყვა და რაც მას მოსდევს ეს უკვე კლასის სახელია. როგორც კლასი ასევე ნებისმიერი ცვლადები სახელების დაწერისას C++ პროგრამირებაში ერთი კანონზომიერებით სარგებლობენ, რაზედაც ჩვენ უკვე ნათქვამი გვაქვს და ეს კანონზომიერება აქაც უნდა გაითვალისწინოთ.
class klasissaxeli
{
// elementebi
};
2) მოვახდინოთ კლასის განსაზღვრა;
// klasi1.cpp - კლასი ვექტორებისათვის
#include < iostream >
using namespace std;
class vektor
{
};
int main()
{
return 0;
}
თვისებები
თვისებები ანუ კლასების ფაილები კლასებში განისაზღვრებიან, როგორც ჩვეულებრივი ცვლადები.
რას ნიშნავს ეს? --- ცვლადები, რომლებიც განსაზღვრულები არიან, როგორც კლასების ელემენტები უწოდებენ ინსტანცებს
3) განვსაზღვროთ ინსტანცის ცვლადები კლას ვექტორისათვის:
// klasi1.cpp - კლასი ვექტორებისათვის
#include < iostream >
using namespace std;
class vektor
{
double x; // x - კოორდინატი
double y; // y - კოორდინატი
};
int main()
{
return 0;
}
წინა თავშიც ვთქვით და ახლაც ვიმეორებთ, რომ ობიექტის გეგმაზომიერი გამოყენების თვალსაზრისით ვიღებთ მისგან მხოლოდ იმ თვისებებს, რომლებიც პროგრამირებისათვის გვჭირდება. ჩვენს მაგალითშიც შევარჩიეთ ორი თვისება, x და y კოორდინატები, თუმცა შესაძლებელი იყო აგვეღო ვექტორის სხვა თვისებებიც, მაგ მისი სიგრძე და კუთხე (იანგარიშება ჰორიზონტალური), მაგრამ ამ ჩვენს მაგალთში გვჭირდება მხოლოდ ორი x და y თვისება. ისეთი თვისებები, როგორებიცაა მაგალითად ვექტორის ფერი, ან ვთქვათ სისქე, მათი გამოყენება ამ შემთხვევაში გასაგებია, რომ უაზრობა იქნებოდა.
ახლა, როდესაც ვექტორის, ანუ ჩვენი ობიექტის თვისებები შევარჩიეთ და განვსაზღვრეთ ისმება კითხვა, როგორ შეიძლება ამ თვისებებით მუშაობა?
ამისათვის კი კლასებში შემოდის მეთოდი
მეთოდები
მეთოდები კლასებში განსაზღვრავენ იმ ოპერაციებს, რომელთა გამოყენებითაც შესაძლებელია კლასების ობიექტებზე ზემოქმედების მოხდენა
თუ თქვენ ჯერ კიდევ არ იცით თუ რა მეთოდი უნდა შემოიტანოთ თქვენს კლასში, მაშინ შეგიძლიათ თქვენს თავს რამოდენიმე კითხვა დაუსვათ:
ა) რის გაკეთება შეიძლება ამ ჩემი კლსაის ობიექტით რეალურად?
ბ) რა უნდა გააკეთონ იმ პროგრამისტებმა ამ ჩემი კლასით, თუ კი ისინი საერთოდ ამ ჩემს კლასს გამოიყენებენ?
გ) და საერთოდ რაში შემიძლია მე თვითონ, ეს ჩემი კლასი გამოვიყენო?
შეიძლება უფრო მეტი კითხვაც გაგვჩენოდა თავში, რადგან კლასები ძალზედ ფართო თემაა, ამჯერად ეს სამი კითხვაც გვეყოფა. ზემოთ ამავე თავში ჩვენ განვიხილეთ ვექტორთა მაგალითი და ახლაც განვაგრძოთ იგი. ე.ი. საჭიროა დავწეროთ მეთოდი, რომელიც შეკრებს ვექტორებს და აგრეთვე მეორე მეთოდი, რომელი უკვე მათ შედეგს გადმოგვცემს და გვაჩვენებს.
4) პირველ რიოგში მეთოდი უნდა განვსაზღვროთ:
// klasi1.cpp - კლასი ვექტორებისათვის
#include < iostream >
using namespace std;
class vektor
{
double x; // x - კოორდინატი
double y; // y - კოორდინატი
// მეთოდები
void sekreba(vektor v2)
{
x += v2 . x;
y += v2 . y;
}
void gadmocema()
{
cout << " ( " << x << " , " << y << " ) ";
}
};
int main()
{
return 0;
}
კი ბატონო დავწერეთ ორი მეთოდი, მაგრამ ბევრისათვის შეიძლება ეს გაუგებარი იყოს, კერძოდ კი ავიღოთ ვთქვათ მეთოდი მიმატება, რატომ ხდება ისე, რომ ვიღებთ მხოლოდ ერთ ვექტორს და მეორეს კი ვიყენებთ არგუმენტად, ჩვენ ხომ ორ ვექტორს ვკრებავთ? აი ამ კითხვას რომ ვუპასუხოთ უნდა გავიხსენოთ თუ რა არის ინსტანცი (ერთი ტიპის კლასის ცვლადებს უწოდებენ ინსტანცებს). როდესაც პროგრამისტი რომელიმე ინსტანცს მეთოდით იძახებს, იგი ელოდება რომ მეთოდი ამ აკტუალურ ინსტანცს დაამუშავებს. მაგალითად ვიძახებთ vektor1.gadmocema() , ველოდებით რომ მივიღოთ ვექტორი პირველის კოორდინატები, როგორც x, ასევე y. ვწერთ მაგ: vektr1.mimateba(vektr2) ველოდებით რომ ვექტორი პირველი და ვექტორი მეორე შეიკრიბება. ალბათ შეამჩნიეთ, რომ ობიექტსა და მეთოდს შორის არის წერტილი დასმული, სწორედ ეს წერტილია მათი დამაკავშირებელი ხიდი, რომლის საშუალებითაც მეთოდი ამუშავებს ობიექტს (ამ შემთხვევაში ინსტანცს).
შეხედეთ ამ მაგალითს:
vektor vektr1, vektr2;
vektr1.x = 10;
vektr2.y = 29;
vektr2.x = -1;
vektr2.y = 12;
vektr1.gadmocema(); // შედეგად გადმოიცემა (10, 29)
vektr2.gadmocema(); // შედეგად გადმოიცემა (-1, 12)
ახლა არც მიმატების ფორმულირებული წარმოსახვა არ უნდა გაგიჭირდეთ:
void sekreba(vektor v2)
{
x += v2.x;
y += v2.y;
}
გაიხსენეთ, რომ ეს ტოლობა x += v2.x; შეესიტყვება x = x + v2.x;
ასეთი მეთოდური წარმოსახვების შედეგად შეგვიძლია ასეც დავწეროთ:
void sekreba(vektor v2)
{
x += v2.x;
y += v2.y;
gadmocema();
}
კონსტრუქტორი
კონსტრუქტორი ეს არის განსაკუთრებული მეთოდი, რომელიც კლასებს მიეკუთვნება. როდესაც რაიმე კლასის ობიექტი იქმნება, იგი იკავებს კომპიუტერის სამუშაო სამახსოვრო ადგილში რაიმე ადგილს, უფრო ზუსტად ამ ობიექტის ცვლადები იკავებენ სამახსოვრო ადგილს. და ამ დროს სჭირდება კომპილერს რაღაცა მეთოდი, რომელიც ამ ცვლადებს და მთლიანობაში ობიექტს, ინიციალიზირებას გაუკეთებს, სწორედ ეს მეთოდია კონსტრუქტორი. იგი გამოიძახება ძირითადად ობიექტის ცვლადების განსაზღვრისას. კომპილერი ისეა შედგენილი, თუ პროგრამისტისაგან მოხდება ამ კონსტრუქტორის გამოტოვება (მიზან მიმართული ან უნებლიე), მაშინ იგი ამ კონსტრუქტორს თვითონ განავრცობს. ყოველივე ეს კი მიგვანიშნებს კონსტრუქტორის აუცილებლობაზე, ამით კომპილერი რწმუნდება, რომ კონსტრუქტორის დახმარებით ობიექტის ცვლადებს სწორედ გაუკეთდათ ინიციალიზირება. ხშირად კონსტრუქტორი გამოიყენება ინსტანცების ელემენტებისათვის საწყის მნიშვნელობების მისანიჭებლად.
საკუთარი კონსტრუქტორის შესაქმნელად პირველ რიგში იგი უნდა განვსაზღვროთ, ამისათვის კი უნდა ვიცოდეთ ეს ოთხი კანონი:
a) კონსტრუქტორები ატარებენ იგივე სახელს, რასაც თვით კლასი;
b) მათ არ გააჩნიათ უკუ გადმოსაცემი მნიშვნელობები და არც ტიპაჟები (თვით void -იც უგულებელყოფილია);
c) კონსტრუქტორები ავტომატურად კომპილერისაგან გამოიძახებიან მაშინ, როდესაც ხდება ინსტანცების განსაზღვრა კლასებში;
d) ისინი სხვა მეთოდებისაგან განსხვავდებიან იმითაც, რომ explizit -ში რაიმე ინსტანცისათვის არ გამოიძახებიან.
5) განვაგრძოთ მაგალითი და დავსვათ კონსტრუქტორი:
// klasi1.cpp - კლასი ვექტორებისათვის
#include < iostream >
using namespace std;
class vektor
{
double x; // x - კოორდინატი
double y; // y - კოორდინატი
// კონსტრუქტორი
vektor()
{
x = 0;
y = 0;
}
// მეთოდები
void sekreba(vektor v2)
{
x += v2 . x;
y += v2 . y;
}
void gadmocema()
{
cout << " ( " << x << " , " << y << " ) ";
}
};
int main()
{
return 0;
}
როგორც ხედავთ კონსტრუქტორი განვსაზღვრეთ იგივე სახელით, რაც კლასს გააჩნია და ობიექტის ცვლადებს საწყის მნიშვნელობებად მივანიჭეთ ნოლები;
ძირითადად ამით შემოფარგლა კლასის მთლიანი წარმოდგენა, ახლა ჩვენი მაგალითი, რომ სრულვყოთ დავსახოთ ჯერ ამოცანა: 1)კერძოდ შევეცადოთ შემოვიტანოთ ორი ინსტანცი ჩვენი ვექტორის კლსიდან და გადმოვცეთ ისინი ჩვენი პროგრამით; და 2) მივუმატოთ შემდეგ მეორე ვექტორი პირველს და ასეთი სახით კვლავ გადმოვცეთ პროგრამის სახით.
6) ამოცანის ამოხსნა:
// klasi1.cpp - კლასი ვექტორებისათვის
#include < iostream >
using namespace std;
class vektor
{
double x; // x - კოორდინატი
double y; // y - კოორდინატი
// კონსტრუქტორი
vektor()
{
x = 0;
y = 0;
}
// მეთოდები
void sekreba(vektor v2)
{
x += v2 . x;
y += v2 . y;
}
void gadmocema()
{
cout << " ( " << x << " , " << y << " ) ";
}
};
int main()
{
vektor vekt1;
vektor vekt2;
vekt1.x = 1;
vekt1.y = 2;
vekt2.x = 10;
vekt2.y = 20;
// ვექტორის გადმოცემა
cout << "Vektor 1: ";
vekt1.gadmocema();
cout << endl;
cout << "Vektor 2: ";
vekt2.gadmocema();
cout << endl << endl;
// 2. ვექტორთა შეკრება
vekt1.sekreba(vekt2);
// ვექტორი შეკრების შემდეგ
cout << "Vektor1 sekrebis Semdeg : ";
vekt1.gadmocema();
cout << endl;
return 0;
}
ატრიბუტი
ბოლოს დაგვრჩა მხოლოდ ატრიბუტი და შეიძლება ითქვას ჩვენც გადავდივართ მეორე ფაზაში
როგორც უკვე ვთქვით კლასები თავიდანვე განისაზღვრება თუ რისთვისაა და ვისთვისაა ესა თუ ის კლასი დაწერილი, ეს ჩვენი დაწერილი კლასი მხოლოდ შეიძლება ჩვენსავე პროგრამაში გამოვიყენოთ, მაგრამ არც აქა გვაქვს ჯერ განსაზღვრაში შემოტანილი თუ როგორი მოქმედება შეიძლება ამ ჩვენს კლასზე.
კლასზე მოქმედება შეიძლება როგორც შიგნიდან ასევე გარედან. სწორედ ატრიბუტია ამის განმსაზღვრელი, თუ რა მოქმედების არე ენიჭება კლასს. თუ ჩვენს ზემოთა მაგალითს გასინჯავთ კომპილერის საშუალებით, თქვენ მიიღებთ შეცდომას და ეს მართალიც იქნება, რადგან ატრიბუტი არა გვაქვს კლსაში შემოტანილი, ჩვენს ეს თავი სპეციალურად გადმოვიტანეთ აქ ბოლოში რომ უფრო კარგად შეძლოთ ყოველივე ამის გათვითცნობიერება.
ატრიბუტი შეიძლება იყოს კერძო ანუ private და საერთო ანუ public. სწორედ ამის და მიხედვითაა კლასებიც განსაზღვრული. ატრიბუტის განსაზღვრა ხდება კლასების თავშივე და მიეთითება ან private ან public, რომელსაც მოსდევს შემდეგ ორი წერტილი:
ასე, რომ თუ თქვენ ჩვენს მაგალითს გასინჯავთ, არ დაგავიწყდეთ ატრიბუტის შემოტანა.
მიზანი ამართლებას საშუალებას !
ვინც ეძებს ის პოულობს : http://therealgta.ucoz.com
ითამაშე ფლეშ თამაშები : http://gamesforboys.in
|
| |
| |
