Lập Trình C++

Trường Đại Học Sư Phạm Kỹ Thuật Thành Phố Hồ Chí Minh
Bộ Môn Cơ Điện Tử

2012
Lập trình ứng dụng trong kỹ thuật Chương I
Bộ môn Cơ điện tử Trang 2
TÓM TẮT CHƯƠNG I : C++/CLI CĂN BẢN.
1) Tạo và biên dịch một chương tr
ình C++/CLI :
a) Dùng phần mềm Visual Studio :
Mở chương tr
ình VS 2008. Trong màn
hình khởi động, chọn File - > New -> Project
Trong cửa sổ New Project : Chọn kiểu project là CLR, trong cửa sổ Templates chọn
CLR Console Application.
Nhập tên của project vào ô Name và chọn thư mục chứa project trong ô Location.
Nhấp OK.
Lập trình ứng dụng trong kỹ thuật Chương I
Bộ môn Cơ điện tử Trang 3
Xuất hiện cửa sổ Project, chúng ta có thể bắt đầu viết chương tr
ình trong vùng so
ạn thảo.
Sau khi hoàn tất chương tr
ình, nh
ấn vào biểu tượng Debug để chạy chương tr
ình (ho
ặc
nhấn F5).
Khi Debug, nếu chương tr
ình co l
ỗi về mặt cú pháp, VS sẽ thông báo các lỗi này trong cửa

sổ Error, nhấp kép chuột vào dòng thông báo lỗi để biết vị trí lỗi.
Nếu không thấy cửa sổ Error, trên thanh công cụ chọn View -> Other Windows -> Error
List. (Hoặc nhấn Ctrl+F5).
b) Dùng Notepad :
Mở Notepad và bắt đầu viết chương tr
ình trong c
ửa sổ soạn thảo của Notepad.
Lập trình ứng dụng trong kỹ thuật Chương I
Bộ môn Cơ điện tử Trang 4
Sau khi hoàn tất, lưu lại với đuôi .cpp. (Ví dụ muốn lưu lại với tên là Vidu thì trong ô File
name nhập Vidu.cpp, trong ô Save as type chọn All Files.
Để biên dịch chương tr
ình, m
ở VS Command Prompt.
Trong màn hình Command Prompt, chuyển đến thư mục đang chứa tập tin muốn biên dịch
bằng lệnh cd. Ví dụ nếu tập tin Vidu.cpp được lưu trong thư mục CLI trong ổ E thì nhập cd
E:\CLI.
Lập trình ứng dụng trong kỹ thuật Chương I
Bộ môn Cơ điện tử Trang 5
Sau khi chuyển đến thư mục, tiến hành biên dịch bằng lệnh : cl name /clr:safe . Trong
đó, name là tên tập tin muốn biên dịch bao gồm cả đuôi mở rộng (Ví dụ : Vidu.cpp).
Sau khi biên dịch thành công, hai tập tin Vidu.exe và Vidu.obj sẽ được tạo ra.
Ta có thể chạy chương tr
ình b
ằng cách nhấp kép vào Vidu.exe trong thư mục chứa tập tin
lập trình hoặc chạy trực tiếp trên Command Prompt bằng cách nhập vào tên của tập tin tại dấu
nhắc (không bao gồm đuôi mở rộng).
Lưu
ý :
Nếu chương tr

ình có l
ỗi về mặt cú pháp, quá trình biên dịch sẽ thất bại.
2) Class CONSOLE :
Lập trình ứng dụng trong kỹ thuật Chương I
Bộ môn Cơ điện tử Trang 6
Class quản lí việc tương tác với màn hình Console. Các phương thức (hàm) cơ bản của lớp:
Write(a) : Hàm một đối số. Xuất ra màn hình Console giá trị của a (a có thể là biến hoặc
hằng số).
VD : Console::Write (10); -> 10
Console::Write(“Hello”); -> Hello
WriteLine(a) : Hàm một đối số. Tương tự như Write() nhưng sau khi xuất giá trị ra màn
hình sẽ xuống dòng.
VD : Console::WriteLine(10); -> 10
Console::WriteLine(“Hello”); -> Hello
Read() : Hàm không có đối số. Kiểu dữ liệu trả về là interger. Nhận một kí tự được nhập từ
bàn phím.
VD : int a = Console::Read ();
5  : a = 5
A : a = 65 (số thập phân tương ứng mã ASCII của kí tự A )
AB : a = 65 (khi nhập vào một chuỗi kí tự thì chỉ nhận kí tự đầu tiên).
ReadLine() : Hàm không có đối số. Kiểu dữ liệu trả về là String. Nhận một chuỗi kí tự
được nhập từ bàn phím.
VD : String^ b = Console::ReadLine ();
Hello : b = “Hello”.
ReadKey() : Hàm không có đối số. Kiểu dữ liệu trả về là ConsoleKeyInfo. Nhận phím
được nhấn từ bàn phím (trừ các phím đặc biệt Ctrl, Shift, Alt).
VD : ConsoleKeyInfo b = Console::ReadKey ();
Console::Write(b.Key);
(Nhấn phím) Esc -> Escape
 Kiểm tra xem có phải phím x đ

