BUSE - Best Ucoz Search Engine

ჩვენს მიერ დაწერილი პროგრამები ჯავაში

DL1MP1K — Sat, 15 Dec 2012 11:52:07 GMT

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

ვიწყებ :

ჩაწერეთ ორი კათეტი და გამოთვლის ჰიპოთენუზას

Code

package project.x;

/**
   *
   * @author DL1MP1K
   */
public class ProjectX {


      public static void main(String[] args) {
          double a=0;
          double b=0;
          double c=Math.sqrt(Math.pow(a, 2) + Math.pow(b, 2));
           System.out.println("answer: " +c);
      }
}

a-ს და b-ს მიანიჭეთ მნიშვნელობა. ა და ბ არის კათეტები

ჯავა დამწყებებს გაკვეთილი 1 - გამარჯობა მსოფლიო

DL1MP1K — Sat, 08 Dec 2012 16:28:54 GMT

სანამ დავიწყებდეთ სწავლას, გავეცნოთ ზოგადად ამ ენას. ვიკიიიი :

ჯავა (ინგლ. Java წარმოითქმის, /dʒɑːvə/) არის ზოგადი დანიშნულების, კონკურენტული, ობიექტურად ორიენტირებული პროგრამირების ენა. Java არის მკაცრად (სტატიკურად) ტიპიზირებული ენა. სინტაქსური აგებულებით ის წააგავს უფრო ადრეულ ენებს C და C++. მისი ობიექტური მოდელი აგრეთვე მნიშვნეოვნად ნასესხებია C++ და Smalltalk ენებიდან. Java პროგრამები კომპილირდება ბაიტ-კოდებში და ეშვება Java ვირტულურ მანქანაში (JVM), რაც უზრუნველყოფს კომპილირებული პროგრამის დამოუკიდებლობას გამშვები სისტემასთან მიმართებაში.
ოფიციალურად Java 1995 წლის 23 მაისს გამოვიდა. Java-ს პირველადი შემუშავება ეკუთვნის Sun Microsystems, რომელიც დღემდე რჩება Java ვირტუალური მანქანის და ენის სპეციფიკაციის ძირითად განმსაზღვრელად.
Java მხარდაჭერილია ძირითად კომპიუტერულ და მობილურ ოპერაციულ სისტემებში, უამრავ საყოფაცხოვრებო და ციფრული მოწყობილობაში, აგრეთვე საბანკო პლასტიკურ და სხვა სახის სერვის ბარათებში.
დღეს Java ყველაზე გავრცელებული ენაა, მოწყობილობათა რაოდენობის მიხედვით, რომლებიც ასრულებენ Java პროგრამებს და, აგრეთვე, ყველაზე პოპულარული ენაა იმ პროგრამისტების რაოდენობის მიხედვით, რომლებიც წერენ თავის პროგრამებს Java-ზე.

(ინფორმაცია აღებულია Wikipedia)

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

download

ეხლა კი შევუდგეთ საქმეს. ჯავას საწერად აუცილებელია თავიდან მთვარი კლასის მითითება. ამ შემთხვევაში ჩვენი კლასის სახელია "გამარჯობა მსოფლიო". მაგრამ ამის დაწერა ნეტბინსი არ დაგჭირდებათ, კლასის შექმნის შემდეგ ის ავტომატურად აკეთებს ამ ყველაფერს. ჩვენი პროგრამის წერას კი ვიწყებთ ამის მერე : "public static void main(String[] args) {" დამხურავ ფრჩხილამდე "}"

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

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

Code

public class გამარჯობა მსოფლიო {

     public static void main(String[] args) {
         System.out.println("გამარჯობა, მსოფლიო");
     }

}

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

მადლობა ყურადღებისთვის

C ++ დამწყებებს- 10 გაკვეთილი

DL1MP1K — Thu, 09 Feb 2012 15:48:52 GMT

როგორც წინა თავში ავღნიშნეთ, კლასები წარმოადგენენ ობიექტორიენტირებული პროგრამირების ძირითად საფუძველს. კლასის განსაზღვრისათვის შეიძლება შემოვიტანოთ ოთხი საფეხური:
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, რომელსაც მოსდევს შემდეგ ორი წერტილი:

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

C ++ დამწყებებს- 9 გაკვეთილი

DL1MP1K — Thu, 09 Feb 2012 15:47:19 GMT

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

C ++ დამწყებებს- 8 გაკვეთილი

DL1MP1K — Thu, 09 Feb 2012 15:46:39 GMT

