Toán tử trong C#

[uocmo_kchodoi]

Tiếp theo trong series bài giảng về C# chúng ta sẽ đi tìm hiểu về toán tử trong C#. Người ta sử dụng các toán tử để thực hiện phép tính trên biến và giá trị.

1. Toán tử (Operator) trong C#

Đối với C# có nhiều loại toán tử được cung cấp sẵn:

Toán tử số học

Các toán tử số học thường được sử dụng cùng với các giá trị số để thực hiện các phép toán số học như: cộng, trừ, nhân, chia lấy phần nguyên, chia lấy phần dư,...

Các phép toán này không thể thiếu trong mọi ngôn ngữ lập trình nào và C# cũng vậy.

Giả sử ta có hai biến x và y. Bảng sau đây miêu tả kết quả về của hai biến x và y:

Toán tử ----------------- Tên ---------------- Ví dụ -------------------- Kết quả
.......+ ...........................Cộng..................... x+y ..........................Tổng của x và y
....... - ............................ Trừ .......................x-y ..........................Hiệu của x và y
.......* .............................Tích .......................x*y.......................... Tích của x và y
......./........................... ..Chia....................... x/y ..........................Phần nguyên của thương x chia y
......% .........................Chia dư ...................x%y ..........................Phần dư của thương x chia y

Lưu ý: Khi chia số thực có kiểu như float, double hay decimal thì kết quả chia được là một số thực.

Giả sử x = 5 và y = 28 ta có ví dụ sau:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace freetuts.net
{
class freetuts
{
static void Main(string[] args)
{
int x = 5;
int y = 28;
Console.WriteLine("\nTong cua hai so y+x = "+(x+y));
Console.WriteLine("\nhieu cua hai so y-x = "+(y-x));
Console.WriteLine("\nTich cua hai so y*x = "+y*x);
Console.WriteLine("\nthuong cua hai so y/x = "+y/x);
Console.WriteLine("\nPhan du cua thuong y/x = "+y%x);

Console.WriteLine("\nfreetuts chuc ban hoc tot !!!");
Console.ReadKey();
}
}
}
Sau khi biên dịch ta được:

Toán tử gán

Mình nghĩ toán tử gán đã khá quen thuộc với chúng ta, hầu hết các chương trình ví dụ trong series chúng ta đều có sử dụng phép gán. Toán tử gán làm cho toán hạng bên trái thay đổi giá trị bằng với giá trị của toán hạng bên phải. Theo mình thì đây là dạng toán tử đơn giản và thông dụng nhất.

Chúng ta có một số toán tử gán được sử dụng trong C#:

Toán tử............................................ Ví dụ...................................... Kết quả
.....=.................................................... x=y ........................................Gán giá trị y cho x
....+=.................................................. x+=y ......................................Gán giá trị x = x+y
....-= ....................................................x-=y .......................................Gán giá trị x = x-y
....*= ...................................................x*=y ........................................Gán giá trị x = x*y
..../= ....................................................x/=y ........................................Gán giá trị x = x/y
....%= .................................................x%=y....................................... Gán giá trị x = x%y
...<<=................................................ x<<=3 .......................................Gán giá trị x = x<<3
....>>=............................................... x>>=3 .......................................Gán giá trị x = x>>3
.....&=................................................. x&=2 .................................Gán giá trị x = x&2 (Phép AND bit)
.....^= ..................................................x^=2........................... Gán giá trị x = x^2 (Phép OR loại trừ bit)
.....|= ...................................................x|=2.................................. Gán giá trị x = x|2 (Phép OR bit)


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace freetuts.net
{
class freetuts
{
static void Main(string[] args)
{
int x = 5;
int y = 28;
Console.WriteLine("\nx = "+x);
Console.WriteLine("\ny = "+y);
y += x;
Console.WriteLine("\ny= y + x = "+y);
y -= x;
Console.WriteLine("\ny= y - x = " + y);
y *= x;
Console.WriteLine("\ny= y * x = " + y);
y /= x;
Console.WriteLine("\ny= y / x = " + y);
y %= x;
Console.WriteLine("\ny= y % x = " + y);

Console.WriteLine("\nfreetuts chuc ban hoc tot !!!");
Console.ReadKey();
}
}
}
Kết quả sau khi biên dịch chương trình:

Ta dễ dàng thấy giá trị của y thay đổi sau mỗi lần gán trị.

Toán tử tăng giảm tiền tố và hậu tố:

Giả sử ta muốn tăng giá trị của một biến x rồi gán nó cho biến y, ta làm như sau:

y = x++; hoặc y = ++x;

Vậy đâu là điểm khác biệt giữa 2 cú pháp trên ? Giả sử cho giá trị của biến x = 9 ta cùng đi phân tích nhé.

Khi lệnh y = x++; được thực hiện thì phép gán sẽ được thực hiện trước tiên và sau đó mới đến phép toán tăng. Ta gọi đây là tăng hậu tố, và giá trị của các biến bây giờ là x = 10 và y = 9.

Còn đối với lệnh y = ++x; phép toán tăng sẽ được thực hiện trước rồi mới đến toán tử gán. Ta gọi đây là tăng tiền tố, các giá trị của x và y bây giờ là như nhau và đều bằng 10.

Tương tự với giảm hậu tố hay giảm tiền tố cũng như vậy nhé.

Toán tử logic
Đôi lúc chúng ta muốn kết hợp nhiều điều kiện với nhau ví dụ như bắt buộc cả hai biểu thức điều kiện đều đúng hoặc chỉ cần một biểu thức đúng thì mới thực hiện một lệnh gì đó. Trong C# hỗ trợ 3 toán tử logic như sau:

Toán tử ............Ký hiệu................... Cú pháp........................ miêu tả

AND ....................&& ...................<BT1> && <BT2>......... Trả về true nếu cả 2 biểu thức đều đúng
OR........................ || .........................<BT1>||<BT2> ..........Trả về true nếu 1 trong 2 biểu thức đúng
NOT ......................!................................... !(BT) ..............Trả về phủ định của biểu thức trong ngoặc

Toán tử quan hệ

Các toán tử quan hệ thường được dùng để so sánh giữa hai giá trị, và sau đó trả về kết quả là một giá trị logic kiểu boolean (true hoặc false).

Giả sử ta có biến x = 5 và y = 3. Các toán tử trong C# được trình bày như bản dưới đây:

Toán tử ...................Ký hiệu.....................Biểu thức so sánh .................Kết quả so sánh

So sánh bằng .............== .......................................x==5 ...................................true
Không bằng................. != ........................................x!=y ..................................true
Lớn hơn ...................... >.......................................... x>y.................................... true
Lớn hơn hay bằng .......>= ........................................x>=y ...................................true
Nhỏ hơn ......................< ............................................x<y .....................................false
Nhỏ hơn hay bằng....... <= .....................................x<=y....................................... false

Lưu ý: toán tử so sánh bằng (==) được ký hiệu bởi hai dấu bằng dính liền nhau và không có bất kỳ khoảng cách nào giữa chúng. Trình biên dịch C# xem đây là một toán tử.

Toán tử hỗn hợp

Ta có một số toán tử khác cũng khá là quan trọng và được hỗ trợ bởi ngôn ngữ C# như sau:

& :Trả về địa chỉ của một biến &x
* :Trỏ đến một biến *x
?: <Biểu thức điều kiện > ? <Biểu thức thứ 1> : <Biểu thức thứ 2>
VD: x==2?x=3:x=4; nếu x bằng 2 thì gán trị mới x=3 ngược lại thì x=4
is: xác định đối tượng là một kiểu cụ thể hay không VD: if(iphone is apple) kiểm tra nếu iphone thuộc lớp apple thì...
as: Ép kiểu mà không tạo exception nếu việc ép kiểu thất bại
VD: Object obj = new StringReader("freetuts.net");
String Reader r = obj as StringReader;
typeof() trả về kiểu của một lớp.
VD: typeof(StreamReader)
sizeof() trả về kích cỡ của một kiểu dữ liệu
VD: sizeof(int), kết quả trả về là 4