ã đư
ợc nhấn : b.Key == ConsoleKey::x ;
VD : if (b.Key ==ConsoleKey::Escape) Console::Write(L “Phím ESC”);
else Console::Write(L “Không phải phím ESC”);
Clear() : Hàm không có đối số.Xóa toàn bộ màn hình Console.
VD : Console::Clear ();
Lập trình ứng dụng trong kỹ thuật Chương I
Bộ môn Cơ điện tử Trang 7
3) Biến và Con trỏ :
a) Biến:
Các biến chúng ta đ
ã bi
ết và sử dụng trước đây đều là biến có kích thước và kiểu dữ liệu
xác định. Người ta gọi các biến kiểu này là biến tĩnh. Khi chúng ta khai báo biến, phần mềm lập
trình sẽ tự động tìm một vùng nhớ còn trống trong bộ nhớ để lưu trữ giá trị của biến, kích thước
của vùng nhớ tùy thuộc vào kiểu dữ liệu của biến. Bất cứ một biến nào cũng có một địa chỉ trong
bộ nhớ của máy tính (địa chỉ này được lưu trữ trong các thanh ghi (register) đặc biệt của CPU).
Khi khai báo biến t
ĩnh, m
ột lượng ô nhớ cho các biến này sẽ được cấp phát mà không cần
biết trong quá trình thực thi chương trình có sử dụng hết lượng ô nhớ này hay không. Mặt khác,
các biến t
ĩnh d
ạng này sẽ tồn tại trong suốt thời gian thực thi chương tr
ình dù có nh
ững biến mà
chương tr
ình ch
ỉ sử dụng 1 lần rồi bỏ.
Các kiểu biến t

ĩnh :
các biến kiểu giá trị như interger, float, decimal, boolean và character.
Một số hạn chế có thể gặp phải khi sử dụng các biến t
ĩnh:
 Cấp phát ô nhớ dư, gây ra l
ãng phí ô nh
ớ.
 Cấp phát ô nhớ thiếu, chương tr
ình th
ực thi bị lỗi.
Để tránh những hạn chế trên, ngôn ngữ C++ cung cấp cho ta một loại biến đặc biệt gọi là
biến động với các đặc điểm sau:
 Chỉ phát sinh trong quá trình thực hiện chương tr
ình ch
ứ không phát sinh lúc bắt
đầu chương tr
ình.
 Khi chạy chương tr
ình, kích th
ư
ớc của biến, vùng nhớ và địa chỉ vùng nhớ được cấp
phát cho biến có thể thay đổi.
 Sau khi sử dụng xong có thể giải phóng để tiết kiệm chỗ trong bộ nhớ.
Các kiểu biến động : String, Object, array, interface, delegate …
Tuy nhiên các biến động không có địa chỉ nhất định nên ta không thể truy cập đến chúng
được. Vì thế, ngôn ngữ C lại cung cấp cho ta một loại biến đặc biệt nữa để khắc phục tình trạng
này, đó là biến con trỏ (pointer) với các đặc điểm:
Biến con trỏ không chứa dữ liệu mà chỉ chứa địa chỉ của dữ liệu hay chứa địa chỉ của ô nhớ
chứa dữ liệu.
Kích thước của biến con trỏ không phụ thuộc vào kiểu dữ liệu, luôn có kích thước cố định

là 2 byte.
Tất cả các biến động đều phải khai báo thông qua con trỏ.
b) Pointer : (*)
Muốn truy xuất giá trị của một biến, thì có thể gọi tên biến trong chương tr
ình ho
ặc truy
xuất trực tiếp đến vùng nhớ thông qua địa chỉ của biến.
Để truy xuất trực tiếp đến vùng nhớ của biến, ta dùng biến con trỏ (pointer). Nói đơn giản,
con trỏ là một biến chứa địa chỉ của biến khác. Kích thước của biến con trỏ không phụ thuộc vào
kiểu dữ liệu, luôn có kích thước cố định là 2 byte.
Lập trình ứng dụng trong kỹ thuật Chương I
Bộ môn Cơ điện tử Trang 8
Cú pháp khai báo : type* name;
 Trong đó type là kiểu dữ liệu của biến mà con trỏ chứa địa chỉ và name là tên của
biến con trỏ.
VD : int* a; //Khai báo biến con trỏ a để chứa địa chỉ của một biến có kiểu
int.
Khi mới khai báo, biến con trỏ sẽ có giá trị ngẫu nhiên. Ngh
ĩa là nó đang ch
ỉ tới một vị trí
bất kì nào
đó trong b
ộ nhớ. Để gán địa chỉ của một biến cho con trỏ, ta dùng toán tử địa chỉ &
VD : int k = 10;
int* a = &k; //Con trỏ a đang chứa địa chỉ của biến k.
Để truy cập nội dung của ô nhớ mà con trỏ đang chỉ tới, ta sử dụng toán tử gián tiếp *.
VD : int y =*a; //Biến y sẽ được gán giá trị của ô nhớ mà con trỏ a đang chỉ
tới.
Ta có thể cộng (+), trừ (-) 1 con trỏ với 1 số nguyên N nào đó; kết quả trả về là 1 con trỏ.
Con trỏ này chỉ đến vùng nhớ cách vùng nhớ của con trỏ hiện tại N phần tử (vùng nhớ) . Kích

