[Programming in C#] Bài 4: Các cấu trúc lập trình trong C#

1. Các cấu trúc lựa chọn (Selection Constructs)
- Cấu trúc lựa chọn là một cấu trúc lập trình được hỗ trợ bởi C# để cho phép điều khiển luồng thực hiện của chương trình.
- Các cấu trúc lựa chọn hoạt động trên cơ sở một điều kiện. Do vậy các cấu trúc lựa chọn còn được gọi với một tên khác là cấu trúc điều kiện.
- Có 4 kiểu cấu trúc lựa chọn trong C#:

Cấu trúc if … else:

Cú pháp:

if (điều kiện)
[khối lệnh 1];
else
[khối lệnh 2];
Trong đó:
Điều kiện: là một biểu thức logic (trả về giá trị true hoặc false).


Khối lệnh: là một hoặc nhiều câu lệnh, mỗi khối lệnh bắt đầu và kết thúc với { }
Cấu trúc này sẽ thực hiện kiểm tra Điều kiện nếu điều kiện đúng thì Khối lệnh 1 được thực hiện và nếu sai thì Khối lệnh 2 được thực hiện.
VD: viết đoạn code thực hiện giải PT bậc nhất.

float a, b, x;

Console.WriteLine("Chuong trinh giai PT bac nhat: ax + b = 0");
Console.Write("a = ");
a = float.Parse(Console.ReadLine());
Console.Write("b = ");
b = float.Parse(Console.ReadLine());

if (a == 0)
    Console.WriteLine("PT hien tai dang xem xet");
else
    Console.WriteLine("PT co nghiem: x = {0}", -b / a);

Console.ReadLine();

Cấu trúc if … else if: trong trường hợp chúng ta muốn chương trình có thể thực hiện theo nhiều luồng thì chúng ta sẽ dùng đến cấu trúc if … else if.

Cú pháp tổng quát:

if (điều kiện 1)
[khối lệnh 1];
else if (điều kiện 2)
[khối lệnh 2];
......
else if (điều kiện i);
[khối lệnh i];


......
else
[khối lệnh n];


Chương trình sẽ thực hiện kiểm tra Điều kiện 1, nếu điều kiện 1 đúng thì khối lệnh 1 được thực hiện nếu sai thì kiểm tra điều kiện 2, nếu điều kiện 2 đúng thì khối lệnh 2 được thực hiện, nếu sai thì điều kiện 3 được kiểm tra…
VD: viết chương trình cho phép nhập điểm số của 1 sinh viên. Thực hiện xếp loại sinh viên đó biết rằng:

        * Nếu điểm số <5 -> loại yếu.
        * Nếu điểm số >=5 và <6.5 -> loại trung bình.
        * Nếu điểm số >=6.5 và <7.5 -> loại khá.
        * Nếu điểm số >=7.5 và <=8.5 -> loại giỏi.
        * Nếu điểm số >=8.5 -> loại xuất sắc.

 

 

float diemSo;
Console.Write("Nhap diem: ");
diemSo = float.Parse(Console.ReadLine());
if (diemSo < 5)
    Console.WriteLine("Xep loai yeu");
else if (diemSo < 6.5)
    Console.WriteLine("Xep loai trung binh");
else if (diemSo < 7.5)
    Console.WriteLine("Xep loai kha");
else if (diemSo < 8.5)
    Console.WriteLine("Xep loai gioi");
else
    Console.WriteLine("Xep loai xuat sac");
Console.ReadLine();

Cấu trúc if lồng nhau: một lệnh if mà nằm trong 1 lệnh if khác thì lệnh if đó được gọi là if lồng.

VD: giải PT bậc nhất đầy đủ.

float a, b;

Console.WriteLine("Chuong trinh giai PT bac nhat: ax + b = 0");
Console.Write("a = ");
a = float.Parse(Console.ReadLine());
Console.Write("b = ");
b = float.Parse(Console.ReadLine());

if (a == 0)
{
    if (b == 0)
        Console.WriteLine("PT vo so nghiem");
    else
        Console.WriteLine("PT vo nghiem");
}
else
    Console.WriteLine("PT co nghiem: x = {0}", -b / a);

Console.ReadLine();

Cấu trúc đa nhánh switch … case: cấu trúc này cho phép chúng ta thực hiện điều khiển luồng thực hiện của chương trình theo nhiều luồng khác nhau dựa vào giá trị của một biểu thức (là biểu thức đếm được).

Cú pháp:

switch (biểu thức)
{
case [giá trị 1]:
[lệnh 1];
break;
case [giá trị 2]:
[lệnh 2];
break;
case [giá trị 3]:
[lệnh 3];
break;
..................
case [giá trị n]:
[lệnh n];
break;
default:
[lệnh n+1];
}


Lệnh này sẽ đánh giá giá trị của Biểu thức.
Nếu biểu thức có giá trị bằng giá trị 1 thì lệnh 1 sẽ được thực hiện.
Nếu biểu thức có giá trị bằng giá trị 2 thì lệnh 2 sẽ được thực hiện.
…………………..
Nếu biểu thức có giá trị bằng giá trị n thì lệnh n sẽ được thực hiện.
Ngược lại nếu giá trị biểu thức khác tất cả các giá trị trên thì lệnh n+1 được thực hiện.

CHÚ Ý: biểu thức phải là một biểu thức có giá trị đếm được có nghĩa là kiểu dữ liệu của biểu thức phải là số nguyên hoặc kí tự hoặc chuỗi kí tự hoặc kiểu dữ liệu liệt kê (enum).
VD: viết chương trình xác định xem ngày nào đó là thứ mấy biết ngày hiện tại 16/04/2010 là thứ 6.
string ngayNhap;

 

Console.Write("Nhap ngay muon xem (ngay/thang/nam): ");
ngayNhap = Console.ReadLine();
DateTime ngay = DateTime.Parse(ngayNhap);
DateTime ngay16042010 = new DateTime(2010, 4, 16);
int kc = Math.Abs(ngay16042010.Day - ngay.Day);
switch (kc % 7)
{
    case 0:
        Console.Write("Ngay nay la thu sau");
        break;
    case 1:
        Console.Write("Ngay nay la thu bay");
        break;
    case 2:
        Console.Write("Ngay nay la chu nhat");
        break;
    case 3:
        Console.Write("Ngay nay la thu hai");
        break;
    case 4:
        Console.Write("Ngay nay la thu ba");
        break;
    case 5:
        Console.Write("Ngay nay la thu tu");
        break;
    case 6:
        Console.Write("Ngay nay la thu nam");
        break;
}
Console.ReadLine();

2. Các cấu trúc lặp (Loop Constructs)
- Cấu trúc lặp là một cấu trúc cho phép chúng ta thực hiện một đoạn code lặp đi lặp lại cho đến khi thỏa mãn một điều kiện nào đó.
- Có 4 cấu trúc lặp được sử dụng trong C#:

Cấu trúc lặp while:

Cú pháp:

while (điều kiện)
{
[khối lệnh];
}


Trong đó:
điều kiện là một biểu thức logic.
Vòng lặp này sẽ thực hiện kiểm tra điều kiện trước. Nếu điều kiện đúng thì thực hiện khối lệnh sau đó quay lại kiểm tra điều kiện. Công việc này sẽ được thực hiện liên tục cho đến khi điều kiện có giá trị sai.
VD: bài toán một người có số tiền m gửi vào ngân hàng A với lãi suất gửi là x%/1 tháng. Hỏi sau bao nhiêu tháng thì người này sẽ được số tiền là n.

 

float m, n, x;
int soThang = 0;
Console.Write("So tien gui: ");
m = float.Parse(Console.ReadLine());
Console.Write("So tien muon co: ");
n = float.Parse(Console.ReadLine());
Console.Write("Lai xuat (%/1 thang): ");
x = float.Parse(Console.ReadLine());
while (m < n)
{
    m = m + (float)(m * x / 100);
    soThang++;
}
Console.WriteLine("So thang phai gui la: {0}", soThang);
Console.ReadLine();

Cấu trúc do … while:

Cú pháp:

do
{
[khối lệnh];
}
while (điều kiện);


Câu lệnh này sẽ thực hiện khối lệnh sau đó kiểm tra điều kiện, nếu điều kiện sai thì kết thúc vòng lặp, nếu điều kiện đúng thì thực hiện tiếp khối lệnh sau đó lại kiểm tra điều kiện.
VD: viết chương trình tính tổng của 2 số, lặp lại việc đó cho đến khi người dùng trả lời ko muốn tiếp tục nữa.

 

int a, b;
char traLoi;
do
{
    Console.Write("a = ");
    a = int.Parse(Console.ReadLine());

    Console.Write("b = ");
    b = int.Parse(Console.ReadLine());

    Console.WriteLine("Tong 2 so: {0}", a + b);
    Console.Write("Ban co tiep tuc ko (C/K)?");
    do
    {
        ConsoleKeyInfo key = Console.ReadKey();
        traLoi = key.KeyChar;
    }
    while (!(traLoi == 'c' || traLoi == 'C' || traLoi == 'k' || traLoi == 'K'));
    Console.WriteLine();
}
while (traLoi == 'c' || traLoi == 'C');

Cấu trúc lặp for:

Cấu trúc lặp for thường được sử dụng trong trường hợp biết trước số lần lặp.
Cú pháp:

for ([biểu thức khởi tạo]; [biểu thức kiểm tra điều kiện]; [biểu thức thay đổi giá trị vòng lặp])
[khối lệnh];


Trong đó:
[biểu thức khởi tạo]: là danh sách các lệnh thực hiện khởi tạo giá trị cho các biến trong vòng lặp, các lệnh này cách nhau bởi dấu phẩy (,).
[biểu thức kiểm tra điều kiện]: là biểu thức được sử dụng để kiểm tra điều kiện dừng của vòng lặp. Nếu điều kiện đúng thì vòng lặp tiếp tục được thực hiện, nếu sai thì kết thúc vòng lặp.
[biểu thức thay đổi giá trị vòng lặp]: là biểu thức thực hiện thay đổi các giá trị của các biến được sử dụng để điều khiển vòng lặp.
VD: viết chương trình in ra tổng các cặp số chẵn nhỏ hơn 300.

 

for (int i = 2, j = 2; i + j < 300; i += 2, j += 2)
{
    Console.WriteLine("{0} + {1} = {2}", i, j, i + j);
}

Console.ReadLine();

Cấu trúc lặp foreach: cấu trúc lặp này được sử dụng để cho phép duyệt qua một tập hợp và thực hiện lặp đi lặp lại cho đến cuối của tập hợp đó.

Cú pháp:

foreach ([kiểu đối tượng] [tên đối tượng] in [tên tập hợp])
[khối lệnh];


Vòng lặp này sẽ thực hiện khối lệnh với mỗi một đối tượng nằm trong tập hợp.
VD: Sinh ra một tập hợp ngẫu nhiên các số nguyên trong khoảng [0..100] sau đó in ra tất cả các phần tử trong tập hợp đó.

 

ArrayList arr = new ArrayList();

// Phát sinh số n ngẫu nhiên trong khoảng từ [5,15].
Random rnd = new Random();
int n = 5 + rnd.Next(10);

// Phát sinh ra n số ngẫu nhiên trong khoảng từ [0..100].
for (int i = 1; i <= n; i++)
    arr.Add(rnd.Next(100));

// In ra các số trong tập hợp arr trên sử dụng vòng lặp foreach.
Console.WriteLine("Mang ngau nhien duoc sinh ra la: ");
foreach (int x in arr)
{
    Console.Write(x + " ");
}

Console.ReadLine();

3. Các lệnh nhảy (Jump Statements)
- Các lệnh nhẩy là những lệnh cho phép thay đổi (chuyển điều khiển) từ một vị trí này đến một vị trí khác trong chương trình.
- Có 4 lệnh nhẩy cơ bản trong C#:

Lệnh break: lệnh này được sử dụng để kết thúc một vòng lặp hoặc một đoạn lệnh trong câu lệnh switch … case.

VD: viết chương trình cho phép in ra các số chia hết cho 3 trong khoảng từ 1 đến 100. Nếu có một số vừa chia hết cho 3 vừa chia hết cho 7 thì dừng.

for (int i = 1; i <= 100; i++)
{
    if (i % 3 == 0)
    {
        if (i % 7 == 0) break;
        Console.Write(i + " ");
    }
}



Lệnh continue: lệnh này cho phép nhảy đến lần lặp tiếp theo trong vòng lặp.

VD: viết chương trình thực hiện in ra danh sách các số từ 1 đến 100 bỏ qua các số chia hết cho 7.

for (int i = 1; i <= 100; i++)
{
    if (i % 7 == 0) continue;
    Console.Write(i + " ");
}


Lệnh goto: lệnh này cho phép chuyển đến một vị trí được định sẵn (được gán nhãn) trong chương trình.

VD: viết chương trình giải PT bậc nhất, lặp đi lặp lại cho đến khi trả lời ko tiếp tục nữa.

int a, b;
Console.WriteLine("Chuong trinh giai PT bac nhat");
BatDau:
Console.Write("a = ");
a = int.Parse(Console.ReadLine());
Console.Write("b = ");
b = int.Parse(Console.ReadLine());

if (a == 0)
    if (b == 0)
        Console.WriteLine("PT vo so nghiem");
    else
        Console.WriteLine("PT vo nghiem");
else
    Console.WriteLine("PT co 1 nghiem: x = {0}", (float)-b / a);

Console.Write("Ban co tiep tuc (C/K)?");
string traLoi = Console.ReadLine();
traLoi = traLoi.ToUpper();

if (traLoi.Equals("C")) goto BatDau;

Lệnh return: lệnh return dùng để kết thúc một hàm và trả về kết quả cho hàm đó.