Viết chương trình in ra màn hình dòng chữ hello, world 10 lần.

Ví dụ: 
a = 2 + (b = 5);
tương đương với 
b = 5;
a = 2 + b;
Vì vậy biểu thức sau cũng hợp lệ trong C++
a = b = c = 5; 
gán giá trị 5 cho cả ba biến a, b và c 
Các toán tử số học ( +, -, *, /, % )
Năm toán tử số học được hỗ trợ bởi ngôn ngữ là:

+ cộng


- trừ
* nhân
/ chia
% lấy phần dư (trong phép chia)
Thứ tự thực hiện các toán tử này cũng giống như chúng được thực hiện trong toán 
học. Điều duy nhất có vẻ hơi lạ đối với bạn là phép lấy phần dư, ký hiệu bằng dấu 
phần trăm (%). Đây chính là phép toán lấy phần dư trong phép chia hai số nguyên 
với nhau. Ví dụ, nếu a = 11 % 3;, biến a sẽ mang giá trị 2 vì 11 = 3*3 +2.
Các toán tử gán phức hợp (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=)
Một đặc tính của ngôn ngữ C++ làm cho nó nổi tiếng là một ngôn ngữ súc tích 
chính là các toán tử gán phức hợp cho phép chỉnh sửa giá trị của một biến với một 
trong những toán tử cơ bản sau:

value += increase; tương đương với value = value + 


increase;
a -= 5; tương đương với a = a - 5;
a /= b; tương đương với a = a / b;
price *= units + 1; tương đương với price = price * 
(units + 1); 
và tương tự cho tất cả các toán tử khác.
Tăng và giảm.
Một ví dụ khác của việc tiết kiệm khi viết mã lệnh là toán tử tăng (++) và giảm (--). 
Chúng tăng hoặc giảm giá trị chứa trong một biến đi 1. Chúng tương đương với 
+=1 hoặc -=1. Vì vậy, các dòng sau là tương đương:

a++;


a+=1;
a=a+1; 
Một tính chất của toán tử này là nó có thể là tiền tố hoặc hậu tố, có nghĩa là có thể 
viết trước tên biến (++a) hoặc sau (a++) và mặc dù trong hai biểu thức rất đơn giản 
đó nó có cùng ý nghĩa nhưng trong các thao tác khác khi mà kết quả của việc tăng 
hay giảm được sử dụng trong một biểu thức thì chúng có thể có một khác biệt quan 
trọng về ý nghĩa: Trong trường hợp toán tử được sử dụng như là một tiền tố (++a) 
giá trị được tăng trước khi biểu thức được tính và giá trị đã tăng được sử dụng 
trong biểu thức; trong trường hợp ngược lại (a++) giá trị trong biến a được tăng sau 
khi đã tính toán. Hãy chú ý sự khác biệt : 
Ví dụ 1 Ví dụ 2
B=3;
A=++B;
// A is 4, B is 4
B=3;
A=B++;
// A is 3, B is 4

Các toán tử quan hệ ( ==, !=, >, <, >=, <= )


Để có thể so sánh hai biểu thức với nhau chúng ta có thể sử dụng các toán tử quan 
hệ. Theo chuẩn ANSI-C++ thì giá trị của thao tác quan hệ chỉ có thể là giá trị logic 
- chúng chỉ có thể có giá trị true hoặc false, tuỳ theo biểu thức kết quả là đúng 
hay sai.

Sau đây là các toán tử quan hệ bạn có thể sử dụng trong C++


==
Bằng
!=
Khác
>
Lớn hơn
<
Nhỏ hơn
> =
Lớn hơn hoặc bằng
< =
Nhỏ hơn hoặc bằng
Ví dụ: 
(7 == 5)
sẽ trả giá trị false
(6 >= 6)
sẽ trả giá trị true
tất nhiên thay vì sử dụng các số, chúng ta có thể sử dụng bất cứ biểu thức 
nào. Cho a=2, b=3 và c=6
(a*b >= c)
sẽ trả giá trị true.
(b+4 < a*c)
sẽ trả giá trị false

Cần chú ý rằng = (một dấu bằng) lf hoàn toàn khác với == (hai dấu bằng). Dấu đầu 


tiên là một toán tử gán ( gán giá trị của biểu thức bên phải cho biến ở bên trái) và 
dấu còn lại (==) là một toán tử quan hệ nhằm so sánh xem hai biểu thức có bằng 
nhau hay không.

Trong nhiều trình dịch có trước chuẩn ANSI-C++ cũng như trong ngôn ngữ C, các toán 


tử quan hệ không trả về giá trị logic true hoặc false mà trả về giá trị int với 0 tương 
ứng với false còn giá trị khác 0 (thường là 1) thì tương ứng với true.