thước của vùng nhớ phụ thuộc vào kiểu dữ liệu của biến mà con trỏ chỉ tới (mỗi ô nhớ có kích
thước 1 byte).
VD : int k = 10;
int* a = &k;
int* b = a + 3; // Nếu a đang chỉ tới ô nhớ 1000 thì b sẽ chỉ tới ô nhớ có địa
Ta không thể công hai biến con trỏ với nhau nhưng có thể trừ hai biến con trỏ (kết quả là
một số nguyên cho biết khoảng cách giữa hai ô nhớ mà hai con trỏ đang trỏ tới).
VD : int k1=10, k2=20;
int *a =&k1, *b =&k2;
int y = a – b; // Nếu a đang chỉ tới ô nhớ 1000 và b chỉ tới ô nhớ 1012 thì y =
12.
Do con trỏ c
ũng là m
ột biến nên c
ũng đư
ợc lưu trữ trong bộ nhớ, nên ta có thể dùng một
con trỏ khác để chỉ tới địa chỉ này.
VD: int*a = &k1;
int**b = &a;
c) Handle : (^)
chỉ 1012 (kiểu int có kích thước 32-bit (4 byte), do đó mỗi vùng nhớ của biến kiểu int là
4 ô nhớ; địa chỉ của con trỏ b cách con trỏ a 4 phần tử tương ứng với 12 ô nhớ ).
Lập trình ứng dụng trong kỹ thuật Chương I
Bộ môn Cơ điện tử Trang 9
Handle c
ũng có chức năng t
ương tự như pointer. Chỉ khác là nó không
ph
ản ánh đ
ược địa

ch
ỉ thật của đối tượng nằm ở đâu trên bộ nhớ mà nó phản ánh được 1 giá trị 32 bit do CLR quản
lý. Do đó handle c
òn có
th
ể được xem là một con trỏ ảo cho phép tương tác với bộ nhớ thông qua
CLR.
Do không ph
ản ánh địa chỉ thật của đối tượng
trên b
ộ nhớ
nên ta không th
ể thực hiện các
phép toán công trừ với số nguyên như pointer.
Cơ ch
ế quản lý bộ nhớ của một số ngôn ngữ :
4) String (Kiểu chuỗi kí tự) :
String là kiểu dữ liệu cho phép lưu trữ giá trị dưới dạng một dãy các kí tự. Để dễ hình
dung, ta có xem String như là một vectơ gồm nhiều phần tử liên tiếp nhau, mỗi phần tử là một kí
tự.
Cú pháp khai báo : String^ name; //name là tên biến.
Để gán giá trị cho biến kiểu String, ta đặt chuỗi kí tự trong cặp dấu “”.
VD : String^ a = “Xinchao”;
Do kích thước của kiểu String là không xác định (vì không biết chính xác chiều dài của
chuỗi kí tự). Nên String thuộc kiểu dữ liệu tham chiếu (reference type) và khi khai báo cần có ^
(handle).
Ta có thể truy xuất đến bất kì một phần tử nào trong chuỗi nếu biết vị trí của phần tử đó.
VD : String^ a = “Xinchao”;
Char b = a [3]; // b = ‘c’ (a[3] có ngh
ĩa là ph

ần tử thứ 4,
phần tử đầu tiên là a[0]).
Lập trình ứng dụng trong kỹ thuật Chương I
Bộ môn Cơ điện tử Trang 10
Trong C++/CLI, có riêng một Class quản lí kiểu chuỗi là Class String. Các biến (variable)
và phương thức (method) cơ bản của Class String :
Length : biến có kiểu interger. Trả về chiều dài của chuỗi (số lượng các kí tự của chuỗi).
VD : String^ a = “Xinchao” ;
int x = a->Length; // x sẽ có giá trị = 7.
Concat() : Hàm nhiều đối số. Kiểu dữ liệu trả về là String. Thực hiện chức năng nối các
chuỗi lại với nhau.
VD : String ^ a = “Welcome”, ^b = “ To ”, ^c = “Viet Nam”;
String ^ d = String::Concat(a,b,c); // d = “Welcome to Viet Nam”
Substring(int n) : Hàm một đối số. Kiểu dữ liệu trả về là String. Tạo một chuỗi mới từ
chuỗi ban đầu bằng cách loại đi n phần tử đầu tiên .
VD : String^ a = “Hello”;
String^ b = a->Substring(2); // b = “llo”
ToUpper() : Hàm không đối số. Kiểu dữ liệu trả về là String. Thực hiện chức năng chuyển
tất cả các kí tự của chuỗi thành chữ HOA
VD : String ^ a = “Welcome”;
String ^ b = a->ToUpper(); // b= “WELCOME”
ToLower() : Hàm không đối số. Kiểu dữ liệu trả về là String. Thực hiện chức năng chuyển
tất cả các kí tự của chuỗi thành chữ thường.
VD : String ^ a = “Welcome”;
String ^ b = a->ToLower(); // b= “welcome”
Remove(int n, int m) : Hàm hai đối số. Kiểu dữ liệu trả về là String. Tạo một chuỗi mới từ
chuỗi ban đầu bằng cách loại đi m các phần tử từ vị trí n .
Replace(String^ n, String^ m) : Hàm hai đối số. Kiểu dữ liệu trả về là String. Tạo một
chuỗi mới từ chuỗi ban đầu bằng cách thay thế chuỗi n bằng chuỗi m.
VD : String^ a = “Hello Hell”;