რა არის სტრუქტურა და რისთვის ვიყენებთ მათ? ამ კითხვაზე, რომ გავცეთ საფუძვლიანი პასუხი გავიხსენოთ ჩვენივე ლექციებიდან ნასწავლი მასივები. კერძოდ მასივების საშუალებით შესაძლებელია რამოდენიმე ცვლადის, რომელთაც ერთი სახის ტიპაჟი გააჩნიათ ერთ ფაილების ტიპად ჩამოყალიბება. ხოლო სტრუქტურების სახით შესაძლებელია უკვე აგრეთვე რამოდენიმე ცვლადის, რომელთაც სხვა და სხვა სახის ტიპაჟები გააჩნიათ, ერთ საერთო კომბინირებულ ფაილთა ტიპად ჩამოყალიბება. ცოტა რთულად კი გამოგვივიდა ნათქვამი, მაგრამ არა უშავს მაგალითების სახით ადვილად გაერკვევით ჩვენს ნათქვამში. ჯერ კი დავიწყოთ თავიდან, ანუ განვსაზღვროთ სტრუქტურა.
პირველ რიგში კი უნდა ისწავლოთ თუ რა განსხვავებაა სტრუქტურების ტიპებსა და სტრუქტურის ცვლადებს შორის.
სტრუქტურის ტიპი ესაა იგივე ფაილის ტიპი (როგორც int, double ან string) , რომელიც ჩვენგან განისაზღვრება და არა თვით პროგრამირების ენისაგან. ხოლო როდესაც ჩვენ უკვე სტრუქტურის ტიპს ანუ სახეობას განვსაზღვრავთ, მაშინ შეგვიძლია უკვე ცვლადებიც შემოვიტანოთ, როგორც სტრუქტურის ცვლადები და განვსაზღვროთ ისინი სტრუქტურულ ცვლადებად.

კომპლექსური ფაილები

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

მივყვეთ ნაბიჯ-ნაბიჯ ჩვენს მაგალითს. შემოვიტანოთ ახალი პროექტი სადაც გამოვიძახებთ აგრეთვე კლასს < string >.

#include < iostream >
#include < string > // შემოტანილია string
using namespace std;

struct konto // სტრუქტურის განსაზღვრა
{
string klientisSaxeli; // შემოგვაქვს სტრუქტურის ცვლადები
int kontoNomeri;
double kontosMdgomareoba;
int krediti;
};

int main()
{
konto cemiKonto;

cemiKonto.klientisSaxeli = "xinkala"; // წერტილის საშუალებით სტრუქურაზე ზემოქმედება
cemiKonto.kontoNomeri = 1234567;
cemiKonto.kontosMdgomareoba = 3000;
cemiKonto.krediti = 1000;

cout << "Konto " << cemiKonto.klientisSaxeli // კლიენტის მონაცემების გადმოცემა
<< endl << endl;
cout << "\tKontoNomeri: "
<< cemiKonto.kontoNomerir << endl;
cout << "\tKontosMdgomareoba: "
<< cemiKonto.kontosMdgomareoba << endl;
cout << "\tKreditis gacemis szRvari: "
<< cemiKonto.krediti << endl;
cout << endl;

return 0;
}

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

C ++ დამწყებებს- 7 გაკვეთილი

DL1MP1K — Thu, 09 Feb 2012 15:45:56 GMT

ჩვენს წინა ლექციაში ვისწავლეთ ფუნქციის განსაზღვრისა და მისი გამოძახების წესები, ავღნიშნეთ აგრეთვე ისიც, თუ რას წარმოადგენს ფუნქციის ბოლოში დასმული ფრჩხილები ( ). კერძოდ კი ის რომ ამ ფრჩხილებში შესაძლებელია განვსაზღვროთ ცვლადები, რომელთაც ვუწოდებთ პარამეტრებს. ამ ფრჩხილებში განსაზღვრული ცვლადები, ანუ ფუნქციის პარამეტრები მოქმედებენ მხოლოდ ფუნქციის არეში, ანუ მათ ფუნქციის გარეთ არავითარი დანიშნულება არ გააჩნიათ.
ის მნიშვნელობები, რომლებიც ფუნქციის გამოძახებისას ამ პარამეტრებს გადეცემათ, ეწოდებათ არგუმენტები. მათ ზოგიერთი პროგრამისტი ასევე პარამეტრს უწოდებს.
ახლა შევხედოთ ჩვენს წინა მაგალითს, სადაც შემოვიტანეთ ფუნქცია 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)

{

ფუნქციის კოდი ;

}

C ++ დამწყებებს- 6 გაკვეთილი

DL1MP1K — Thu, 09 Feb 2012 15:45:10 GMT