Các toán tử logic ( !, &&, || ).


Toán tử ! tương đương với toán tử logic NOT, nó chỉ có một đối số ở phía bên phải 
và việc duy nhất mà nó làm là đổi ngược giá trị của đối số từ true sang false hoặc 
ngược lại. Ví dụ:
!(5 == 5)
trả về false vì biểu thức bên phải (5 == 5) có giá trịtrue.
!(6 <= 4)
trả về true vì (6 <= 4)có giá trị false.
!true
trả về false.
!false
trả về true.
Toán tử logic && và || được sử dụng khi tính toán hai biểu thức để lấy ra một kết 
quả duy nhất. Chúng tương ứng với các toán tử logic AND và OR. Kết quả của 
chúng phụ thuộc vào mối quan hệ của hai đối số:
Đối số thứ nhất
a
Đối số thứ hai
b
Kết quả
a && b
Kết quả
a || b
true true true true
true false false true
false true false true
false false false false
Ví dụ: 
( (5 == 5) && (3 > 6) ) trả về false ( true && false ).
( (5 == 5) || (3 > 6)) trả về true ( true || false ). 
Toán tử điều kiện ( ? ).
Toán tử điều kiện tính toán một biểu thức và trả về một giá trị khác tuỳ thuộc vào 
biểu thức đó là đúng hay sai. Cấu trúc của nó như sau:
condition ? result1 : result2 
Nếu condition là true thì giá trị trả về sẽ là result1, nếu không giá trị trả về là 
result2.
7==5 ? 4 : 3
trả về 3 vì 7 không bằng 5.
7==5+2 ? 4 : 3
trả về 4 vì 7 bằng 5+2.
5>3 ? a : b
trả về a, vì 5 lớn hơn 3.
a>b ? a : b
trả về giá trị lớn hơn, a hoặc b.

Các toán tử thao tác bit ( &, |, ^, ~, <<, >> ).


Các toán tử thao tác bit thay đổi các bit biểu diễn một biến, có nghĩa là thay đổi 
biểu diễn nhị phân của chúng
toán tử asm Mô tả
& AND Logical AND
| OR Logical OR
^ XOR Logical exclusive OR
~ NOT Đảo ngược bit
<< SHL Dịch bit sang trái
>> SHR Dịch bit sang phải

Các toán tử chuyển đổi kiểu


Các toán tử chuyển đổi kiểu cho phép bạn chuyển đổi dữ liệu từ kiểu này sang kiểu 
khác. Có vài cách để làm việc này trong C++, cách cơ bản nhất được thừa kế từ 
ngôn ngữ C là đặt trước biểu thức cần chuyển đổi tên kiểu dữ liệu được bọc trong 
cặp ngoặc đơn (), ví dụ:
int i;
float f = 3.14;
i = (int) f; 
Đoạn mã trên chuyển số thập phân 3.14 sang một số nguyên (3). Ở đây, toán tử 
chuyển đổi kiểu là (int). Một cách khác để làm điều này trong C++ là sử dụng các 
constructors (ở một số sách thuật ngữ này được dịch là cấu tử nhưng tôi thấy nó có 
vẻ không xuôi tai lắm) thay vì dùng các toán tử : đặt trước biểu thức cần chuyển 
đổi kiểu tên kiểu mới và bao bọc biểu thức giữa một cặp ngoặc đơn. 
i = int ( f ); 
Cả hai cách chuyển đổi kiểu đều hợp lệ trong C++. Thêm vào đó ANSI-C++ còn có 
những toán tử chuyển đổi kiểu mới đặc trưng cho lập trình hướng đối tượng.

sizeof()


Toán tử này có một tham số, đó có thể là một kiểu dữ liệu hay là một biến và trả về 
kích cỡ bằng byte của kiểu hay đối tượng đó.
a = sizeof (char); 
a sẽ mang giá trị 1 vì kiểu char luôn có kích cỡ 1 byte trên mọi hệ thống. Giá trị trả 
về của sizeof là một hằng số vì vậy nó luôn luôn được tính trước khi chương trình 
thực hiện. 

Các toán tử khác


