Dalam C++, apabila kita bekerja dengan pengendali, terdapat urutan di mana semua operasi dilakukan. Keutamaan pengendali digunakan apabila bekerja dengan berbilang operator dalam ungkapan kod kami. Sebagai contoh, semasa bekerja dengan operator tambah, tolak, darab dan bahagi, operasi darab dan bahagi dilakukan terlebih dahulu dari kiri ke kanan kerana ia mempunyai keutamaan yang tinggi, dan operasi tambah dan tolak dilakukan seterusnya dari kiri ke kanan seperti yang telah dilakukan. keutamaan yang rendah daripada pendaraban dan pembahagian. Tetapi jika ungkapan itu hanya mengandungi operator tambah dan tolak, operasi hanya dilakukan dari kiri ke kanan. Di sini, kami akan menunjukkan jadual keutamaan operator dan contoh keutamaan operator.
Keutamaan Operator bagi Operasi Aritmetik
| Operasi | Operator | Keutamaan |
|---|---|---|
| kurungan | () | Tanda kurung ini dikendalikan. |
| pendaraban, pembahagian, modulus | *, /, % | Operasi ini dilakukan dan susunannya adalah dari kiri ke kanan. |
| penambahan, penolakan | +, – | Operasi ini dilakukan pada penghujung dan urutannya adalah dari kiri ke kanan. |
Contoh 1:
Mari mulakan kod kami dengan memasukkan fail pengepala bernama 'iostrem'. Banyak fungsi diisytiharkan dalam fail pengepala 'iostream' ini yang akan kami gunakan dalam kod kami. Di bawahnya, kami menaip 'ruang nama std' dan memanggil 'main()' di hadapan. Di sini dalam 'main()', kami mengisytiharkan pembolehubah bernama 'i', 'j', dan 'k' dengan 'int' dan nilai yang kami luluskan di sini ialah '10', '37', dan '29', masing-masing. Kami juga mengisytiharkan pembolehubah 'r' di mana hasilnya disimpan.
Selepas ini, kami menaip ungkapan menggunakan pengendali '+, '/', dan '-'. Seperti yang telah kami jelaskan sebelum ini, operasi ini dilakukan dalam urutan. Ungkapan yang kami letakkan di sini ialah 'i + j / k - j' di mana pembahagian dilakukan terlebih dahulu, dan kemudian operasi tambah dan tolak dilakukan. Ia memaparkan hasil dalam nilai integer semasa kami mengisytiharkan pembolehubah 'r' sebagai integer. Dalam yang berikut, kami memaparkan hasil pengiraan menggunakan 'cout'.
Kod 1:
#includemenggunakan ruang nama std ;
int utama ( )
{
int i = 10 , j = 37 , k = 29 , r ;
r = i + j / k - j ;
cout << 'Hasil ungkapan yang diberikan ialah = ' << r ;
kembali 0 ;
}
Pengeluaran:
Output adalah '-26' selepas melakukan semua operasi. Keputusan ini dikira mengikut keutamaan operator yang disediakan oleh bahasa C++.
Contoh 2:
Dalam kod ini, selepas memasukkan fail pengepala dan menggunakan 'main()', kami memulakan pembolehubah 'int' dengan nama 'val1' dan meletakkan ungkapan di mana kami menaip '9 + 18 * 7'. Di sini, ia melakukan pendaraban terlebih dahulu dan kemudian menambah '9' pada nilai yang didarab. Dalam perkara berikut, kami memulakan 'int val2' dengan '9 + (18 * 7)'.
Di sini, kurungan diselesaikan terlebih dahulu. Kemudian, penambahan dilakukan. Selepas ini, kami juga memulakan 'int val3' dengan ungkapan '(9 + 18) * 7'. Dalam ungkapan ini, kurungan sekali lagi dikendalikan dahulu dan kemudian pendaraban dilakukan. Nilai ungkapan adalah sama tetapi ia memberikan hasil yang unik kerana keutamaan pengendali. Sekarang, kami bergerak ke hadapan dan mencetak semua keputusan yang disimpan dalam pembolehubah 'val1', 'val2', dan 'val3' dengan bantuan 'cout'.
Kod 2:
#includemenggunakan ruang nama std ;
int utama ( ) {
int pilihan1 = 9 + 18 * 7 ;
int val2 = 9 + ( 18 * 7 ) ;
int val3 = ( 9 + 18 ) * 7 ;
cout << 'Keputusan pertama menunjukkan = ' << pilihan1 << endl ;
cout << 'Keputusan kedua menunjukkan = ' << val2 << endl ;
cout << 'Keputusan ketiga menunjukkan = ' << val3 << endl ;
kembali 0 ;
}
Pengeluaran:
Hasil yang kita dapat selepas mengira ungkapan yang diberikan adalah seperti berikut. Kita dapat melihat bahawa hasil ketiga tidak sama dengan dua yang lain, walaupun nilainya sama. Ini disebabkan oleh keutamaan pengendali yang digunakan pada pengendali ungkapan.
Contoh 3:
Di sini, kami memulakan pembolehubah yang berbeza dengan nilai yang berbeza, dan jenis data semua pembolehubah ini ialah 'int'. Kami mempunyai pembolehubah integer 'a', 'b', 'c', dan 'd' masing-masing dengan nilai '14', '9', '15', dan '29'. Selepas ini, kami memulakan 'int R1' dan ungkapan yang kami letakkan di sini ialah 'a + b) * c / d'. Tanda kurung diselesaikan terlebih dahulu. Kemudian, operasi darab dan bahagi dilakukan. Kami juga memaparkan hasil di bawah ini. Kemudian, kita mempunyai 'int R2' dengan ungkapan 'a - b * (d + a) + c'. Di sini, ia juga menyelesaikan kurungan dan kemudian penolakan dan penambahan dilakukan mengikut keutamaan operator. Kami juga mencetak hasilnya dan memulakan 'int R3' di mana ungkapan 'b - d + c * a' ditaip. Dalam ungkapan ini, pendaraban dilakukan terlebih dahulu, kemudian penolakan dan penambahan dilakukan. Hasil ungkapan ini juga dipaparkan dalam perkara berikut. Sekarang, kita mempunyai ungkapan terakhir, 'd + (a * b) / a', yang hasilnya disimpan dalam pembolehubah 'R4'. Dalam ungkapan ini, kurungan diselesaikan terlebih dahulu dan kemudian dibahagikan. Pada akhirnya, penambahan dilakukan. Hasil ungkapan ini ditunjukkan seperti berikut:
Kod 3:
#includemenggunakan ruang nama std ;
int utama ( ) {
int a = 14 ;
int b = 9 ;
int c = lima belas ;
int d = 29 ;
int R1 = ( a + b ) * c / d ;
cout << '(a + b) * c / d ' << 'memberi = ' << R1 << endl ;
int R2 = a - b * ( d + a ) + c ;
cout << 'a - b (d + a) + c' << 'memberi = ' << R2 << endl ;
int R3 = b - d + c * a ;
cout << 'b - d + c * a ' << 'memberi = ' << R3 << endl ;
int R4 = d + ( a * b ) / a ;
cout << 'd + (a * b) / a ' << 'memberi = ' << R4 << endl ;
kembali 0 ;
}
Pengeluaran:
Berikut ialah hasil pengiraan ungkapan yang dinyatakan sebelum ini. Kami mendapat hasil ini kerana pengendali dalam ungkapan mempunyai keutamaan pengendali digunakan untuk mereka:
Contoh 4:
Kami memulakan pembolehubah 'a1', 'b1', 'c1', 'd1', 'e1', dan 'f1' di sini dengan nilai integer '64', '90', '11', '27', '34', dan '98', masing-masing. Kami memulakan 'int result1' di sini dengan ungkapan 'a1 + b1 - c1) * d1 / f1' dan hasilnya disimpan dalam pembolehubah 'result1'. Di sini, kurungan diselesaikan terlebih dahulu. Kemudian, operasi yang selebihnya dikira secara berurutan. Kemudian, kami mencetak 'hasil1'. Dengan cara yang sama, kami mengira ungkapan dan menyimpannya dalam pembolehubah yang berbeza. Kemudian, kami mencetak semua keputusan secara berasingan, menunjukkan cara keutamaan pengendali berfungsi.
Kod 4:
#includemenggunakan ruang nama std ;
int utama ( ) {
int a1 = 64 ;
int b1 = 90 ;
int c1 = sebelas ;
int d1 = 27 ;
int e1 = 3. 4 ;
int f1 = 98 ;
int keputusan1 = ( a1 + b1 - c1 ) * d1 / f1 ;
cout << 'Hasil 1 ialah' << keputusan1 << endl ;
int hasil2 = a1 + ( f1 * b1 ) / e1 ;
cout << 'Hasil 2 ialah' << hasil2 << endl ;
int keputusan3 = e1 + d1 + a1 - c1 * b1 / a1 ;
cout << 'Hasil 3 ialah' << keputusan3 << endl ;
int keputusan4 = a1 - f1 + ( b1 - d1 ) * c1 ;
cout << 'Hasil 4 ialah' << keputusan4 << endl ;
int keputusan5 = ( f1 + ( a1 * ( b1 + a1 ) - f1 ) * a1 + e1 ) ;
cout << 'Hasil 5 ialah' << keputusan5 << endl ;
kembali 0 ;
}
Pengeluaran:
Output kod yang diberikan diberikan di sini yang menunjukkan hasil semua ungkapan yang kami masukkan sebelum ini. Semua ungkapan dikira dengan mengikut peraturan keutamaan tertib.
Kesimpulan
Kami melihat 'keutamaan C++' di sini di mana kami mengkaji dengan mendalam susunan pengendali di mana mereka dikira dalam pengaturcaraan C++. Kami juga menunjukkan susunan pengendali dalam bentuk jadual dan kemudian melakukan banyak contoh di mana kami mengetahui cara ungkapan diselesaikan mengikut keutamaan tertib dalam pengaturcaraan C++.