ოპერატორები C ++ - ში


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

  • არითმეტიკის ოპერატორები
  • ურთიერთობის ოპერატორები
  • ლოგიკური ოპერატორები
  • Bitwise ოპერატორები
  • დავალების ოპერატორები
  • სხვა ოპერატორები

არითმეტიკის ოპერატორები

ამ ტიპის ოპერატორებზე განხილულია სტატიაში C ++ ცვალებადი ტიპები. არითმეტიკის ძირითადი ოპერატორებია +, -, *, /,%. ამ ოპერატორების გარდა, არსებობს 2 ოპერატორი ცვლადის მნიშვნელობის გაზრდის და შემცირებისთვის. ნამატის ოპერატორია ++ და შემცირების ოპერატორი არის -. ეს ოპერატორები შეიძლება გამოყენებულ იქნას როგორც ცვლადის (პრეფიქსი) და ცვლადის შემდეგ (postfix). მაგალითად, ცვლადის მნიშვნელობების შეცვლა შეგიძლიათ შემდეგი გზით:

int a = 0;
++a; //now "a" is 1
cout << a << endl;
a++; //now "a" is 2 
cout << a << endl;
--a; //decrement a. it's 1 now 
cout << a << endl;
--a; //decrement a; it is 0 now 
cout << a;
cin.ignore();

პროგრამის შედეგი უნდა იყოს შემდეგი
1
2
1
0

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

  
a = ++b; // a==4, b==4
a = b++; // a==3, b==4

ქვემოთ მოცემული კოდი აჩვენებს ცვლადების მნიშვნელობას წინასწარი და პოსტიანი ზრდის მიხედვით.
  
int main()
{
  	int i = 0;
	while(i < 10)
	{
		cout << i++; //post increment
	}
	cout << endl;
	i = 0;
	while(i<10)
	{
		cout << ++i; //pre increment
	}	
	return 0;
}

ქვემოთ მოცემულია ზემოთ მოცემული პროგრამის შედეგები

0123456789
12345678910

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

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

ოპერატორი
აღწერა
 ==  თანაბარი  აბრუნებს true- ს, თუ ოპერანდები ტოლია. წინააღმდეგ შემთხვევაში ყალბია.
 !=  ტოლი არ არის  აბრუნებს სიმართლეს, თუ ოპერანდები არ არის ტოლი. წინააღმდეგ შემთხვევაში ყალბია.
 <  ნაკლები  აბრუნებს true- ს, თუ operand1 ნაკლებია, ვიდრე operand2. წინააღმდეგ შემთხვევაში ყალბია.
 >  Უფრო მეტი ვიდრე  აბრუნებს true- ს, თუ operand1 მეტია, ვიდრე operand2. წინააღმდეგ შემთხვევაში ყალბია.
 <=  ნაკლებია ან ტოლი  აბრუნებს სიმართლეს, თუ ოპერადი 1 ნაკლებია ოპერანდის 2-ზე ან ტოლია ოპერანდის 2. წინააღმდეგ შემთხვევაში, მცდარია.
 >=  მეტია ან ტოლი  აბრუნებს სიმართლეს, თუ ოპერადი 1 მეტია ოპერანდის 2-ზე ან ტოლია ოპერანდის 2. წინააღმდეგ შემთხვევაში, მცდარია.

ახლა ჩვენ შეგვიძლია შევეცადოთ ამ ოპერატორებს. გახსოვდეთ, რომ "cout" გამოდის 1-ის ჭეშმარიტი და 0-ისთვის ცრუ:

int three = 3;
int five = 5;
cout << " 3 is equal to 5 = " << (three == five) << endl;
cout << " 3 is not equal to 5 = " << (three != five) << endl;
cout << " 3 is less than 5 = " << (three < five) << endl;
cout << " 3 is greater than 5 = " << (three > five) << endl;
cout << " 3 is not less than 5 = " << (three >= five) << endl;
cout << " 3 is not greater than 5 = " << (three <= five) << endl;

ზემოთ მოცემული კოდის შედეგია:

3 უდრის 5 = 0-ს
3 არ არის 5 = 1 ტოლი
3 ნაკლებია, ვიდრე 5 = 1
3 მეტია ვიდრე 5 = 0
3 არანაკლებ 5 = 0
3 არ აღემატება 5 = 1-ს

ლოგიკური ოპერატორები

C ++ უზრუნველყოფს 3 ოპერაციას ლოგიკური ალგებრისგან:
და (შეერთების) ოპერატორი &&
ან (დაშლა) ოპერატორი ||
არა (უარყოფა) ოპერატორი !

2 და x ც y ცვლადის ლოგიკური ოპერაციების შედეგი მოცემულია შემდეგ ცხრილებში:

X

Y

X && Y

X || ი

ყალბი

ყალბი

ყალბი

ყალბი

მართალია

ყალბი

ყალბი

მართალია

ყალბი

მართალია

ყალბი

მართალია

მართალია

მართალია

მართალია

მართალია

X

!X

ყალბი

მართალია

მართალია

ყალბი

აქ მოცემულია ლოგიკური ოპერატორების გამოყენების მაგალითი:

//initialize x with true
bool x = true;
//initialize y with false
bool y = false;
//now x is x AND y (false)
x = x&&y;

Bitwise ოპერატორები

Bitwise ოპერატორები ლოგიკური ოპერატორების მსგავსია, მაგრამ ისინი ასრულებენ ერთსა და იმავე ლოგიკურ ოპერაციებს ბიტებზე. მეხსიერების ყველა მონაცემი წარმოდგენილია ორობითი ფორმით. ასე რომ, ბიტების სახით ცვლადები შეიცავს მხოლოდ 0-ს ან 1-ს. შემდეგი ცხრილი წარმოადგენს ბიტისტური ოპერატორების ოპერაციების შედეგს:

X Y X & Y X | ი X ^ Y
0 0 0 0 0
0 1 0 1 1
1 1 1 1 0
1 0 0 1 1

C ++ უზრუნველყოფს შემდეგი bitwise ოპერატორების გამოყენების შესაძლებლობას:

ორობითი და ოპერატორი "&"

შედეგად მიღებული ბიტი მითითებულია 1-ზე და მხოლოდ იმ შემთხვევაში, თუ ორივე ცვლადს აქვს 1 შესაბამისი ბიტი. ორობითი და:

10100110 & 00101010 = 00100010

ორობითი ან ოპერატორი “|”

შედეგად მიღებული ბიტი დაყენებულია 1-ზე, თუ ცვლადებიდან ერთს აქვს შესაბამის ბიტში 1. ორობითი მაგალითი |:

10100110 | 00101010 = 10101110

ორობითი XOR ოპერატორი “^”

შედეგის ბიტი 1-ზეა დაყენებული, თუ ცვლადებიდან მხოლოდ ერთს აქვს შესაბამისი ბიტი. ორობითი xor- ის მაგალითი:

10100110 ^ 00101010 =  10001100

ორობითი NOT ოპერატორი “”

ცვლის ცვლადის ბიტებს. Მაგალითად:

~10100110 = 01011001

ორობითი მარცხენა ცვლის ოპერატორი “<< N”

გადავა 'N' რაოდენობის ბიტი მარცხნივ. მარტივი სიტყვებით, მარცხნიდან ამოიშლება ბიტების N რაოდენობა და მარჯვნივ დაემატება ნულების N რიცხვი. Მაგალითად:

10100110 << 3 = 00110000

ორობითი მარჯვენა ცვლის ოპერატორი ”>> N”

გადააქვს 'N' რაოდენობის ბიტი მარჯვნივ. უბრალო სიტყვებით, მარჯვენა ბიტიდან N რაოდენობის ბიტი წაიშლება და მარცხნივ დაემატება ნულის N ნომერი. Მაგალითად:

10100110 >> 2 = 00101001

დავალების ოპერაციები

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

int k = 9;
//normal way of adding value
k = k + 7;
//you can add value in a more compact way by combining two operators
//Composite assignment will be
k += 7; // this is equal to k = k + 7

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

კომპოზიტური დავალება-ოპერატორი
 Expression2

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

მოდით X = 10 თავდაპირველად ქვემოთ მოცემული მაგალითებისათვის

კომპოზიტური დავალება
ოპერატორი
მაგალითი
ტოლფასია
გამოყვანის
 +=  X + = 2  X = X + 2  12
 -=  X - = 2  X = X - 2  8
 *=  X * = 2  X = X * 2  20
 /=  X / = 2  X = X / 2  5
 %=  X% = 2  X = X% 2  0
 << =  X << = 2  X = X << 2  40
 >> =  X >> = 2  X = X >> 2  2
 &=  X & = 2  X = X და 2  2
 ^=  X ^ = 2  X = X ^ 2  8
 |=  X | = 2  X = X | 2  10

უფრო ეფექტური კოდისთვის შემოთავაზებულია კომპოზიტური დანიშნულების ოპერატორის გამოყენება

X +=10; // will be faster than X = X + 10
X = X + 10; // will be slower than X += 10

სხვა ოპერატორები

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

ოპერატორის "sizeof"

ოპერატორი sizeof აბრუნებს ცვლადის ან ტიპის ზომას. აქ "ზომა" ნიშნავს მეხსიერების რამდენ ბაიტს იყენებს ცვლადი ან ტიპი.

cout << sizeof(int) << endl; // will print 4
cout << sizeof(x) << endl; // will print size of x

კომა (",") ოპერატორი

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

double a = 2.0,
       b = 4.3,
       c = 2;

ოპერატორების უპირატესობა C ++ - ში

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

მაგალითად a = 2 + 3 * 5; აქ მიენიჭება 17-ს და არა 25-ს, რადგან ოპერატორს * აქვს მეტი უპირატესობა ვიდრე +, ასე რომ 3 * 5 ჯერ გამრავლდება და შემდეგ 2 ემატება გამრავლების შედეგი 3 * 5.

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

ოპერატორი
კატეგორია
ასოციაციურობა
პრეცედენტი
 () [] ->. ++ - - postfix Მარცხნიდან მარჯვნივ
უმაღლესი
 + -! ~ ++ - - (ტიპი) * & ზომა უნარი მარჯვნივ მარცხნივ
 * /% მრავლობითი Მარცხნიდან მარჯვნივ
 + - დანამატები Მარცხნიდან მარჯვნივ
 << >> >> გადაიტანოს Მარცხნიდან მარჯვნივ
 <<=>> = ურთიერთობრივი Მარცხნიდან მარჯვნივ
 ==! = თანასწორობა Მარცხნიდან მარჯვნივ
 & ოდნავ და Მარცხნიდან მარჯვნივ
 ^ Bitwise XOR Მარცხნიდან მარჯვნივ
 | Bitwise ან Მარცხნიდან მარჯვნივ
 && ლოგიკური და Მარცხნიდან მარჯვნივ
 || ლოგიკური ან Მარცხნიდან მარჯვნივ
 ?: პირობითი მარჯვნივ მარცხნივ
 = + = - = * = / =% = >> = << = & = ^ = | = დავალება მარჯვნივ მარცხნივ
 , მძიმით Მარცხნიდან მარჯვნივ
Უმდაბლესი