საერთოდ ფუნქცია და მისი დანიშნულება პროგრამირების ენებში, ყველგან თითქმის ერთია. ჩვენი თემების ყველა ლექციებში ამ საკითხს უკვე შევეხეთ, განვიხილეთ თითოეული პროგრამირების და ენის მიხედვით მისი დანიშნულება და მისი შემოტანის პრიორიტეტი. ახლაც გვინდა მოკლედ აგიხსნათ ის, თუ რას წარმოადგენს ფუნქცია და რა დანიშნულება გააჩნია მას.
წარმოიდგინეთ წერთ რომელიმე პროგრამის კოდს, სადაც ერთი და იგივე კოდის (ვთქვათ, რაიმე ტექსტური ჩანაწერის) მრავალჯერ გამეორება გიწევთ, რა ხდება ამ დროს? იძულებულები ვართ ეს კოდი ყველგან გავიმეოროთ, ამით რა თქმა უნდა იზრდება პროგრამის კოდი, რაც ხელს უშლის პროგრამის მოქნილობას და ასევე რა საკვირველია ვკარგავთ ბევრ დროს. აი ფუნქციის შემოტანით ამ შრომის აცილება შესაძლებელია და თუ როგორ, ამაზე ქვემოთ.
ფუნქციის გამოყენება აადვილებს აგრეთვე პროგრამაში გაპარული შესაძლო შეცდომის პოვნას და შესაძლებელია აგრეთვე ამ ფუნქციის სხვა ახალ პროგრამაშიც გამოყენება, უბრალოდ კოპირების მეთოდით გადავიტანთ ფუნქციაში შესულ ბრძანებებს და მორჩა.
როგორც ხედავთ, ფუნქციის შემოტანას პროგრამირებაში ბევრი უპირატესობანი გააჩნია, ამიტომ ჩვენი რჩევაა, გულმოდგინეთ მოეკიდოთ ამ საკითხს.
როგორც ცვლადები, ასევე ფუნქციებიც პირველ რიგში უნდა განისაზღვრონ, ჩვენი ფუნქციის განსაზღვრა ხდება main() ფუნქციის წინ, ხოლო მისი გამოძახება შესაძლებელია თვით ამ main() ფუნქციიდან; მარტივად ვწერთ ჩვენი ფუნქციის სახელს და მორჩა.
ფუნქციის განსაზღვრისას პირველ რიგში ვფიქრობთ მის სახელზე და იმაზე, თუ რა დანიშნულება უნდა ქონდეს ამ ჩვენს ფუნქციას, ანუ რა მუშაობა უნდა გაწიოს მან ჩვენს პროგრამაში.
ფუნქციის სახელი სასურველია იყოს ნათელი, რათა შემდეგი მუშაობის შესრულებაში ადვილად შევძლოთ მთლიანი კოდის ანალიზება.
შემოვიტანოთ ერთი მაგალითი ახლა და მივყვეთ მას ნაბიჯ-ნაბიჯ, რათა გავერკვეთ ფუნქციის წესებში.
როგორც ყოველთვის ფუნქციას ეძლევა სახელი; misalmeba(), რომლის ბოლოშიც ვსვამთ ფრჩხილებს, თუ რას წარმოადგენენ ეს ფრჩხილები, ამაზე ქვემოთ გვექნება საუბარი, მოკლედ კი გეტყვით, რომ ეს ფრჩხილები წარმოადგენენ ადგილს სადაც ხდება ფუნქციის პარამეტრების განსაზღვრა.
ახლა მივყვეთ კვლავ ჩვენს მაგალითს. რა მოვალეობა ეკისრება ჩვენს მიერ შექმნილ ახალ ფუნქციას misalmeba(), რა მუშაობა უნდა შესრულოს მან ჩვენს პროგრამაში.
როგორც თვით ფუნქციის სახელი გვეუბნება, საჭიროა მან ჩვენს პროგრამაში შეასრულოს მისალმების ფუნქცია, ანუ როდესაც ჩვენ გვსურს მივესალმოთ ჩვენს მომხმარებელს (მას ვინც ჩვენი დაწერილი პროგრამით იხელმძღვანელებს).
როგორც უკვე წინა ლექციებიდან ვიცით, ტექსტური ჩანაწერების გადმოცემას ვახდენთ ბრძანებით cout, რომელსაც მიეთითება აუცილებლად ეს ნიშანი <<, რომლის შემდეგაც ვათავსებთ ჩვენთვის სასურველ ტექსტს, რომელსაც ვხურავთ კვლავ ამ ნიშნით <<, და ბოლოს ვუთითებთ ბრძანებას endl, ამ უკანასკნელის დანიშნულებაა, შემოიტანოს ახალი სტრიქონის დასაწყისი.
cout << "gamarjobaT xalxooo!" << endl; //არ დაივიწყოთ, რომ C++ პროგრამირებაში, ასევე ჯავა ენაში ყოველი საპროგრამო სტრიქონი მთავრდება წერტილ-მძიმეთი, ანუ ასე ;
ფუნქციებს შეუძლიათ საბოლოო შედეგების უკუ ასახვა მოახდინონ, რომლებსაც ენიჭებათ ტიპაჟები, ანუ იმ ტიპების სახეობები, რომელი სახისაც უნდა იყოს შედეგის მნიშვნელობა. (int, duble ან string). ამიტომ ყოველ ფუნქციას მისი განსაზღვრისას ფუნქციის სახელის წინ მიეთითება შესაბამისი ტიპაჟი. ხოლო იმ შემთხვევაში, როდესაც არაა საჭირო ფუნქციის ბოლო შედეგის გადმოცემა, როგორც ამ ჩვენს მაგალითში, მაშინ მიეთითება სპეციალური ბრძანება void
მაშასადამე ჩვენი ფუნქციის განსაზღვრა ხდება ასე:
void misalmeba()
ახლა ავდგეთ და მოვათავსოთ ჩვენი ტექსტური ჩანაწერი ფუნქციის იმ სპეციალურ ბლოკში, რომელიც იჭყება { ამ ფრჩხილით და მთავრდება ამით }.
void misalmeba()
{
cout << endl;
cout << "gamarjobaT xalxooo!" << endl;
cout << endl;
}
კი ბატონო, დავწერეთ ფუნქცია, რომელსაც დანიშნულებაც მოვანიჭეთ, მაგრამ როგორ მოვახდინოთ მისი გამოძახება? როგორც ზემოთ ვთქვით, გამოძახებისას ვწერთ მხოლოდ ფუნქციის სახელს, თავისივე ფრჩხილების ( ) ჩათვლით და მორჩა. ჩაწერას ვახდენთ იმ ადგილას სადაც გვინდა, რომ ჩვენი მისალმება გამოჩნდეს.
თუ შემოვიტანთ ჩვენი მაგალითის მთლიან სახეს, ვნახავთ შემდეგს, რომ ფუნქციის განსაზღვრას ვახდენთ თავში, კერძოდ კი main() ფუნქციის წინ, ხოლო გამოძახებას კი თვით ამ main() ფუნქციის ბლოკის არედან.