String^ b = a->Replace(“ell”, “i”); // b = “Hio Hi”
VD : String^ a = “Hello Viet Nam”;
String^ b = a->Remove(2,5); // b = “Heiet Nam”
String^ b= a->SubString(Start, Length) //Start={0, 1, 2, }, Length:
Sӕ Ký tӵ Cҫn lҩy Vd: A->SubString(0,2)="He";
Lập trình ứng dụng trong kỹ thuật Chương I
Bộ môn Cơ điện tử Trang 11
Insert(int n, String^ m) : Hàm hai đối số. Kiểu dữ liệu trả về là String. Tạo một chuỗi mới
từ chuỗi ban đầu bằng cách chèn thêm vào chuỗi m tại vị trí thứ n .
VD : String^ a = “Hello”;
String^ b = a->Insert(2, “hi”); // b = “Hehillo”
Trim() : Hàm không đối số. Kiểu dữ liệu trả về là String. Loại bỏ các kí tự khoảng trắng
(spacebar) ở đầu và cuối chuỗi.
VD : String^ a = “ Hello VN ”;
String^ b = a->Trim() ; // b = “Hello VN”
5) Array (Kiểu mảng) :
array là kiểu dữ liệu dạng tập hợp (collection) cho phép lưu trữ giá trị dưới dạng một
mảng các phần tử có cùng kiểu dữ liệu. Để dễ hình dung, ta có xem array như là một ma trận
nhiều chiều gồm nhiều phần tử, kiểu dữ liệu của mỗi phần tử là bất kì.
Với phiên bản VS 2005 (.Net Framework 1.1), muốn sử dụng kiểu mảng cần khai báo
namespace stdcli::language. Tuy nhiên từ phiên bản VS 2008 (.Net Framework 2.0) thì không
cần khai báo.
Cú pháp khai báo :
 Mảng 1 chiều : array <type>^ name; //name là tên biến, type là kiểu dữ liệu của
biến.
 Mảng n chiều : array <type, n>^ name; //n là số chiều của mảng.
VD : array <int>^ a; //mảng 1 chiều, phần tử có kiểu interger.
array <String^, 2>^ b; //mảng 2 chiều, kiểu dữ liệu là String.
array <array<int,2>^,2>^ b; //mảng 2 chiều, mỗi phần tử lại là 1 array 2
chiều.

Số chiều tối đa của mảng là 32.
Trước khi sử dụng mảng, ta phải thực hiện việc cấp phát bộ nhớ cho mảng. Việc cấp phát
bộ nhớ được thực hiện bằng lệnh gcnew().
Cú pháp : name = gcnew array<type,n>(k1,k2,…,kn); // k1,k2,…,kn là số phần tử
ứng với chiều thứ 1,2,…,n của mảng.
VD : array<int,2>^ M;
M = gcnew array<int,2>(5,3); //mảng 2 chiều 5x3 (5 hàng, 3 cột).
Muốn gán giá trị cho mảng, ta phải gán giá trị cho từng phần tử một. Để truy xuất đến từng
phần tử của mảng, ta dùng cú pháp :
Mҧng bҳt ÿҫu tӯ 0
Lập trình ứng dụng trong kỹ thuật Chương I
Bộ môn Cơ điện tử Trang 12
name[i1,i2,…,in] //name là tên mảng, i1,i2,…,in là vị trí của phần tử trong mảng
VD : array<int,2>^ M = gcnew array<int,2>(5,3);
M[3,2] = 10; //gán giá trị 10 cho phần tử ở hàng thứ 4, cột 3 (phần tử
ở hàng 1 cột 1 là M[0,0]).
Ngoài ra, nếu giá trị tất cả các phần tử của mảng đ
ã bi
ết. Ta có dùng cách gán trực tiếp như
sau :
VD : array<int,2>^ M = { {1,2,3},{2,3,0},{1,2,3} }; //mảng 3x3
Lưu ý : khi dùng cách gán giá trị trực tiếp, ta phải gán ngay khi khai báo và không cần
dùng lệnh gcnew() (phần mềm sẽ tự động cấp phát bộ nhớ).
VD : array<int,2>^ M;
M = { {1,2,3},{2,3,0},{1,2,3} }; // báo lỗi.
Trong C++/CLI, có riêng một Class quản lí kiểu mảng là Class Array. Các biến (variable)
và phương thức (method) cơ bản của Class Array :
Rank : biến có kiểu interger. Trả về số chiều của mảng.
VD : array<int,2>^ M = gcnew array<int,3>(5,3,2);
int x = M->Rank; // x sẽ có giá trị = 3.

GetLength (int i) : hàm 1 đối số. Kiểu dữ liệu trả về là interger. Trả về số phần tử (kích
thước) chiều thứ i của mảng.
VD : array<int,2>^ M = gcnew array<int,2>(5,3);
int x = M->GetLength(0); // x = 5.
int y = M->GetLength(1); // y = 3.
Reverse(array^ x) : Hàm một đối số. Không trả về dữ liệu. Thực hiện chức năng đảo ngược
thứ tự của mảng 1 chiều.
VD : array<int>^ M = { 1,2,3,4,5 };
Array::Reverse(M); // M = {5,4,3,2,1}.
Sort(array^ x) : Hàm một đối số. Không trả về dữ liệu. Thực hiện chức năng sắp xếp thứ
tự của mảng 1 chiều.
VD : array<int>^ M = { 5,1,3,3,2 };
Array::Sort(M); // M = {1,2,3,3,5}.
Lập trình ứng dụng trong kỹ thuật Chương I
Bộ môn Cơ điện tử Trang 13
Sort(array^ x, array^ y) : Hàm hai đối số. Không trả về dữ liệu. Thực hiện chức năng sắp
xếp thứ tự của 2 mảng 1 chiều dựa vào mảng thứ nhất.
VD : array<int>^ M = { 5,1,3,3,2 };
array<Char>^ C = {‘A’, ‘D’, ‘K’, ‘E’, ‘F”};
Array::Sort(M,C); // M = {1,2,3,3,5} C = {‘D’, ‘F’, ‘K’, ‘E’, ‘A’}
6) Toán tử (Operator) :
a) Toán tử số học :
Thực hiện các tính toán số học trên số nguyên, số thực và số thập phân. Bao gồm các
toán tử sau :
- : Phép trừ hay phép lấy phần âm.
+ : Phép cộng.
* : Phép nhân.
/ : Phép chia.
% : Phép chia lấy dư.
++ : Tăng đơn vị.