Trong C++ còn có một số các toán tử khác, như các toán tử liên quan đến con trỏ 
hay lập trình hướng đối tượng. Chúng sẽ được nói đến cụ thể trong các phần tương 
ứng.
Thứ tự ưu tiên của các toán tử
Khi viết các biểu thức phức tạp với nhiều toán hạng các bạn có thể tự hỏi toán hạng nào 
được tính trước, toán hạng nào được tính sau. Ví dụ như trong biểu thức sau: 
a = 5 + 7 % 2
có thể có hai cách hiểu sau: 
a = 5 + (7 % 2) với kết quả là 6, hoặc
a = (5 + 7) % 2 với kết quả là 0
Câu trả lời đúng là biểu thức đầu tiên. Vì nguyên nhân nói trên, ngôn ngữ C++ đã thiết lập 
một thứ tự ưu tiên giữa các toán tử, không chỉ riêng các toán tử số học mà tất cả các toán tử 
có thể xuất hiện trong C++. Thứ tự ưu tiên của chúng được liệt kê trong bảng sau theo thứ 
tự từ cao xuống thấp. 

Thứ tự Toán tử Mô tả Associativity


1
::
scope Trái
2
() [ ] -> . sizeof
Trái
3
++ --
tăng/giảm
~
Đảo ngược bit
!
NOT
& *
Toán tử con trỏ
(type)
Chuyển đổi kiểu
+ -
Dương hoặc âm
Phải
4
* / %
Toán tử số học Trái
5
+ -
Toán tử số học Trái
6
<< >>
Dịch bit Trái
7
< <= > >=
Toán tử quan hệ Trái
8
== !=
Toán tử quan hệ Trái
9
& ^ |
Toán tử thao tác bit Trái
10
&& ||
Toán tử logic Trái
11
?:
Toán tử điều kiện Phải
12
= += -= *= /= %=
Toán tử gán Phải
>>= <<= &= ^= |=
13
,
Dấu phẩy Trái
Associativity định nghĩa trong trường hợp có một vài toán tử có cùng thứ tự ưu tiên thì cái 
nào sẽ được tính trước, toán tử ở phía xa nhất bên phải hay là xa nhất bên trái.
Nếu bạn muốn viết một biểu thức phức tạp mà lại không chắc lắm về thứ tự ưu tiên của các 
toán tử thì nên sử dụng các ngoặc đơn. Các bạn nên thực hiện điều này vì nó sẽ giúp 
chương trình dễ đọc hơn.
Bài 3 : Các Cấu Trúc Điều Khiển
Một chương trình thường không chỉ bao gồm các lệnh tuần tự nối tiếp nhau. Trong quá 
trình chạy nó có thể rẽ nhánh hay lặp lại một đoạn mã nào đó. Để làm điều này chúng ta sử 
dụng các cấu trúc điều khiển. 
Cùng với việc giới thiệu các cấu trúc điều khiển chúng ta cũng sẽ phải biết tới một khái 
niệm mới: khối lệnh, đó là một nhóm các lệnh được ngăn cách bởi dấu chấm phẩy (;) 
nhưng được gộp trong một khối giới hạn bởi một cặp ngoặc nhọn: { và }.
Hầu hết các cấu trúc điều khiển mà chúng ta sẽ xem xét trong chương này cho phép sử 
dụng một lệnh đơn hay một khối lệnh làm tham số, tuỳ thuộc vào chúng ta có đặt nó trong 
cặp ngoặc nhọn hay không.
Cấu trúc điều kiện: if và else
Cấu trúc này được dùng khi một lệnh hay một khối lệnh chỉ được thực hiện khi một điều 
kiện nào đó thoả mãn. Dạng của nó như sau: 
if (condition) statement
trong đó condition là biểu thức sẽ được tính toán. Nếu điều kiện đó là true, statement 
được thực hiện. Nếu không statement bị bỏ qua (không thực hiện) và chương trình tiếp 
tục thực hiện lệnh tiếp sau cấu trúc điều kiện. 
Ví dụ, đoạn mã sau đây sẽ viết x is 100 chỉ khi biến x chứa giá trị 100: 
if (x == 100)
cout << "x is 100";
Nếu chúng ta muốn có hơn một lệnh được thực hiện trong trường hợp condition là true 
chúng ta có thể chỉ định một khối lệnh bằng cách sử dụng một cặp ngoặc nhọn { }: 
if (x == 100)
{
cout << "x is ";
cout << x;
}
Chúng ta cũng có thể chỉ định điều gì sẽ xảy ra nếu điều kiện không được thoả mãn bằng 
cách sửu dụng từ khoá else. Nó được sử dụng cùng với if như sau: 
if (condition) statement1 else statement2
Ví dụ: 
if (x == 100)
cout << "x is 100";
else
cout << "x is not 100";
Cấu trúc if + else có thể được móc nối để kiểm tra nhiều giá trị. Ví dụ sau đây sẽ kiểm tra 
xem giá trị chứa trong biến x là dương, âm hay bằng không.
if (x > 0)
cout << "x is positive";
else if (x < 0)
cout << "x is negative";
else
cout << "x is 0"; 
Các cấu trúc lặp
Mục đích của các vòng lặp là lặp lại một thao tác với một số lần nhất định hoặc trong khi 
một điều kiện nào đó còn thoả mãn. 
Vòng lặp while .
Dạng của nó như sau:
while (expression) statement 
và chức năng của nó đơn giản chỉ là lặp lại statement khi điều kiện expression 
còn thoả mãn. 
Ví dụ, chúng ta sẽ viết một chương trình đếm ngược sử dụng vào lặp while:
// custom countdown using while
#include
int main ()
{
int n;
cout << "Enter the starting 
number > ";
cin >> n;
Enter the starting number > 8
8, 7, 6, 5, 4, 3, 2, 1, FIRE!
while (n>0) {
cout << n << ", ";
--n;
}
cout << "FIRE!";
return 0;
}
Khi chương trình chạy người sử dụng được yêu cầu nhập vào một số để đếm 
ngược. Sau đó, khi vòng lặp while bắt đầu nếu số mà người dùng nhập vào thoả 
mãn điều kiện điều kiện n>0 khối lệnh sẽ được thực hiện một số lần không xác 
định chừng nào điều kiện (n>0) còn được thoả mãn.
Chúng ta cần phải nhớ rằng vòng lặp phải kết thúc ở một điểm nào đó, vì 
vậy bên trong vòng lặp chúng ta phải cung cấp một phương thức nào đó để 
buộc condition trở thành sai nếu không thì nó sẽ lặp lại mãi mãi. Trong ví 
dụ trên vòng lặp phải có lệnh --n; để làm cho condition trở thành sai sau 
một số lần lặp.
Vòng lặp do-while 
Dạng thức:
do statement while (condition); 
Chức năng của nó là hoàn toàn giống vòng lặp while chỉ trừ có một điều là điều 
kiện điều khiển vòng lặp được tính toán sau khi statement được thực hiện, vì vậy 
statement sẽ được thực hiện ít nhất một lần ngay cả khi condition không bao 
giờ được thoả mãn. Ví dụ, chương trình dưới đây sẽ viết ra bất kì số nào mà bạn 
nhập vào cho đến khi bạn nhập số 0.
// number echoer
#include
int main ()
{
unsigned long n;
do {
cout << "Enter number (0 to 
end): ";
cin >> n;
cout << "You entered: " << n 
<< "\n";
} while (n != 0);
return 0;
}
Enter number (0 to end): 12345
You entered: 12345
Enter number (0 to end): 160277
You entered: 160277
Enter number (0 to end): 0
You entered: 0
Vòng lặp do-while thường được dùng khi điều kiện để kết thúc vòng lặp nằm trong 
vòng lặp, như trong ví dụ trên, số mà người dùng nhập vào là điều kiện kiểm tra để 
kết thúc vòng lặp. Nếu bạn không nhập số 0 trong ví dụ trên thì vòng lặp sẽ không 
bao giờ chấm dứt.
Vòng lặp for . 
Dạng thức:
for (initialization; condition; increase) statement; 
và chức năng chính của nó là lặp lại statement chừng nào condition còn mang 
giá trị đúng, như trong vòng lặp while. Nhưng thêm vào đó, for cung cấp chỗ dành 
cho lệnh khởi tạo và lệnh tăng. Vì vậy vòng lặp này được thiết kế đặc biệt lặp lại 
một hành động với một số lần xác định. 
Cách thức hoạt động của nó như sau: 
1, initialization được thực hiện. Nói chung nó đặt một giá khí ban đầu 
cho biến điều khiển. Lệnh này được thực hiện chỉ một lần.
2, condition được kiểm tra, nếu nó là đúng vòng lặp tiếp tục còn nếu 
không vòng lặp kết thúc và statement được bỏ qua.
3, statement được thực hiện. Nó có thể là một lệnh đơn hoặc là một khối 
lệnh được bao trong một cặp ngoặc nhọn.
4, Cuối cùng, increase được thực hiện để tăng biến điều khiển và vòng lặp 
quay trở lại bước 2.
Sau đây là một ví dụ đếm ngược sử dụng vòng for. 
// countdown using a for loop
#include
int main ()
{
for (int n=10; n>0; n--) {
cout << n << ", ";
}
cout << "FIRE!";
return 0;
}
10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 
FIRE!
Phần khởi tạo và lệnh tăng không bắt buộc phải có. Chúng có thể được bỏ qua 
nhưng vẫn phải có dấu chấm phẩy ngăn cách giữa các phần. Vì vậy, chúng ta có thể 
viết for (;n<10;) hoặc for (;n<10;n++).
Bằng cách sử dụng dấu phẩy, chúng ta có thể dùng nhiều lệnh trong bất kì 
trường nào trong vòng for, như là trong phần khởi tạo. Ví dụ chúng ta có 
thể khởi tạo một lúc nhiều biến trong vòng lặp: 
for ( n=0, i=100 ; n!=i ; n++, i-- )
{
// cái gì ở đây cũng được...
}
Vòng lặp này sẽ thực hiện 50 lần nếu như n và i không bị thay đổi trong 
thân vòng lặp: 
Các lệnh rẽ nhánh và lệnh nhảy
Lệnh break.
Sử dụng break chúng ta có thể thoát khỏi vòng lặp ngay cả khi điều kiện để nó kết 
thúc chưa được thoả mãn. Lệnh này có thể được dùng để kết thúc một vòng lặp 
không xác định hay buộc nó phải kết thúc giữa chừng thay vì kết thúc một cách 
bình thường. Ví dụ, chúng ta sẽ dừng việc đếm ngược trước khi nó kết thúc: 
// break loop example
#include
int main ()
{
int n;
for (n=10; n>0; n--) {
cout << n << ", ";
if (n==3)
{
cout << "countdown 
aborted!";
break;
}
}
return 0;
}
10, 9, 8, 7, 6, 5, 4, countdown 
aborted!
Lệnh continue.
Lệnh continue làm cho chương trình bỏ qua phần còn lại của vòng lặp và nhảy sang 
lần lặp tiếp theo. Ví dụ chúng ta sẽ bỏ qua số 5 trong phần đếm ngược:
// break loop example
#include
int main ()
{
for (int n=10; n>0; n--) {
if (n==5) continue;
cout << n << ", ";
}
10, 9, 8, 7, 6, 4, 3, 2, 1, 
FIRE!
cout << "FIRE!";
return 0;
}
Lệnh goto.
Lệnh này cho phép nhảy vô điều kiện tới bất kì điểm nào trong chương trình. Nói 
chung bạn nên tránh dùng nó trong chương trình C++. Tuy nhiên chúng ta vẫn có 
một ví dụ dùng lệnh goto để đếm ngược: 
// goto loop example
#include
int main ()
{
int n=10;
loop: ;
cout << n << ", ";
n--;
if (n>0) goto loop;
cout << "FIRE!";
return 0;
}
10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 
FIRE!
Hàm exit.
Mục đích của exit là kết thúc chương trình và trả về một mã xác định. Dạng thức 
của nó như sau 
void exit (int exit code);
exit code được dùng bởi một số hệ điều hành hoặc có thể được dùng bởi các 
chương trình gọi. Theo quy ước, mã trả về 0 có nghĩa là chương trình kết thúc bình 
thường còn các giá trị khác 0 có nghĩa là có lỗi.
Cấu trúc lựa chọn: switch.
Cú pháp của lệnh switch hơi đặc biệt một chút. Mục đích của nó là kiểm tra một vài giá trị 
hằng cho một biểu thức, tương tự với những gì chúng ta làm ở đầu bài này khi liên kết một 
vài lệnh if và else if với nhau. Dạng thức của nó như sau: 
switch (expression) {
case constant1:
block of instructions 1
break;
case constant2:
block of instructions 2
break;
.
.
.
default:
default block of instructions
}
Nó hoạt động theo cách sau: switch tính biểu thức và kiểm tra xem nó có bằng constant1 
hay không, nếu đúng thì nó thực hiện block of instructions 1 cho đến khi tìm thấy từ 
khoá break, sau đó nhảy đến phần cuối của cấu trúc lựa chọn switch.
Còn nếu không, switch sẽ kiểm tra xem biểu thức có bằng constant2 hay không. Nếu 
đúng nó sẽ thực hiện block of instructions 2 cho đến khi tìm thấy từ khoá break.
Cuối cùng, nếu giá trị biểu thức không bằng bất kì hằng nào được chỉ định ở trên (bạn có 
thể chỉ định bao nhiêu câu lệnh case tuỳ thích), chương trình sẽ thực hiện các lệnh trong 
phần default: nếu nó tồn tại vì phần này không bắt buộc phải có. 
Hai đoạn mã sau là tương đương:
ví dụ switch if-else tương đương 
switch (x) {
case 1:
cout << "x is 1";
break;
case 2:
cout << "x is 2";
break;
default:
cout << "value of x 
unknown";
}
if (x == 1) {
cout << "x is 1";
}
else if (x == 2) {
cout << "x is 2";
}
else {
cout << "value of x unknown";
}
Tôi đã nói ở trên rằng cấu trúc của lệnh switch hơi đặc biệt. Chú ý sự tồn tại của lệnh 
break ở cuối mỗi khối lệnh. Điều này là cần thiết vì nếu không thì sau khi thực hiện block 
of instructions 1 chương trình sẽ không nhảy đến cuối của lệnh switch mà sẽ thực 
hiện các khối lệnh tiếp theo cho đến khi nó tìm thấy lệnh break đầu tiên. Điều này khiến 
cho việc đặt cặp ngoặc nhọn { } trong mỗi trường hợp là không cần thiết và có thể được 
dùng khi bạn muốn thực hiện một khối lệnh cho nhiều trường hợp khác nhau, ví dụ:
switch (x) {
case 1:
case 2:
case 3:
cout << "x is 1, 2 or 3";
break;
default:
cout << "x is not 1, 2 nor 3";
}
Chú ý rằng lệnh switch chỉ có thể được dùng để so sánh một biểu thức với các hằng. Vì 
vậy chúng ta không thể đặt các biến (case (n*2):) hay các khoảng (case (1..3):) vì 
chúng không phải là các hằng hợp lệ. 
style="BORDER-RIGHT: medium none; PADDING-RIGHT: 0cm; BORDER-TOP: 
medium none; PADDING-LEFT: 0cm; PADDING-BOTTOM: 0cm; BORDER-LEFT: 
medium none; PADDING-TOP: 0cm; BORDER-BOTTOM: windowtext 3pt solid"> 
Nếu bạn cần kiểm tra các khoảng hay nhiều giá trị không phải là hằng số hãy kết hợp các 
lệnh if và else if
Bài 4 : Hàm (I)
Hàm là một khối lệnh được thực hiện khi nó được gọi từ một điểm khác của chương trình. 
Dạng thức của nó như sau: 
type name ( argument1, argument2, ...) statement
trong đó:
type là kiểu dữ liệu được trả về của hàm
name là tên gọi của hàm.
arguments là các tham số (có nhiều bao nhiêu cũng được tuỳ theo nhu cầu). Một tham số 
bao gồm tên kiểu dữ liệu sau đó là tên của tham số giống như khi khai báo biến (ví dụ int 
x) và đóng vai trò bên trong hàm như bất kì biến nào khác. Chúng dùng để truyền tham số 
cho hàm khi nó được gọi. Các tham số khác nhau được ngăn cách bởi các dấu phẩy.
statement là thân của hàm. Nó có thể là một lệnh đơn hay một khối lệnh. 
Dưới đây là ví dụ đầu tiên về hàm:
// function example
#include