#include < iostream >

using namespace std;

void misalmeba()

{

cout << endl;
cout << "gamarjobaT xalxooo!" << endl;
cout << endl;
}
int main()

{

misalmeba();

return 0;

}

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

C ++ დამწყებებს- 5 გაკვეთილი

DL1MP1K — Thu, 09 Feb 2012 15:44:33 GMT

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

if()

else

2. ციკლის ოპერატორები
for ()

while()

do while();

დავიწყოთ პირობის ოპერატორების განხილვით, რადგანაც ყველა ციკლი რაღაც პირობამდე სრულდება
ოპერატორი IF()
if() ოპერატორის ფრჩხილებში იწერება პირობა თუ რა უნდა დაკმაყოფილდეს რომ შეიძლებოდეს ოპერატორის შემდგომი კოდის რეალიზაცია
თუკი პირობა სრულდება if ოპერატორს გადაეცემა მნიშვნელობა true, ყველა სხვა შემთხვევაში false;
if(a < b) //თუ პირველი ცვლადი ნაკლებია მეორეზე პირობა არის true თუ არა false

if(a > b) //თუ პირველი ცვლადი მეტია მეორეზე პირობა არის true თუ არა false

if(a <= b) //თუ პირველი ცვლადი ნაკლებია ან ტოლია მეორეზე პირობა არის true თუ არა false

if(a >= b) //თუ პირველი ცვლადი მეტია ან ტოლია მეორეზე პირობა არის true თუ არა false

if(a == b) //თუ პირველი ცვლადი ტოლია მეორესი პირობა არის true თუ არა false

if(a != b) //თუ პირველი ცვლადი არ უდრის მეორეს პირობა არის true თუ არა false
if(bool cvladi romelic tolia an false an true) //თუ ცვლადს არა აქვს მნიშვნელობა true

განვიხილოთ ბოლო მაგალითი;
bool rafika = true;

if(rafika)

{

rafika =false;

}
აქ რაკი ცვლადს აქვს მნიშვნელობა true, if ოპერატორიც მიიღებს მნიშვნელობას true და შესრულდება ოპერატორის ფიგურულ ფრჩხილებში განთავსებული მოქმედება, თუმცა თუკი მეორეთ მიმართავს პროგრამა ამ ბლოკს პირობა უკვე აღარ იქნება შესრულებული და ეს ბლოკი გამოიტოვება, თუ არ მოხდა ცვლადისათვის ისევ trues მინიჭება; არის საშუალება რომ false მნიშვნელობამ ცვლადისა გამოიწვიოს true მნიშვნელობის გადაცემა if ოპერატორში; მაგ;
bool iden=false;

if( ! iden)

{

iden =true;

}
ამ შემთხვევაში if ოპერატორი მიიღებს მნიშვნელობა trues რადგან ცვლადის წინ დაწერილი ძახილის ნიშანი განსაზღვრავს შემდეგ პირობას თუ ცვლადს არა აქვს მნიშვნელობა true მაშინ პირობა შესრულებულია. ანუ შემდეგი მიმართვისას (რაკი ფრჩხილებში ხდება ცვლადისთვის trues მინიჭება ) პირობა უკვე აღარ შესრულდება და ბლოკი გამოიტოვება. ოპერატორი else სრულდება იმ შემთხვევაში თუ if ოპერატორის პირობა არ სრულდება , მარტო else oპერატორი არ მუშაობს, იგი ყოველთვის თანმდევია if ოპერატორის. მაგ
bool iden=false;

int a=10, b=20;

if( ! iden)

{

iden =true;

}

else

{

a=a+b;

}
განვიხილოთ ციკლები თანმიმდევრობით
დავიწყოთ for ით. ამ ოპერატორის მოქმედება სრულდება მანამ სანამ მისი მეორე წევრი რომელიც პირობაც არის არ შესრულდება;
მისი სინტაქსისი;
for(int i=0; i<100; i++)

{

moqmedeba romelic unda Sesruldes

}
პირველი წევრი როგორც უკვე ვიცით არის მთელი რიცხვი და მრიცხველის როლს ასრულებს , ციკლის მუშაობის დაწყებისას მოწმდება პირველი წევრი და შემდეგ საფეხურებზე მისი შემოწმება აღარ ხდება, მოწმდება მხოლოდ მეორე წევრის პირობა. რაც შეეხება მესამე წევრს ეს ახალი მცნებაა და ცოტა ფართოდ გავაშუქებთ; ორი პლუსი ცვლადის შემდეგ განაპირობებს ცვლადის ერთით გაზრდას ეს იგივეა რაც i=i+1; ამიტომ აუცილებელია თავიდან ცვლადს რაიმე მნიშვნელობა ჰქონდეს მიღებული, წინააღმდეგ შემთხვევაში არ მოხდება ცვლადის სიდიდის გაზრდა; მოქმედება შემდეგნაირად მიმდინარეობს; შემოწმდა პირობა და შემდეგ გაიზარდა ინკრემენტი ანუ ცვლადი i ; თუმცა არსებობს შემდეგი სინტაქსისიც ++i რაც იგივეს ნიშნავს მაგრამ აქ უკვე ჯერ სრულდება მომატება და შემდეგ მოწმდება პირობა; იგივე სინტაქსისი აქვს დეკრემენტს ოღონდ მინუს ნიშნით i-- ან --i და ნიშნავს i=i-1;
მეორე ციკლის ოპერატორია while()