: Giảm đơn vị.
Lưu
ý
:
Phép chia lấy dư (%) chỉ thực hiện trên số nguyên (interger).
++/ đặt trước toán hạng : thực hiện tăng giảm trên toán hạng rồi sau đó mới thực hiện
phép tính.
++/ đặt sau toán hạng : thực hiện phép tính trước rồi sau đó mới thực hiện tăng giảm trên
toán hạng.
VD : int x = 5, y = 3;
int z = x%y; // z = 2 (5 chia 3 dư 2).
int k = x++%y; // k = 2 , x = 6 ( thực hiện x% y trước rồi mới tăng x).
int t = ++z%y; // t = 0 , z = 3 (tăng z rồi mới thực hiện z%y)
b) Toán tử so sánh và logic :
Toán tử so sánh thực hiện so sánh hai biểu thức và trả về một giá trị bool dựa vào kết quả
của việc so sánh. Bao gồm các toán tử sau :
> : So sánh lớn hơn.
< : So sánh nhỏ hơn.
>= : So sánh lớn hơn hoặc bằng.
<= : So sánh nhỏ hơn hoặc bằng.
Lập trình ứng dụng trong kỹ thuật Chương I
Bộ môn Cơ điện tử Trang 14
== : So sánh bằng.
!= : So sánh không bằng.
Toán tử logic thực hiện các phép toán trên số bool. Bao gồm 3 toán tử :
! : Phép NOT.
&& : Phép AND.
|| : Phép OR.
VD : int x = 5, y = 3;
int z = x%y; // z = 2 (5 chia 3 dư 2).

int k = x++%y; // k = 2 , x = 6 ( thực hiện x% y trước rồi mới tăng x).
int t = ++z%y; // t = 0 , z = 3 (tăng z rồi mới thực hiện z%y)
c) Toán tử thao tác bit (bitwise) :
Thực hiện các phép tính trên từng bit của một số nguyên (chuyển số nguyên sang số nhị
phân rồi thực hiện phép toán, kết quả sau đó được chuyển ngược lại số nguyên).
& : Phép AND.
| : Phép OR.
^ : Phép XOR.
~ : Phép bù -1.
>> : Phép dịch phải.
<< : Phép dịch trái.
VD : Byte x = 5, y = 3; // Giá trị nhị phân x = 0000 0101 y = 0000 0011
Byte z = x&y; // z = 0000 0101 & 0000 0011 = 0000 0001 = 1
Byte k = x>>2; // k = 0000 0001 = 1.
Byte t = y<<3; // t = 0000 1100 = 12
d) Toán tử điều kiện :
Toán tử điều kiện là toán tử ba ngôi duy nhất trong C++/CLI.
Cú pháp : condition ? result 1 : result 2;
Trong đó condition là điều kiện : nếu điều kiện là đúng (true) thì biểu thức sẽ trả về
result1 , nếu điều kiện là sai (false) thì biểu thức sẽ trả về result2.
Lập trình ứng dụng trong kỹ thuật Chương I
Bộ môn Cơ điện tử Trang 15
VD : int x = 5, y = 3;
int z = (x > y) ? (x+y) : (x-y); // z = 8 : x > y đúng nên z = x + y
int k = (x < y) ? (x+y) : (x-y); // z = 2 : x < y sai nên z = x - y
e) Toán tử gán :
Thực hiện việc gán giá trị cho các biến. Bao gồm 11 toán tử gán.
= : Gán trực tiếp.
+= : Thực hiện công rồi mới gán ( x += a  x = x + a).
-= : Thực hiện trừ rồi mới gán ( x -= a  x = x - a).

*= : Thực hiện nhân rồi mới gán ( x *= a  x = x * a).
/= : Thực hiện chia rồi mới gán ( x /= a  x = x / a).
%= : Thực hiện chia lấy dư rồi mới gán ( x %= a  x = x % a).
&= : Thực hiện AND rồi mới gán ( x &= a  x = x & a).
^= : Thực hiện XOR rồi mới gán ( x ^= a  x = x ^ a).
|= : Thực hiện OR rồi mới gán ( x |= a  x = x|a).
>>=: Thực hiện dịch phải rồi mới gán ( x >>= a  x = x >> a).
<<=: Thực hiện dịch trái rồi mới gán ( x <<= a  x = x << a).
f) Toán tử ngoặc đơn (comma) :
Gồm nhiều biểu thức liên tiếp được thực hiện liên tiếp, kết quả là kết quả của biểu thức
cuối cùng.
VD : int x = 5, y = 3;
int z = (y++, x = y++ * x++, x%y); // z = 4.
g) Toán tử địa chỉ, tham chiếu và gián tiếp :
Toán tử địa chỉ (&) : trả về địa chỉ (trong bộ nhớ) của một biến.
VD : int x = 5, *y ;
y = &x; // đặt địa chỉ của biến x vào biến con trỏ y.
Toán tử gián tiếp (*) : toán tử một ngôi trên biến con trỏ, trả về giá trị đang lưu trữ trong ô
nhớ mà biến con trỏ đang chỉ tới.
VD : int x ;
int *y = &x; // y chỉ tới địa chỉ lưu trữ giá trị biến x
x = 10;
Lập trình ứng dụng trong kỹ thuật Chương I
Bộ môn Cơ điện tử Trang 16
int z = *y; // z = giá trị đang lưu trữ trong địa chỉ vùng nhớ mà y
đang chỉ tới.
Toán tử tham chiếu (%) : thực hiện tham chiếu đến một biến cùng kiểu dữ liệu.
VD : int x = 5;
int % y = x; // y tham chiếu đến biến x.
x = 10; // x = 10, y =10 : vì y tham chiếu đến x nên khi x thay