int addition (int a, int b)


{
int r;
r=a+b;
return (r);
}

int main ()


{
int z;
z = addition (5,3);
cout << "The result is " << z;
return 0;
}
The result is 8
Để có thể hiểu được đoạn mã này, trước hết hãy nhớ lại những điều đã nói ở bài đầu tiên: 
một chương trình C++ luôn bắt đầu thực hiện từ hàm main. Vì vậy chúng ta bắt đầu từ đây.
Chúng ta có thể thấy hàm main bắt đầu bằng việc khai báo biến z kiểu int. Ngay sau đó là 
một lời gọi tới hàm addition. Nếu để ý chúng ta sẽ thấy sự tương tự giữa cấu trúc của lời 
gọi hàm với khai báo của hàm: 
Các tham số có vai trò thật rõ ràng. Bên trong hàm main chúng ta gọi hàm addition và 
truyền hai giá trị: 5 và 3 tương ứng với hai tham số int a và int b được khai báo cho 
hàm addition. 
Vào thời điểm hàm được gọi từ main, quyền điều khiển được chuyển sang cho hàm 
addition. Giá trị của c hai tham số (5 và 3) được copy sang hai biến cục bộ int a và int 
b bên trong hàm. 
Dòng lệnh sau: 
return (r);
kết thúc hàm addition, và trả lại quyền điều khiển cho hàm nào đã gọi nó (main) và tiếp 
tục chương trình ở cái điểm mà nó bị ngắt bởi lời gọi đến addition. Nhưng thêm vào đó, 
giá trị được dùng với lệnh return (r) chính là giá trị được trả về của hàm.\ 
Giá trị trả về bởi một hàm chính là giá trị của hàm khi nó được tính toán. Vì vậy biến z sẽ 
có có giá trị được trả về bởi addition (5, 3), đó là 8. 