while(ცვლადი ან პირობა)

{

მოქმედება რომელიც უნდა შესრულდეს

}
აქ ციკლის ოპერატორი მუშაობს მანამ სანამ ცვლადი ან პირობა რომელიც ოპერატორის ბრჩხილებშია არ მიიღებენ მნიშვნელობას false
განვიხილოთ ორი მაგალითი;

1) int a=0;

int b=100;

while(a < b)

{

a++;

}
ციკლის დასაწყისში მოწმდება ორივე ცვლადის მნიშვნელობა და ეს ხდება ყოველი შემდგომი გამეორებისას, ჯერ მოწმდება პირობა (a < b) და თუ პირობა სრულდება ციკლიც გრძელდება, რაც გამოიხატება იმაში რომ ფიგურულ ფრჩხილებში მოთავსებული მოქმედება შესრულდება, ცვლადს მოემატება ერთი და ისევ შემოწმდება პირობა, ასე გაგრძელდება მანამ სანამ ოპერატორში მოცემული პირობა არ დაირღვევა; მრიცხველის დაყენება იმითია ნაკარნახევი რომ თუ არ იქნება მრიცხველი და ეს ეხება ამ კონკრეტულ შემთხვევას, მაშინ ციკლი უსასრულოდ გაგრძელდება და გამოიწვევს სისტემის დაკიდებას;
2) bool soo=true;

int a=10;

while(soo)

{>BR>
if(a == 120)

{

soo=false;

}

a++;

}
ეს ის შემთხვევაა როცა ციკლი ტრიალებს მანამ სანამ ცვლადი truea და თან ყოველი შემდგომი ციკლის დროს ამოწმებს ორივე პირობას, როგორც კი soo გახდება false ციკლი მაინც მოუმატებს a - ს ერთს და დაასრულებს თავის მოქმედებას. თუმცა არსებობს ციკლის ხელოვნური გაწყვეტის ოპერატორიც რომელიც რეზერვირებულია ტრანსლიატორში. ეს არის Break; განვიხილოთ იგივე მაგალითზე;
bool soo=true;

int a=10;

while(1)

{

if(a == 120)

{

soo=false;

break;

}

a++;

}
ამ დროს შეიძლება ციკლის პირობა საეთოდ არ არსებობდეს ან უბრალოდ ფრჩხილებში ჩაიწეროს რიცხვი ერთი რაც უსასრულო ციკლს მოგვცემს;
შემდეგი ციკლია do while

int a=6;

do

{

a=a+3;

}

while(a < 5)
ამ შემთხვევაში ჯერ სრულდება ციკლის შიდა ნაწილი ხოლო შემდეგ მოწმდება პირობა, ჩვენს შემთხვევაში ეს ციკლი ერთხელ მაინც შესრულდება რადგანაც დასწყისშივე პირობა დარღვეულია, ცვლადს მაინც მოემატება სამი და დასრულდება; ყოველივე ზემოთ განხილულის უკეთ დასანახად გამოიძახეთ ხელახლა ჩვენი პროექტი, რომელიც განვიხილეთ თემაში 'პირველი მაგალითის ნაირი' გახსენით იგი და შეიყვანეთ შემდეგი კოდი;
cout<<"////////////////////////////////////////////////////////////////////////////////" << endl;

int afo=20;