đổi giá trị thì y c
ũng thay đ
ổi giá tri.
int z = y; // z = 10.
y = 20; // x = 20, y =20 : khi y thay đổi giá trị thì x c
ũng thay
đổi giá trị.
h) Thứ tự ưu tiên của các toán tử : (Tham khảo trong tài liệu).
7) Cấu trúc điều khiển (Control Construct) :
a) Cấu trúc điều kiện (Condition Construct) :
Các cấu trúc điều kiện là một đoạn mã lệnh, chương tr
ình ch
ỉ thực hiện đoạn mã lệnh nếu
điều kiện của cấu trúc là đúng (true). C++/CLI cung cấp 2 loại cấu trúc điều kiện : if và switch
 Cấu trúc “if” :
Cú pháp :
if (conditon) //Nếu điều kiện đúng thì thực hiện đoạn mã lệnh.
{
Statement;
}
Hoặc :
if (conditon) //Nếu điều kiện đúng th
ì th
ực hiện đoạn mã lệnh 1.
{
Statement 1;
}
else // Nếu điều kiện sai thì thực hiện đoạn mã lệnh 2.
{
Statement 2;

}
Nếu có nhiều vòng if lồng nhau (nhiều điều kiện) thì có thể dùng cấu trúc sau :
Lập trình ứng dụng trong kỹ thuật Chương I
Bộ môn Cơ điện tử Trang 17
if (conditon 1) //Nếu điều kiện 1 đúng th
ì th
ực hiện đoạn mã lệnh 1.
{
Statement 1;
}
else if (condition 2) // Nếu điều kiện 2 đúng thì thực hiện đoạn mã lệnh 2.
{
Statement 2;
}
else // Nếu tất cả đều sai thì thực hiện đoạn mã lệnh 3.
{
Statement 3;
}
VD : int x = 5, y = 10;
if (x>y)
{
Console::WriteLine(x); //Điều kiện sai không thực hiện.
}
else
{
Console::WriteLine(y); //Xuất ra màn hình console giá trị biến y.
}
 Cấu trúc “switch” :
Cấu trúc “switch” là cấu trúc điều kiện nhiều lựa chọn.
Cú pháp :

switch (expression) // expression là một biểu thức.
{
case constant1: // Nếu kết quả biểu thức = constant1 thì thực hiện
Statement1; đoạn mã lệnh Statement1.
break; // Sau khi kết thúc Statement1 thì thoát khỏi.
case constant2: // Nếu kết quả biểu thức = constant2 thì thực hiện
Statement2; đoạn mã lệnh Statement2.
break; // Sau khi kết thúc Statement2 thì thoát khỏi.
default: // Đoạn lệnh mặc định
Statement3;
Lập trình ứng dụng trong kỹ thuật Chương I
Bộ môn Cơ điện tử Trang 18
}
VD : int x = 4,y;
switch (x%3)
{
case 0:
Console::WriteLine(“x chia het cho 3”);
break;
case 1:
Console::WriteLine(“x la so chan”);
break;
default :
Console::WriteLine(“x la so le”);
}
Kết quả xuất ra màn hình của đoạn mã trên : x la so chan.
Lưu
ý :
 Lệnh break có tác dụng thoát khỏi điều kiện. Nếu không có lệnh break sau mỗi
đoạn lệnh case, chương tr

ình s
ẽ thực thi đến đoạn lệnh case tiếp theo (nếu thỏa điều
kiện).
 Cấu trúc switch-case có thể được thay thế bởi cấu trúc if , trong đó, condition trong
cấu trúc if sẽ là (expression == constant).
if (expression == constant 1)
{
Statement 1;
}
else if (expression == constant 2)
{
Statement 2;
}
else
{
Statement 3;
}
b) Cấu trúc lặp (Looping Construct) :
Lập trình ứng dụng trong kỹ thuật Chương I
Bộ môn Cơ điện tử Trang 19
Các cấu trúc lặp là một đoạn mã lệnh được lặp lại nhiều. C++/CLI cung cấp 2 loại cấu trúc
lặp : lặp có giới hạn (bao gồm cấu trúc for và for each) và lặp không giới hạn (bao gồm cấu trúc
while và do-while).
 Cấu trúc “while” :
Cấu trúc “while” thực hiện lặp lại một đoạn mã lệnh nếu như điều kiện lặp vẫn còn thỏa
mãn.
Cú pháp :
while (condition)
{
Statements; // Thực hiện lại đoạn lệnh khi condition vẫn còn

đúng.
}
VD : int x = 0;
while (x < 3)
{
Console::Write(“{0}/t”,x++);
}
Kết quả in ra màn hình : 0 1 2
 Cấu trúc “do-while” :