Phạm vi hoạt động của các biến [nhắc lại] 


Bạn cần nhớ rằng phạm vi hoạt động của các biến khai báo trong một hàm hay bất kì một 
khối lệnh nào khác chỉ là hàm đó hay khối lệnh đó và không thể sử dụng bên ngoài chúng. 
Ví dụ, trong chương trình ví dụ trên, bạn không thể sử dụng trực tiếp các biến a, b hay r 
trong hàm main vì chúng là các biến cục bộ của hàm addition. Thêm vào đó bạn cũng 
không thể sử dụng biến z trực tiếp bên trong hàm addition vì nó làm biến cục bộ của hàm 
main. 
Tuy nhiên bạn có thể khai báo các biến toàn cục để có thể sử dụng chúng ở bất kì đâu, bên 
trong hay bên ngoài bất kì hàm nào. Để làm việc này bạn cần khai báo chúng bên ngoài mọi 
hàm hay các khối lệnh, có nghĩa là ngay trong thân chương trình.
Đây là một ví dụ khác về hàm:
// function example
#include

int subtraction (int a, int b)


{
int r;
r=a-b;
return (r);
}

int main ()


{
int x=5, y=3, z;
z = subtraction (7,2);
cout << "The first result is " << 
z << '\n';
cout << "The second result is " << 
subtraction (7,2) << '\n';
cout << "The third result is " << 
subtraction (x,y) << '\n';
z= 4 + subtraction (x,y);
cout << "The fourth result is " << 
z << '\n';
return 0;
}
The first result is 5
The second result is 5
The third result is 2
The fourth result is 6
Trong trường hợp này chúng ta tạo ra hàm subtraction. Chức năng của hàm này là lấy 
hiệu của hai tham số rồi trả về kết quả. 
Tuy nhiên, nếu phân tích hàm main các bạn sẽ thấy chương trình đã vài lần gọi đến hàm 
subtraction. Tôi đã sử dụng vài cách gọi khác nhau để các bạn thấy các cách khác nhau 
mà một hàm có thể được gọi.
Để có hiểu cặn kẽ ví dụ này bạn cần nhớ rằng một lời gọi đến một hàm có thể hoàn toàn 
được thay thế bởi giá trị của nó. Ví dụ trong lệnh gọi hàm đầu tiên : 
z = subtraction (7,2);
cout << "The first result is " << z;
Nếu chúng ta thay lời gọi hàm bằng giá trị của nó (đó là 5), chúng ta sẽ có: 
z = 5;
cout << "The first result is " << z;
Tương tự như vậy 
cout << "The second result is " << subtraction (7,2); 
cũng cho kết quả giống như hai dòng lệnh trên nhưng trong trường hợp này chúng ta gọi 
hàm subtraction trực tiếp như là một tham số của cout. Chúng ta cũng có thể viết: 
cout << "The second result is " << 5;
vì 5 là kết quả của subtraction (7,2).
Còn với lệnh 
cout << "The third result is " << subtraction (x,y);
Điều mới mẻ duy nhất ở đây là các tham số của subtraction là các biến thay vì các hằng. 
Điều này là hoàn toàn hợp lệ. Trong trường hợp này giá trị được truyền cho hàm 
subtraction là giá trị của x and y. 
Trường hợp thứ tư cũng hoàn toàn tương tự. Thay vì viết 
z = 4 + subtraction (x,y);
chúng ta có thể viết: 
z = subtraction (x,y) + 4;
cũng hoàn toàn cho kết quả tương đương. Chú ý rằng dấu chấm phẩy được đặt ở cuối biểu 
thức chứ không cần thiết phải đặt ngay sau lời gọi hàm. 
Các hàm không kiểu. Cách sử dụng void.
Nếu bạn còn nhớ cú pháp của một lời khai báo hàm: 
type name ( argument1, argument2 ...) statement
bạn sẽ thấy rõ ràng rằng nó bắt đầu với một tên kiểu, đó là kiểu dữ liệu sẽ được hàm trả về 
bởi lệnh return. Nhưng nếu chúng ta không muốn trả về giá trị nào thì sao ?
Hãy tưởng tượng rằng chúng ta muốn tạo ra một hàm chỉ để hiển thị một thông báo lên 
màn hình. Nó không cần trả về một giá trị nào cả, hơn nữa cũng không cần nhận tham số 
nào hết. Vì vậy người ta đã nghĩ ra kiểu dữ liệu void trong ngôn ngữ C. Hãy xem xét 
chương trình sau: 
// void function example
#include