for(int x=0; x
{

if( x == 15)

{

cout<<"SRULDEBA IF (x == 15) PIROBA x = " << x << endl;

}

else

{

cout << "mimdinareobs ciklis - " << x << " - safexuri \n";

}

}

cout<<"////////////////////////////////////////////////////////////////////////////////"<< endl;

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

C ++ დამწყებებს- 4 გაკვეთილი

DL1MP1K — Thu, 09 Feb 2012 15:43:31 GMT

მასივები ერთ-ერთი ფუნდამენტალური მცნებაა პროგრამირების სამყაროში, ეს არის მეხსიერების ბლოკების(ბაიტების) თანმიმდევრული გამოყოფა. როგორც ვიცით (და თუ არ ვიცით ეხლა გავიგებთ) წინა თემებიდან ოპერატორის მეშვეობით შეგვიძლია გამოვაცხადოთ ცვლადი რომელიც მეხსიერებაში რაღაც ადგილს დაიკავებს, ყოველი შემდგომი ცვლადის გამოცხადებისას ჩვენ არა გვაქვს გარანტია რომ ცვლადები რომლებიც გამოვაცხადეთ, ერთმანეთის მიყოლებით განლაგდებიან მეხსიერებაში, და თუკი დაგვჭირდება მეხსიერებიდან ამ ცვლადების წაკითხვა ჩვენ უნდა სახელებით მივმართოთ მათ, სხვანაირად მათი მოძებნა შეუძლებელია. მასივი ამ მხრივ უნიკალურია რადგანაც ყოველი ცვლადი რომელიც მასივში იქნება, გარანტირებულად ერთმანეთის მიყოლებით იქნება მეხსიერებაში ჩაწერილი და მეხსიერებიდან შეიძლება ასევე მიმდევრობით წაკითხვა; მასივი შეიძლება არსებობდეს ნებისმიერი ტიპის;
მაგ
int masivi [10]; // int არის ოპერატორი რომელიც განსაზღვრავს რომ მასივი რომელიც გამოიყოფა და ჩვენს შემთხვევაში მასივს ქვია masivi მის თითოეულ წევრს ექნება 4 ბაიტის სიდიდე. აქ გამოყოფილი არის 10 წევრიანი მასივი(ანუ 10 არის მასივის სიგრძე) და თითოეული წევრის სიდიდე ოთხი ბაიტია;
ჩვენ შეგვიძლია მის თითოეულ წევრს ცალცალკე მივანიჭოთ მნიშვნელობა
მაგ:
masivi[2] = 18;

masivi[0]=100;

masivi [5]=20;

masivi [9]=43;

masivi [10]=234; //EROR!!!

საგულისხმოა ერთი რამ რომ , თუმცა მასივის სიგრძე 10 ის ტოლია ჩვენ არშეგვიძლია მივმართოთ მასივის მე 10 ელემენტს, რადგანაც მასივის ათვლა იწყება 0 დან და ამიტომაც მისი ბოლო წევრი არის მეათ ელემენტი ინდექსით 9; თუმცა მასივის გამოცხადებისას რიცხვი 10 განსაზღვრავს მასივის სიგრძეს მინიჭებისას ოთხკუთხედ ფრჩხილებში მოთავსებული რიცხვები უკვე მიუთითებენ არა სიგრძეს არამედ ინდექსს თუ მასივის რომელ წევრთან ხდება მოქმედება;
განვიხილოთ ტექსტური მასივი;
char TeMas[20]; // char არის ოპერატორი რომელიც განსაზღვრავს რომ მასივი რომელიც გამოიყოფა და ჩვენს შემთხვევაში მასივს ქვია TeMas მის თითოეულ წევრს ექნება 1 ბაიტის სიდიდე. აქ გამოყოფილი არის 20 წევრიანი მასივი(ანუ 20 არის მასივის სიგრძე) და თითოეული წევრის სიდიდე ერთი ბაიტია;
განსხვავებით სხვა მასივებისა, რომლებიც რიცხვებთან სამუშაოთაა განკუთვნილი, char მასივების ინიციალიზაცია (ანუ მნიშვნელობის მინიჭება) გამოცხადებისთანავეა შესაძლებელი; გამოვიყენებ იგივე მასივს;
char TeMas[20]="Hello C++"; //მართალია მასივი 20 ბაიტიანია მაგრამ ჩვენ მხოლოდ 9 ბაიტი შევავსეთ, თითოეული ასო მეხსიერებაში იკავებს 1 ბაიტს. ცხრა ბაიტის შემდეგ ისე რომ ჩვენ არც ვიცით თავისთავად ეწერება დასასრულის აღმნიშვნელი \0. ეს ხდება იმ მიზეზით რომ წაკითხვისას წაკითხული იქნეს მხოლოდ მეხსიერების ის ნაწილი რომელიც შევსებულია და დანარჩენი იგნორირებული იქნება. აუცილებელი პირობაა ტექსტის ბრჭყალებში მოთავსება, სხვანაირად ტრანსლიატორისთვის გაუგებარი ხდება მინიჭების მოქმედება.
ისევე როგორც სხვა მასივებში აქაც არის საშუალება რომ ცალცალკე მივანიჭოთ მნიშვნელობა მასივის წევრებს
TeMas[0] = "H";

TeMas[1]="e";

TeMas[2]="l";

TeMas[3]="l";

TeMas[4]="o";

TeMas[5]=" ";
და ასე შემდეგ.
მართალია ჩვენი მასივი თავიდანვე 20 ბაიტი გამოვყავით და აქედან მხოლოდ 9 ბაიტი შევავსეთ, სინამდვილეში 10 ბაიტია შევსებული. მეათე არის დასასრულის ნიშანი "\0". თუკი ჩვენ გამოვყოფდით აი ასე ;
char TeMas[9]="Hello C++"; // თითქოს გამართლებულია რომ გვაქვს 9 სიმბოლო და ამიტომაც 9 ბაიტი მოვითხოვეთ, მაგრამ ტრანსლიატორი შეცდომას აფიქსირებს რადგანაც არ რჩება ადგილი დასასრულის აღმნიშვნელი სიმბოლოსათვის:

ისეთი შემთხვევებისათვის როცა არა აქვს მნიშვნელობა მასივის სიგრძეს, შეგვიძლია გამოვაცხადოთ მასივი წინასწარ განსაზღვრული სიდიდით, რომელიც ტრანსლიაციის დროს შემოწმდება და გამოიყოფა იმხელა მეხსიერება რამდენი სიმბოლოც არის ტოლობის შემდეგ. ამ სახის მასივი გამოცხადებისთანავე უნდა იქნეს ინიცირებული, მისი დინამიური ინიციალიზაცია არ მოხდება. მაგ:
char TeMas[ ] ="gamarjoba Cemo Tbilis qalaqo";
როდესაც არანაირი მანიპულაციების ჩატარება არ იგეგმება ტექსტურ მასივთან და უბრალოდ ეკრანზე გამოსაყვანად გვჭირდება მასივი, მაშნ მიზანშეწონილია ამ სახით მასივის გამოცხადება, თუმცა არც ეს მასივია ურიგო მანიპულაციებისთვის, რასაც შემდეგ თავებში გავარკვევთ; ტექსტური მასივების გარდა ყველა სხვა დანარჩენი მასივები შეიძლება განხილულ იქნას ერთ ჯგუფში, ამიტომ ყველაზე ცალ ცალკე აღარ შევჩერდები;
არაფრის შეცვლა არ არის საჭირო, ბოლო ხაზის შემდეგ დავწეროთ ეს კოდი
cout < <"/////////////////////////////////////////////////////////////////////////////////////////////////////////////////"< < endl;

int array[10];

double darray[5];

char TextMas[20];

char Text2[]="ganusazgvreli sididis masivi";

array[0]=10;

array[1]= 15;

array[8]=25;

darray[2]=9.27;

darray[1]=23.5;

darray[4]=22.87;

flomas[2]=22.987;

flomas[8]=12.55;

flomas[0]=10;

TextMas[0]='I';

TextMas[1]='L';

TextMas[2]='I';

TextMas[3]='A';

cout < < "1.int masivis pirveli elementi = "< < array[0 ] < < endl;

cout < < "2.int masivis meore elementi = " << array[1 ]< < endl;

cout < < "3.int masivis meSvide elementi = " < < array[8] < < endl;

array[2]=array[0] + array[8] *array[1];

cout < < "4.int masivis mesame elementi = " < < array[2] < < endl;

cout < < "5.double masivis mesame elementi = " < < darray[2] < < endl;

cout < < "6.double masivis meore elementi = " < < darray[1] < < endl;

cout < < "7.double masivis mexuTe elementi = " < < darray[4] < < endl;

darray[0]=(darray[2] + darray[4] )/(darray[1] + 30.76);

cout < < "8.double masivis pirveli elementi = " < < darray[0] < < endl;

cout < < "9.char masivis pirveli elementi = " < < TextMas [0] < < endl;

cout < < "10.char masivis meore elementi = " < < TextMas [1] < < endl;

cout < < "11.char masivis mesame elementi = " < < TextMas [2] < < endl;

cout < < "12.char masivis meotxe elementi = " < < TextMas [3] < < endl;

cout < < "13.ganusazgvreli masivi = "< < Text2 < < endl;

C ++ დამწყებებს- 3 გაკვეთილი

DL1MP1K — Thu, 09 Feb 2012 15:42:18 GMT

იმისათვის რომ უფრო თვალნათლივ დავინახოთ ოპერატორების მიერ გამოყოფილი ადგილის სიდიდეები გავაკეთოთ პატარა პროგრამა. გაუშვათ visual studio და მენიუ file ავირჩიოთ new გამოჩნდება ფანჯარა კონსტრუქტორების ჩამონათვალით .

მოვნიშნოთ Win32 Console Aapplication და მინიშნებულ ადგილას დავარქვათ რამე ჩვენ პროექტს , როგორც ჩემს შემთხვევაში MyProg , ქვედა ფანჯარაში ავირჩიოთ ლოკაციის ადგილი თუ სად შეიქმნას დირექტორია რომელშიც ჩვენი პროექტი განთავსდება. არჩეულ ადგილას შეიქმნება ახალი საქაღალდე იმავე სახელით რაც პროექტს დავარქვით ანუ MyProg . ყველა მოთხოვნის შემდეგ ღილაკი OK და კონსტრუქტორი შემოგვთავაზებს პროგრამის ტიპის არჩევას ამ ფანჯარაში არაფრის შეცვლა არ არის საჭირო უბრალოდ დავასრულოთ ღილაკი FINISH ით პროექტის შექმნა. კონსტრუქტორი გვიპატაკებს რომ შექმნის მარტო პროექტს და დანარჩენი თქვენ იცითო, ჩვენც არ ვეკამათებით და ვეთანხმებით, სხვანაირად არაფერი არ გამოვა. ბოლოსდა ბოლოს პროექტი შექმნილია მაგრამ მასში არაფრის გაკეთება არ შეიძლება რადგანაც დასამატებელია ფაილი რომელშიც კოდი უნდა ჩაიწეროს.
ამიტომაც მენიუ Project -ში ვირჩევთ პუნქტს Add Tu project -> New რის შემდეგაც გამოჩნდება ფაილთა სია რომლის დამატებაც შესაძლებელია პროექტში

მოვნიშნავთ C++ Source File და ფანჯარაში File name ვარქმევთ ფაილს სახელს რაც მოგვეხასიათდება. ვადასტურებთ ყოველივე ჩვენს მიერ ჩადენილს და ფაილი პროექტში გამოჩნდება აი ასე

მართალია პროექტს ფაილი დავუმატეთ მაგრამ სამწუხაროა რომ ფაილში არაფერი არ წერია . თუ არ ჩავწერეთ არც ჩაიწერება. ჩვენც ვიწყებთ წერას.
მაკროპროცესორი # include განაპირობებს მის შემდეგ მითითებული ფაილის ჩართვას ტრანსილირებულ ტექსტში. მისი სინტაქსია;
# include < iostream.h >
//ამ შემთხვევაში მიცემულია ფაილი რომელიც visual studios სპეციალურად განკუთვნილ საქაღალდეშია მოთავსებული ამ საქაღალდესაც იგივე სახელი აქვს რაც მაკროპროცესორს და მისი ნახვა შეიძლება visual studios პროგრამფაილების საქაღალდეში ასეთი ფრჩხილების გაკეთება თავისთავად მიანიშნებს იმაზე რომ პროექტსი ჩართულია სათაო ფაილი ( header File) visual studios სისტემიდან
# include "MyClass.h"// ამ სახით ჩართული ფაილი შეიძლება იყოს როგორც visual studios სისტემიდან ასევე საკუთარი, ჩვენს მიერ შექმნილი სათაო ფაილი იმ შემთხვევაში თუ ის ფაილი რომელსაც მაკროპროცესორის შემდეგ ვწერთ იმყოფება იმავე საქაღალდეში რომელშიც ტრანსლირებული პროექტია მოთავსებული(ეს არ ეხება visual studios ფაილებს), სხვა შემთხვევაში უნდა მიეთითოს მთლიანი გზა ფაილამდე თუკი იგი სხვა საქაღალდიდან არის ჩართული.
მას შემდეგ რაც ფაილი დავამატეთ პროექტს უკვე შეგვიძლია ჩავწეროთ მაკროპროცესორი რათა მისახწევი გახდეს იმ ფუნქციათა გამოყენება რომელიც ვიზუალ სტუდიოს სტანდარტულ ბიბლიოთეკაშია რეალიზებული.
#include < iostream.h >
void main()

{

cout <<" \t\t**************** HELOO C++ **************** "< < endl;

int a=0,B;

char Tx='s';

double Doi=8.9;

float mani=10.45;

B=sizeof(Tx);

cout<<"char mexsierebaSi ikavebs --- "< < B < <" baits "< < endl;

B=sizeof(a);

cout <<"Int mexsierebaSi ikavebs --"< < B < <" baits" < < endl;

B=sizeof(Doi);

cout << "double mexsierebaSi ikavebs --- "< < B < <" baits"< < endl;

B=sizeof(mani);

cout << "float mexsierebaSi ikavebs --- "< < B < <" baits"< < endl;

}

მივყვეთ და განვიხილოთ კოდი ნაბიჯ-ნაბიჯ. პირველ ხაზში ჩავრთეთ სათაო ფაილი რომელშიც რეალიზებულია ეკრანზე გამოყვანის ფუნქციები აქედან მაქვს საშუალება გამოვიყენო ფუნქცია cout<< ამის გარდა კიდევ ბევრი ფუნქციაა რეალიზებული ამ სათაო ფაილში მაგრამ მე ჯერ სხვა არ მჭირდება. შემდეგ ხაზში იწყება პროგრამა ფუნქცია main() როგორც მისი დასახელებიდანაც ჩანს არის მთავარი ფუნქცია, იგი გლობალურია და რაიმე სათაო ფაილს არ მოითხოვს, მისი მოქმედება იწყება გახსნილი ფიგურული ფრჩხილიდან და მთავრდება დახურულ ფრჩხილთან. შეიძლებოდა უბრალოდ დაგვეწერა მარტო ფუნქცია მაინი თავისი ფრჩხილებით და პროგრამა უკვე გაეშვებოდა თუმცა არაფერს არ გააკეთებდა. შემდეგ ხაზში უბრალოდ გამოგვყავს მისალმება სუფთა ესთეთიკური თვალსაზრისით. როგორც ხედავთ ტექსტი ბრჭყალებშია მოთავსებული რაც მის უცვლელად გამოყვანის გარანტიაა და თანაც ბრჭყალების გარეშე იგი არ აღიქმება ტრანსლიატორის მიერ როგორც ტექსტი. ტექსტის თავში \t\t გაკეთებულია ტაბულაციის მიზნით რათა ტექსტი მარცხენა კიდედან ეკრანის ცენტრისკენ გადმოადგილდეს, ბოლო სიტყვა endl - ს მიზანია კურსორის შემდეგ ხაზზე გადმოტანა , წინააღმდეგ შემთხვევაში ყველა ტექსტი ერთ ხაზზე გამოვიდოდა რაც მაინცდამაინც ლამაზი არ იქნებოდა. შემდეგი ხაზიდან იწყება ცვლადების გამოცხადება, ოპერატორის შემდეგ შეიძლება ცვლადების ჩამონათვალი გაკეთდეს, ოღონდ ისინი ერთმანეთისაგან მძიმით უნდა გამოიყოს. ცვლადების გამოცხადების ბოლოს აუცილებლად უნდა დაისვას წერტილ მძიმე რომელსაც ცარიელი ოპერატორი ქვია და ყოველი გამოცხადების ბოლოში ისმევა. ასევე გლობალური ფუნქცია B=sizeof(ცვლადი) არ საჭიროებს რაიმე სათაო ფაილს . მისი მიზანია გაზომოს მის ფრჩხილებში მოთავსებბული ცვლადის სიდიდე მეხსიერებაში და აბრუნებს მთელ რიცხვს ცვლადის ზომას ბაიტებში, ამიტომაც იგი int ს გაუტოლე , ყოველი გამოძახების შემდეგ B ს მნიშვნელობა გამოგვყავს ეკრანზე.