Cấu trúc do-while c
ũng tương t
ự như cấu trúc while; khác biệt duy nhất là cấu trú do-while
sẽ thực hiện đoạn lệnh trước rồi mới kiểm tra điều kiện trong khi cấu trúc while thì kiểm tra điều
kiện trước rồi mới thực hiện đoạn lệnh.
Cú pháp :
do
{
Statements; // Thực hiện lại đoạn lệnh khi condition vẫn còn
đúng.
} while (condition);
VD : int x = 0;
do
{
Console::Write(“{0}/t”,x++);
} while (x < 3);
Kết quả in ra màn hình : 0 1 2 3
Lưu
ý :
Lập trình ứng dụng trong kỹ thuật Chương I
Bộ môn Cơ điện tử Trang 20

 Cấu trúc while và do-while là các cấu trúc lặp vô hạn, do đó trong đoạn mã lệnh
phải có đoạn lệnh thoát khỏi vòng lặp.
 Cấu trúc “for” :
Cấu trúc “for” thực hiện lặp lại có giới hạn một đoạn mã lệnh .
Cú pháp :
for (initialization ; condition ; increment)
{
Statements; // Thực hiện lại đoạn lệnh khi condition vẫn còn
đúng.
}
initialization : Phát biểu khởi tạo, có thể có nhiều phát biểu, các phát biểu cách nhàu bằng
dấu “,” .
condition : Điều kiện, chỉ có duy nhất một điều kiện.
increment : tăng hoặc giảm dần giá trị biến khởi tạo. Có thể có nhiều.
VD : for (int i = 0 ; i < 3 ; i++)
{
Console::Write(“{0}/t”, i);
}
Kết quả in ra màn hình : 0 1 2
Trường hợp có nhiều phát biểu khởi tạo :
VD : for (int i= 0, j = 0, z = 0 ; (i+j+z) < 10 ; i++, j++, z++)
{
Console::WriteLine(“{0}/t”, (i+j));
}
Kết quả in ra màn hình : 0 2 4 6
 Cấu trúc “for each” :
Cấu trúc “for each” có chức năng tương tự như cấu trúc “for” và thường được dùng với
các biến kiểu tập hợp (collection). Tại mỗi vòng lặp, biến sẽ có giá trị bằng giá trị một phần tử của
tập hợp.
Cú pháp :

Lập trình ứng dụng trong kỹ thuật Chương I
Bộ môn Cơ điện tử Trang 21
for each (type name in collection) //name là tên biến, collection là tập hợp.
{
Statements; // Thực hiện lại đoạn lệnh.
}
VD : array <Char>^ M = {‘A’ , ‘B’ , ‘C’, ‘D’};
for each(Char x in M)
{
Console::Write(“{0}/t”, x);
}
Kết quả in ra màn hình : A B C D
8) Hàm (Function) :
Hàm được xem như là trung tâm của các chương tr
ình C++/CLI.
Về cơ bản, hàm là một
khối lệnh và có thể được thực thi khi được gọi ra từ bất cứ vị trí nào trong chương tr
ình. Có hai
kiểu hàm cơ bản : hàm trả về kiểu dữ liệu và hàm không trả về kiểu dữ liệu.
a) Hàm trả về kiểu dữ liệu :
Hàm trả về kiểu dữ liệu là hàm sau khi kết thúc sẽ trả về một giá trị, ta có giữ lấy giá trị
này bằng cách gán cho một biến.
Cú pháp :
type function-name (argument 1, argument 2, …)
{
Statements; // Đoạn mã lệnh của hàm.
return x; // Giá trị muốn trả về.
}
Trong đó, type là kiểu dữ liệu của giá trị hàm trả về, function-name là tên của hàm,
argument là tham số của hàm (bao gồm kiểu dữ liệu và tên của tham số). Số lượng tham số của

hàm là không giới hạn. Khi kết thúc đo
ãn mã l
ệnh của hàm phải có lệnh return, giá trị được dùng
với lệnh return chính là giá trị trả về của hàm.
Hàm được khai báo bên ngoài hàm main().Trong hàm main(), khi muốn sử dụng hàm, ta
có thể gọi hàm thông qua tên của hàm và các tham số được truyền vào. Sau đây là một ví dụ về
hàm giải phương tr
ình
bậc 1.
VD : using namespace Sytem;
int Solve (int a, int b) // Hàm giải pt bậc 1 ax + b = 0.
{
int x = -b/a;
return x; // Trả về giá trị nghiệm x.
Lập trình ứng dụng trong kỹ thuật Chương I
Bộ môn Cơ điện tử Trang 22
}
void main()
{
int x = 5, y =10;
int z = Solve (x,y); // Gọi hàm và truyền tham số cho hàm .
Console::WriteLine(z); // z = -2.
}
Lưu
ý :
 Tất cả các biến được khai báo bên trong hàm đều là biến tạm, các biến này sẽ bị xóa
sau khi hàm kết thúc. Do đó, các biến bên trong hàm và biến trong chương tr
ình
chính có thể trùng tên nhau.
 Hàm có thể được gọi nhiều lần trong chương tr