void dummyfunction (void)


{
I'm a function!
cout << "I'm a function!";
}

int main ()


{
dummyfunction ();
return 0;
}
Từ khoá void trong phần danh sách tham số có nghĩa là hàm này không nhận một tham số 
nào. Tuy nhiên trong C++ không cần thiết phải sử dụng void để làm điều này. Bạn chỉ đơn 
giản sử dụng cặp ngoặc đơn ( ) là xong.
Bởi vì hàm của chúng ta không có một tham số nào, vì vậy lời gọi hàm dummyfunction sẽ 
là : 
dummyfunction ();
style="BORDER-RIGHT: medium none; PADDING-RIGHT: 0in; BORDER-TOP: 
medium none; PADDING-LEFT: 0in; PADDING-BOTTOM: 0in; BORDER-LEFT: 
medium none; PADDING-TOP: 0in; BORDER-BOTTOM: windowtext 3pt solid"> 
Hai dấu ngoặc đơn là cần thiết để cho trình dịch hiểu đó là một lời gọi hàm chứ không phải 
là một tên biến hay bất kì dấu hiệu nào khác. 
Bài 5 : Hàm (II)
Truyền tham số theo tham số giá trị hay tham số biến.
Cho đến nay, trong tất cả các hàm chúng ta đã biết, tất cả các tham số truyền cho hàm đều 
được truyền theo giá trị. Điều này có nghĩa là khi chúng ta gọi hàm với các tham số, những 
gì chúng ta truyền cho hàm là các giá trị chứ không phải bản thân các biến. Ví dụ, giả sử 
chúng ta gọi hàm addition như sau: 
int x=5, y=3, z;
z = addition ( x , y );
Trong trường hợp này khi chúng ta gọi hàm addition thì các giá trị 5 and 3 được truyền 
cho hàm, không phải là bản thân các biến. 
Đến đây các bạn có thể hỏi tôi: Như vậy thì sao, có ảnh hưởng gì đâu ? Điều đáng nói ở 
đây là khi các bạn thay đổi giá trị của các biến a hay b bên trong hàm thì các biến x và y 
vẫn không thay đổi vì chúng đâu có được truyền cho hàm chỉ có giá trị của chúng được 
truyền mà thôi.
Hãy xét trường hợp bạn cần thao tác với một biến ngoài ở bên trong một hàm. Vì vậy bạn 
sẽ phải truyền tham số dưới dạng tham số biến như ở trong hàm duplicate trong ví dụ 
dưới đây:
// passing parameters by reference
#include