Một ví dụ nhỏ tổng hợp toán tử quan hệ, toán tử logic và toán tử hỗn hợp:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace freetuts.net
{
class freetuts
{
static void Main(string[] args)
{
int x = 5;
int y = 28;
Console.WriteLine((x==5&&y==28) ? "\nthoa man ca 2 dieu kien" : "\nkhong thoa man");
Console.WriteLine("\nfreetuts chuc ban hoc tot !!!");
Console.ReadKey();
}
}
}


Biên dịch chương trình ta được:

Ở ví dụ trên ta đã tổng hợp được các toán tử gồm: logic, quan hệ và hỗn hợp.

Đầu tiên kiểm tra x==5 && y==28 hay không nếu đúng thì trả về chuỗi "thoa man ca hai dieu kien" neu sai thi tra ve "khong thoa man". Và dĩ nhiên ta thấy được điều kiện là đúng vậy chuỗi xuất ra màn hình sẽ là: "thoa man ca hai dieu kien" .

2. Thứ tự ưu tiên các phép toán

Giả sử trong trường hợp có nhiều phép toán trong một biểu thức thì trình biên dịch phải xác định thứ tự thực hiện các toán tử. Các luật về độ ưu tiên xử lý sẽ bảo trình biên dịch biết được toán tử nào được thực hiện trước trong biểu thức.

Bảng dưới đây thể hiện thứ tự, độ ưu tiên các phép toán trong C#.

Loại toán tử ...........................................Toán tử ............................................Thứ tự ưu tiên

Phép toán cơ bản .................. ..... x++ x-- typeof() sizeof() ! ++x --x ..............Trái sang phải
Phép toán cơ bản ......................................+ - * / % ...........................................Trái sang phải
Dịch bit ........................................................<< >> .............................................Trái sang phải
Quan hệ .................................................<> <= >= is ........................................Trái sang phải
So sánh bằng ...............................................== != .............................................Phải sang trái
AND .................................................................& ................................................Trái sang phải
XOR.................................................................. ^ .................................................Trái sang phải
OR..................................................................... | .................................................Trái sang phải
Điều kiện AND .................................................&& ...............................................Trái sang phải
Điều kiện OR .....................................................|| ................................................Trái sang phải
Điều kiện ...........................................................?: ................................................Phải sang trái
Phép gán .................................= *= /= %= += -= <<= >>= &= ^= |= ....................Phải sang trái

Các phép toán được liệt kê cùng loại sẽ có thứ tự theo mục thứ thự của bảng: thứ tự trái tức là độ ưu tiên của các phép toán từ bên trái sang, thứ tự phải thì các phép toán có độ ưu tiên từ bên phải qua trái. Các toán tử khác loại thì có độ ưu tiên từ trên xuống dưới, do vậy các toán tử loại cơ bản sẽ có độ ưu tiên cao nhất và phép toán gán sẽ có độ ưu tiên thấp nhất trong các toán tử.

Trong một số trường hợp ta nên dùng ngoặc tròn () để nhóm các biểu thức nhằm quy định độ ưu tiên của các toán tử và làm cho biểu thức rõ ràng hơn.

3. Ví dụ về sử dụng toán tử

Viết chương trình nhập vào độ C và lần lượt chuyển nó qua độ K và độ F

Công thức:

K = C + 273

F = C * 18/10 +32

Bài giải

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace freetuts.net
{
class freetuts
{
static void Main(string[] args)
{
Console.Write("Nhap do C: ");
int celsius = Convert.ToInt32(Console.ReadLine());
int K = celsius + 273;
int F = celsius * 18 / 10 + 32;
Console.WriteLine("Do K tuong ung la = {0}", K );
Console.WriteLine("Do F tuong ung la = {0}", F);
Console.WriteLine("Freetuts.net chuc ban hoc tot");
Console.ReadKey();
}
}
}
Chạy chương trình và cho kết quả:

Chúc các bạn ngày làm việc hiệu quả!

Nguồn: Freetuts.net