ình chính.
b) Hàm không trả về dữ liệu :
Hàm trả về dữ liệu là hàm sau khi kết thúc sẽ không trả về bất cứ một giá trị nào, do đó ta
chỉ có thể gọi trực tiếp hàm mà không thể gán cho một biến khác.
Cú pháp :
void function-name (argument 1, argument 2, …)
{
Statements; // Đoạn mã lệnh của hàm.
}
Hàm không trả về dữ liệu không có lệnh return ở cuối đoạn mã.
VD : using namespace Sytem;
void Solve (int a, int b) // Hàm giải pt bậc 1 ax + b = 0.
{
int x = -b/a;
Console::WriteLine (x);
}
void main()
{
int x = 5, y =10;
Solve (x,y); // Gọi hàm và truyền tham số cho hàm .
}
c) Truyền tham số cho hàm :
Lập trình ứng dụng trong kỹ thuật Chương I
Bộ môn Cơ điện tử Trang 23
Có hai cách truyền tham số cho hàm : tham trị (by value) và tham chiếu (by reference).
Điểm khác biệt duy nhất về cú pháp giữa hai cách truyền này là nếu truyền theo tham chiếu thì
trước tham số có thêm toán tử tham chiếu (%) hoặc địa chỉ (&) hoặc khai báo tham số theo kiểu
con trỏ.
VD : void Solve (int a, int b) // Truyền tham trị.
void Solve (int %a, int %b) // Truyền tham chiếu.

void Solve (int &a, int &b) // Truyền tham chiếu theo địa chỉ.
void Solve (int ^a, int ^b) // Truyền tham số kiểu con trỏ.
Về mặt bản chất, khi truyền tham số theo kiểu giá trị cho hàm, tức là ta chỉ truyền giá trị
của biến cho hàm chứ không phải bản thân của biến. Do đó, hàm này không thể thay đổi được giá
trị ban đầu của tham số.
VD : void Binh_phuong (int a) // Hàm tính bình ph
ương c
ủa một số.
{
a = a*a;
}
void main()
{
int x = 5;
Binh_phuong (x); // Gọi hàm và truyền tham số cho hàm .
Console::WriteLine(x);
}
Kết quả in ra màn hình : 5
Trong ví dụ trên, khi gọi hàm Binh_phuong(x) và truyền tham số x cho hàm c
ũng tư
ơng
đương với việc truyền số 5 cho hàm Binh_phuong(5) vì hàm chỉ quan tâm đến giá trị của tham số.
Do đó, nếu muốn sử dụng hàm để thay đổi giá trị của tham số, ta phải khai báo tham số theo kiểu
truyền tham chiếu.
VD : void Binh_phuong (int %a) // Hàm tính bình ph
ương c
ủa một số.
{
a = a*a;
}

void main()
{
int x = 5;
Binh_phuong (x); // Gọi hàm và truyền tham số cho hàm .
Console::WriteLine(x);
}
Lập trình ứng dụng trong kỹ thuật Chương I
Bộ môn Cơ điện tử Trang 24
Kết quả in ra màn hình : 25
VD : void Binh_phuong (int ^a) // Hàm tính bình ph
ương c
ủa một số.
{
*a = (*a)*(*a); // *a là toán tử gián tiếp.
}
void main()
{
int ^x = 5;
Binh_phuong (x); // Gọi hàm và truyền tham số cho hàm .
Console::WriteLine(x);
}
Kết quả in ra màn hình : 25
VD : void Binh_phuong (int &a) // Hàm tính bình ph
ương c
ủa một số.
{
a = a*a;
}
void main()
{

int x = 5;
Binh_phuong (x); // Gọi hàm và truyền tham số cho hàm .
Console::WriteLine(x);
}
Kết quả in ra màn hình : 25
Như vậy, ta có thể thấy khi truyền tham số theo kiểu tham chiếu, có ngh
ĩa là ta truy
ền
bản thân của biến cho hàm (can thiệp trực tiếp lên ô nhớ lưu trữ giá trị tham số).
d) Hàm đệ qui và chồng chập hàm :
Hàm đệ qui là hàm gọi lại chính bản thân hàm trong đoạn mã lệnh của hàm.
VD : int Factorial (int a) // Hàm tính giai thừa.
{
if (a > 1) return (a*Factorial(a-1));
else return 1;
}
Quá tải hàm (Overload function) : là các hàm có cùng tên nhưng khác nhau về số lượng
tham số hay kiểu dữ liệu của tham số. Chẳng hạn, hàm WriteLine() của Class Console là một quá
tải hàm, tham số của hàm có thể là kiểu interger, float, decimal, boolean, character hay String.
Lập trình ứng dụng trong kỹ thuật Chương I
Bộ môn Cơ điện tử Trang 25
Để tạo ra quá tải hàm, ta thực hiện khai báo nhiều hàm cùng tên với các kiểu dữ liệu khác
nhau hay số lượng tham số khác nhau.
VD : void Binh_phương (int %a) // Tham số kiểu int.
{
a = a*a;
}
void Binh_phương (float %a) // Tham số kiểu float.
{
a = a*a;

}
void Binh_phương (double %a) // Tham số kiểu double.
{
a = a*a;
}
Đọc thêm :
Class System::Math
Class Math là Class quản lí các hàm thực hiện các phép tính số học và các hằng số toán
học.
- Hằng số :
 PI : hằng số pi (3,14159) ( PI có kiểu double).
 E : hằng số e ( e có kiểu double).
VD : double x = Math::PI;
double y = Math::E;
- Các hàm lượng giác và lượng giác ngược :
 Cos (double x) : hàm cos.
 Sin (double x) : hàm sin.
 Tan (double x) : hàm tan.
 Acos (double x) : hàm arccos.
 Asin (double x) : hàm arcsin.
 Atan (double x) : hàm arctan.
- Các hàm đại số :
 Abs (x) : hàm lấy giá trị tuyệt đối.
 Sign (x) : hàm trả về dấu của x (-1,0,1).