void duplicate (int& a, int& b, int& 


c)
{
a*=2;
b*=2;
c*=2;
}

int main ()


{
int x=1, y=3, z=7;
duplicate (x, y, z);
cout << "x=" << x << ", y=" << y 
<< ", z=" << z;
return 0;
}
x=2, y=6, z=14
Điều đầu tiên làm bạn chú ý là trong khai báo của duplicate theo sau tên kiểu của mỗi 
tham số đều là dấu và (&), để báo hiệu rằng các tham số này được truyền theo tham số biến 
chứ không phải tham số giá trị.
Khi truyền tham số dưới dạng tham số biến chúng ta đang truyền bản thân biến đó và bất kì 
sự thay đổi nào mà chúng ta thực hiện với tham số đó bên trong hàm sẽ ảnh hưởng trực 
tiếp đến biến đó. 
Trong ví dụ trên, chúng ta đã liên kết a, b và c với các tham số khi gọi hàm (x, y và z) và 
mọi sự thay đổi với a bên trong hàm sẽ ảnh hưởng đến giá trị của x và hoàn toàn tương tự 
với b và y, c và z.
Kiểu khai báo tham số theo dạng tham số biến sử dụng dấu và (&) chỉ có trong C++. Trong 
ngôn ngữ C chúng ta phải sử dụng con trỏ để làm việc tương tự như thế.
Truyền tham số dưới dạng tham số biến cho phép một hàm trả về nhiều hơn một giá trị. Ví 
dụ, đây là một hàm trả về số liền trước và liền sau của tham số đầu tiên.
// more than one returning value
#include

void prevnext (int x, int& prev, 


int& next)
{
prev = x-1;
next = x+1;
}

int main ()


{
int x=100, y, z;
prevnext (x, y, z);
cout << "Previous=" << y << ", 
Next=" << z;
return 0;
}
Previous=99, Next=101
Giá trị mặc định của tham số.
Khi định nghĩa một hàm chúng ta có thể chỉ định những giá trị mặc định sẽ được truyền 
cho các đối số trong trường hợp chúng bị bỏ qua khi hàm được gọi. Để làm việc này đơn 
giản chỉ cần gán một giá trị cho đối số khi khai báo hàm. Nếu giá trị của tham số đó vẫn 
được chỉ định khi gọi hàm thì giá trị mặc định sẽ bị bỏ qua. Ví dụ: 
// default values in functions
#include

int divide (int a, int b=2)


{
int r;
r=a/b;
return (r);
}

int main ()


{
cout << divide (12);
cout << endl;
cout << divide (20,4);
return 0;
}
6
5
Nhưng chúng ta thấy trong thân chương trình, có hai lời gọi hàm divide. Trong lệnh đầu 
tiên: 
divide (12)