Giáo trình C++

Ma Bư · 01-01-1970, 07:00 AM

Bài 1.1

Cấu trúc của một chương trình C++

Bài này dài lắm mời các bạn tham khảo.

Có lẽ một trong những cách tốt nhất để bắt đầu học một ngôn ngữ lập trình là bằng một chương trình. Vậy đây là chương trình đầu tiên của chúng ta :

// my first program in C++

#include

int main ()
{
cout << "Hello World!";
return 0;
}

Hello World!

Chương trình trên đây là chương trình đầu tiên mà hầu hết những người học nghề lập trình viết đầu tiên và kết quả của nó là viết câu "Hello, World" lên màn hình. Đây là một trong những chương trình đơn giản nhất có thể viết bằng C++ nhưng nó đã bao gồm những phần cơ bản mà mọi chương trình C++ có. Hãy cùng xem xét từng dòng một :

// my first program in C++

Đây là dòng chú thích. Tất cả các dòng bắt đầu bằng hai dấu sổ (//) được coi là chút thích mà chúng không có bất kì một ảnh hưởng nào đến hoạt động của chương trình. Chúng có thể được các lập trình viên dùng để giải thích hay bình phẩm bên trong mã nguồn của chương trình. Trong trường hợp này, dòng chú thích là một giải thích ngắn gọn những gì mà chương trình chúng ta làm.

#include
Các câu bắt đầu bằng dấu (#) được dùng cho preprocessor (ai dịch hộ tôi từ này với). Chúng không phải là những dòng mã thực hiện nhưng được dùng để báo hiệu cho trình dịch. Ở đây câu lệnh #include báo cho trình dịch biết cần phải "include" thư viện iostream. Đây là một thư viện vào ra cơ bản trong C++ và nó phải được "include" vì nó sẽ được dùng trong chương trình. Đây là cách cổ điển để sử dụng thư viện iostream

int main ()
Dòng này tương ứng với phần bắt đầu khai báo hàm main. Hàm main là điểm mà tất cả các chương trình C++ bắt đầu thực hiện. Nó không phụ thuộc vào vị trí của hàm này (ở đầu, cuối hay ở giữa của mã nguồn) mà nội dung của nó luôn được thực hiện đầu tiên khi chương trình bắt đầu. Thêm vào đó, do nguyên nhân nói trên, mọi chương trình C++ đều phải tồn tại một hàm main.

Theo sau main là một cặp ngoặc đơn bởi vì nó là một hàm. Trong C++, tất cả các hàm mà sau đó là một cặp ngoặc đơn () thì có nghĩa là nó có thể có hoặc không có tham số (không bắt buộc). Nội dung của hàm main tiếp ngay sau phần khai báo chính thức được bao trong các ngoặc nhọn ( { } ) như trong ví dụ của chúng ta

cout << "Hello World";
Dòng lệnh này làm việc quan trọng nhất của chương trình. cout là một dòng (stream) output chuẩn trong C++ được định nghĩa trong thư viện iostream và những gì mà dòng lệnh này làm là gửi chuỗi kí tự "Hello World" ra màn hình.

Chú ý rằng dòng này kết thúc bằng dấu chấm phẩy ( ; ). Kí tự này được dùng để kết thúc một lệnh và bắt buộc phải có sau mỗi lệnh trong chương trình C++ của bạn (một trong những lỗi phổ biến nhất của những lập trình viên C++ là quên mất dấu chấm phẩy).

return 0;
Lệnh return kết thúc hàm main và trả về mã đi sau nó, trong trường hợp này là 0. Đây là một kết thúc bình thường của một chương trình không có một lỗi nào trong quá trình thực hiện. Như bạn sẽ thấy trong các ví dụ tiếp theo, đây là một cách phổ biến nhất để kết thúc một chương trình C++.

Chương trình được cấu trúc thành những dòng khác nhau để nó trở nên dễ đọc hơn nhưng hoàn toàn không phải bắt buộc phải làm vậy. Ví dụ, thay vì viết

int main ()
{
cout << " Hello World ";
return 0;
}

ta có thể viết

int main () { cout << " Hello World "; return 0; }

cũng cho một kết quả chính xác như nhau.

Trong C++, các dòng lệnh được phân cách bằng dấu chấm phẩy ( . Việc chia chương trình thành các dòng chỉ nhằm để cho nó dễ đọc hơn mà thôi.

Các chú thích.

Các chú thích được các lập trình viên sử dụng để ghi chú hay mô tả trong các phần của chương trình. Trong C++ có hai cách để chú thích

// Chú thích theo dòng
/* Chú thích theo khối */

Chú thích theo dòng bắt đầu từ cặp dấu xổ (//) cho đến cuối dòng. Chú thích theo khối bắt đầu bằng /* và kết thúc bằng */ và có thể bao gồm nhiều dòng. Chúng ta sẽ thêm các chú thích cho chương trình :

/* my second program in C++
with more comments */

#include

int main ()
{
cout << "Hello World! "; // says Hello World!
cout << "I'm a C++ program"; // says I'm a C++ program
return 0;
}

Hello World! I'm a C++ program

Nếu bạn viết các chú thích trong chương trình mà không sử dụng các dấu //, /* hay */, trình dịch sẽ coi chúng như là các lệnh C++ và sẽ hiển thị các lỗi

Ma Bư · 01-01-1970, 07:00 AM

Bài 1.2

Các biến, kiểu và hằng số

Identifiers

Một tên (indentifiers) hợp lệ là một chuỗi gồm các chữ cái, chữ số hoặc kí tự gạch dưới. Chiều dài của một tên là không giới hạn.

Kí tự trống, các kí tự đánh dấu đều không thể có mặt trong một tên. Chỉ có chữ cái, chữ số và kí tự gạch dưới là được cho phép. Thêm vào đó, một tên biến luôn phải bắt đầu bằng một chữ cái. Chúng cũng có thể bắt đầu bằng kí tự gạch dưới ( _ ) nhưng kí tự này thường được dành cho các liên kết bên ngoài (external link). Không bao giờ chúng bắt đầu bằng một chữ số.

Một luật nữa mà bạn phải quan tâm đến khi tạo ra các tên của riêng mình là chúng không được trùng với bất kì từ khoá nào của ngôn ngữ hay của trình dịch, ví dụ các tên sau đây luôn luôn được coi là từ khoá theo chuẩn ANSI-C++ và do vậy chúng không thể được dùng để đặt tên

asm, car, bool, break, marry, catch, to char, class, const, const_cast, continue, default, delete, do, double, dynamic_cast, else, enum, explicit, extern, false, float, for, friend, goto, if, inline, int, long, mutable, namespace, new, operator, private, protected, public, to register, reinterpret_cast, return, short, signed, sizeof, static, static_cast, struct, switch, template, this, throw, true, try, typedef, typeid, typename, union, unsigned, using, virtual, void, volatile, wchar_t

Thêm vào đó, một số biểu diễn khác của các toán tử (operator) cũng không được dùng làm tên vì chúng là những từ được dành riêng trong một số trường hợp.

and, and_eq, bitand, bitor, compl, not, not_eq, or, or_eq, xor, xor_eq

Trình dịch của bạn có thể thêm một từ dành riêng đặc trưng khác. Ví dụ, rất nhiều trình dịch 16 bit (như các trình dịch cho DOS) còn có thể các từ khoá far, huge và near.

Chú ý: Ngôn ngữ C++ là "case sensitive" có nghĩa là phân biệt chữ hoa chữ thường. Do vậy biến RESULT khác với result cũng như Result.

Các kiểu dữ liệu

Khi lập trình, chúng ta lưu trữ các biến trong bộ nhớ của máy tính nhưng máy tính phải biết chúng ta muốn lưu trữ gì trong chúng vì các kiểu dữ liệu khác nhau sẽ cần lượng bộ nhớ khác nhau.

Bộ nhớ của máy tính chúng ta được tổ chức thành các byte. Một byte là lượng bộ nhớ nhỏ nhất mà chúng ta có thể quản lí. Một byte có thể dùng để lưu trữ một loại dữ liệu nhỏ như là kiểu số nguyên từ 0 đến 255 hay một kí tự. Nhưng máy tính có thể xử lý các kiểu dữ liệu phức tạp hơn bằng cách gộp nhiều byte lại với nhau, như số nguyên dài hay số thập phân. Tiếp theo bạn sẽ có một danh sách các kiểu dữ liệu cơ bản trong C++ cũng như miền giá trị mà chúng có thể biểu diễn

Ngoài các kiểu dữ liệu cơ bản nói trên còn tồn tại các con trỏ và các tham số không kiểu (void) mà chúng ta sẽ xem xét sau.

Khai báo một biến

Để có thể sử dụng một biến trong C++, đầu tiên chúng ta phải khai báo nó, ghi rõ nó là kiểu dữ liệu nào. Chúng ta chỉ cần viết tên kiểu (như int, short, float...) tiếp theo sau đó là một tên biến hợp lệ. Ví dụ

int a;
float mynumber;

Dòng đầu tiên khai báo một biến kiểu int với tên là a. Dòng thứ hai khai báo một biến kiểu float với tên mynumber. Sau khi được khai báo, các biến trên có thể được dùng trong phạm vi của chúng trong chương trình.

Nếu bạn muốn khai báo một vài biến có cùng một kiểu và bạn muốn tiết kiệm công sức viết bạn có thể khai báo chúng trên một dòng, ngăn cách các tên bằng dấu phẩy. Ví dụ

int a, b, c;

khai báo ba biến kiểu int (a,b và c) và hoàn toàn tương đương với :

int a;
int b;
int c;

Các kiểu số nguyên (char, short, long and int) có thể là số có dấu hay không dấu tuỳ theo miền giá trị mà chúng ta cần biểu diễn. Vì vậy khi xác định một kiểu số nguyên chúng ta đặt từ khoá signed hoặc unsigned trước tên kiểu dữ liệu. Ví dụ:

unsigned short NumberOfSons;
signed int MyAccountBalance;

Nếu ta không chỉ rõ signed or unsigned nó sẽ được coi là có dấu, vì vậy trong khai báo thứ hai chúng ta có thể viết :

int MyAccountBalance

cũng hoàn toàn tương đương với dòng khai báo ở trên. Trong thực tế, rất ít khi người ta dùng đến từ khoá signed. Ngoại lệ duy nhất của luật này kiểu char. Trong chuẩn ANSI-C++ nó là kiểu dữ liệu khác với signed char và unsigned char.

Để có thể thấy rõ hơn việc khai báo trong chương trình, chúng ta sẽ xem xét một đoạn mã C++ ví dụ như sau:

// operating with variables

#include <iostream.h>

int main ()
{
// declaring variables:
int a, b;
int result;

// process:
a = 5;
b = 2;
a = a + 1;
result = a - b;

// print out the result:
cout << result;

// terminate the program:
return 0;
}

Đừng lo lắng nếu như việc khai báo có vẻ hơi lạ lùng với bạn. Bạn sẽ thấy phần chi tiết còn lại trong phần tiếp theo

Khởi tạo các biến

Khi khai báo một biến, giá trị của nó mặc nhiên là không xác định. Nhưng có thể bạn sẽ muốn nó mang một giá trị xác định khi được khai báo. Để làm điều đó, bạn chỉ cần viết dấu bằng và giá trị bạn muốn biến đó sẽ mang:

type identifier = initial_value ;

Ví dụ, nếu chúng ta muốn khai báo một biến int là a chứa giá trị 0 ngay từ khi khởi tạo, chúng ta sẽ viết :

int a = 0;

Bổ xung vào cách khởi tạo kiểu C này, C++ còn có thêm một cách mới để khởi tạo biến bằng cách bọc một cặp ngoặc đơn sau giá trị khởi tạo. Ví dụ :

int a (0);

Cả hai cách đều hợp lệ trong C++.

Phạm vi hoạt động của các biến

Tất cả các biến mà chúng ta sẽ sử dụng đều phải được khai báo trước. Một điểm khác biết giữa Cvà C++ là trong C++ chúng ta có thể khai báo biến ở bất kì nơi nào trong chương trình, thậm chí là ngay ở giữa các lệnh thực hiện chứ không chỉ là ở đầu khối lệnh như ở trong C.

Mặc dù vậy chúng ta vẫn nên theo cách của ngôn ngữ C khi khai báo các biến bởi vì nó sẽ rất hữu dụng khi cần sửa chữa một chương trình có tất cả các phần khai báo được gộp lại với nhau. Bởi vậy, cách thông dụng nhất để khai báo biến là đặt nó trong phần bắt đầu của mỗi hàm (biến cục bộ) hay trực tiếp trong thân chương trình, ngoài tất cả các hàm (biến toàn cục).

Global variables (biến toàn cục) có thể được sử dụng ở bất kì đâu trong chương trình, ngay sau khi nó được khai báo.

Tầm hoạt động của local variables (biến cục bộ) bị giới hạn trong phần mã mà nó được khai báo. Nếu chúng được khai báo ở đầu một hàm (như hàm main), tầm hoạt động sẽ là toàn bộ hàm main. Điều đó có nghĩa là trong ví dụ trên, các biến được khai báo trong hàm main() chỉ có thể được dùng trong hàm đó, không được dùng ở bất kì đâu khác.

Thêm vào các biến toàn cục và cục bộ, còn có các biến ngoài (external). Các biến này không những được dùng trong một file mã nguồn mà còn trong tất cả các file được liên kết trong chương trình.

Trong C++ tầm hoạt động của một biến chính là khối lệnh mà nó được khai báo (một khối lệnh là một tập hợp các lệnh được gộp lại trong một bằng các ngoặc nhọn { } ). Nếu nó được khai báo trong một hàm tầm hoạt động sẽ là hàm đó, còn nếu được khai báo trong vòng lặp thì tầm hoạt động sẽ chỉ là vòng lặp đó....

Các hằng số

Một hằng số là bất kì một biểu thức nào mang một giá trị cố định, như:

Các số nguyên

1776
707
-273

chúng là các hằng mang giá trị số. Chú ý rằng khi biểu diễn một hằng kiểu số chúng ta không cần viết dấu ngoặc kép hay bất kì dấu hiệu nào khác.

Thêm vào những số ở hệ cơ số 10 ( cái mà tất cả chúng ta đều đã biết) C++ còn cho phép sử dụng các hằng số cơ số 8 và 16. Để biểu diễn một số hệ cơ số 8 chúng ta đặt trước nó kí tự 0, để biễu diễn số ở hệ cơ số 16 chúng ta đặt trước nó hai kí tự 0x. Ví dụ:

75 // Cơ số 10
0113 // cơ số 8
0x4b // cơ số 16

Các số thập phân (dạng dấu phẩy động)
Chúng biểu diễn các số với phần thập phân và/hoặc số mũ. Chúng có thể bao gồm phần thập phân, kí tự e (biểu diễn 10 mũ...).

3.14159 // 3.14159
6.02e23 // 6.02 x 1023
1.6e-19 // 1.6 x 10-19
3.0 // 3.0

Kí tự và xâu kí tự
Trong C++ còn tồn tại các hằng không phải kiểu số như:

'z'
'p'
"Hello world"
"How do you do?"

Hai biểu thức đầu tiên biểu diễn các kí tự đơn, các kí tự được đặt trong dấu nháy đơn ('), hai biểu thức tiếp theo biểu thức các xâu kí tự được đặt trong dấu nháy kép (").

Khi viết các kí tự đơn hay các xâu kí tự cần phải đặ chúng trong các dấu nháy để phân biệt với các tên biến hay các từ khoá. Chú ý:

x
'x'

x trỏ đến biến x trong khi 'x' là kí tự hằng 'x'.

Các kí tự đơn và các xâu kí tự có một tính chất riêng biệt là các mã điều khiển. Chúng là những kí tự đặc biệt mà không thể được viết ở bất kì đâu khác trong chương trình như là mã xuống dòng (\n) hay tab (\t). Tất cả đều bắt đầu bằng dấu xổ ngược (\). Sau đây là danh sách các mã điều khiển đó:

\n xuống dòng
\r lùi về đầu dòng
\t kí tự tab
\v căn thẳng theo chiều dọc
\b backspace
\f sang trang
\a Kêu bíp
\' dấu nháy đơn
\" dấu nháy kép
\ dấu hỏi
\\ kí tự xổ ngược

Ví dụ:

'\n'
'\t'
"Left \t Right"
"one\ntwo\nthree"

Thêm vào đó, để biểu diễn một mã ASCII bạn cần sử dụng kí tự xổ ngược (\) tiếp theo đó là mã ASCII viết trong hệ cơ số 8 hay cơ số 16. Trong trường hợp đầu mã ASCII được viết ngay sau dấu sổ ngược, trong trường hợp thứ hai, để sử dụng số trong hệ cơ số 16 bạn cần viết kí tự x trước số đó (ví dụ \x20 hay \x4A).

Các hằng chuỗi kí tự có thể được viết trên nhiều dòng nếu mỗi dòng được kết thúc bằng một dấu sổ ngược (\):

"string expressed in \
two lines"

Bạn có thể nối một vài hằng xâu kí tự ngăn cách bằng một hay vài dấu trống, kí tự tab, xuống dòng hay bất kì kí tự trống nào khác.

"we form" "a unique" "string" "of characters"

Định nghĩa các hằng (#define)

Bạn có thể định nghĩa các hằng với tên mà bạn muốn để có thể sử dụng thường xuyên mà không mất tài nguyên cho các biến bằng cách sử dụng chỉ thị #define. Đây là dạng của nó:

#define identifier value

Ví dụ:

#define PI 3.14159265
#define NEWLINE '\n'
#define WIDTH 100

chúng định nghĩa ba hằng số mới. Sau khi khai báo bạn có thể sử dụng chúng như bất kì các hằng số nào khác, ví dụ

circle = 2 * PI * r;
cout << NEWLINE;

Trong thực tế việc duy nhất mà trình dịch làm khi nó tìm thấy một chỉ thị #define là thay thế các tên hằng tại bất kì chỗ nào chúng xuất hiện (như trong ví dụ trước, PI, NEWLINE hay WIDTH) bằng giá trị mà chúng được định nghĩa. Vì vậy các hằng số #define được coi là các hằng số macro

Chỉ thị #define không phải là một lệnh thực thi, nó là chỉ thị tiền xử lý (preprocessor), đó là lý do trình dịch coi cả dòng là một chỉ thị và dòng đó không cần kết thúc bằng dấu chấm phẩy. Nếu bạn thêm dấu chấm phẩy vào cuối dòng, nó sẽ được coi là một phần của giá trị định nghĩa hằng.

Khai báo các hằng (const)

Với tiền tố const bạn có thể khai báo các hằng với một kiểu xác định như là bạn làm với một biến

const int width = 100;
const to char tab = '\t';
const zip = 12440;

Trong trường hợp kiểu không được chỉ rõ (như trong ví dụ cuối) trình dịch sẽ coi nó là kiểu int.

Ma Bư · 01-01-1970, 07:00 AM

Bài 1.3

Các toán tử

Qua bài trước chúng ta đã biết đến sự tồn tại của các biến và các hằng. Trong C++, để thao tác với chúng ta sử dụng các toán tử, đó là các từ khoá và các dấu không có trong bảng chữ cái nhưng lại có trên hầu hết các bàn phím trên thế giới. Hiểu biết về chúng là rất quan trọng vì đây là một trong những thành phần cơ bản của ngôn ngữ C++.

Toán tử gán (=).

Toán tử gán dùng để gán một giá trị nào đó cho một biến

a = 5;

gán giá trị nguyên 5 cho biến a. Vế trái bắt buộc phải là một biến còn vế phải có thể là bất kì hằng, biến hay kết quả của một biểu thức.

Cần phải nhấn mạnh rằng toán tử gán luôn được thực hiện từ trái sang phải và không bao giờ đảo ngược

a = b;

gán giá trị của biến a bằng giá trị đang chứa trong biến b. Chú ý rằng chúng ta chỉ gán giá trị của b cho a và sự thay đổi của b sau đó sẽ không ảnh hưởng đến giá trị của a.

Một thuộc tính của toán tử gán trong C++ góp phần giúp nó vượt lên các ngôn ngữ lập trình khác là việc cho phép vế phải có thể chứa các phép gán khác. 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
% 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

B=3;
A=++B;
// A is 4, B is 4

Ví dụ 2

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ố:

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

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.

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 1.4

Giao tiếp với console

Console là giao diện cơ bản của máy tính. Bàn phím là thiết bị vào cơ bản còn màn hình là thiết bị ra cơ bản.

Trong thư viện iostream của C++, các thao tác vào ra cơ bản của một chương trình được hỗ trợ bởi hai dòng dữ liệu : cin để nhập dữ liệu và cout để xuất. Thêm vào đó, còn có cerr và clog là hai dòng dữ liệu dùng để hiển thị các thông báo lỗi trên thiết bị ra chuẩn (thường là màn hình) hoặc ra một file. Thông thường cout được gán với màn hình còn cin được gán với bàn phím.

Sử dụng hai dòng dữ liệu này bạn sẽ có thể giao tiếp với người sử dụng vì bạn có thể hiển thị các thông báo lên màn hình cũng như nhận dữ liệu từ bàn phím.

Xuất dữ liệu (cout)

Dòng cout được sử dụng với toán tử đã quá tải << (overloaded - bạn sẽ hiểu rõ hơn về thuật ngữ này trong phần lập trình hướng đối tượng)

cout << "Output sentence"; // Hiển thị Output sentence lên màn hình
cout << 120; // Hiển thị số 120 lên màn hình
cout << x; // Hiển thị nội dung biến x lên màn hình

Toán tử << được gọi là toán tử chèn vì nó chèn dữ liệu đi sau nó vào dòng dữ liệu đứng trước. Trong ví dụ trên nó chèn chuỗi "Output sentence", hằng số 120 và biến x vào dòng dữ liệu ra cout.Chú ý rằng ở dòng đầu tiên chúng ta sử dụng dấu ngoặc kép vì đó là một chuỗi kí tự. Khi chúng ta muốn sử dụng các hằng xâu kí tự ta phải đặt chúng trong cặp dấu ngoặc kép để chúng có thể được phân biệt với các biến. Ví dụ, hai lệnh sau đây là hoàn toàn khác nhau:

cout << "Hello"; // Hiển thị Hello lên màn hình
cout << Hello; // Hiển thị nội dung của biến Hello lên màn hình

Toán tử chèn (<<) có thể được sử dụng nhiều lần trong một câu lệnh:

cout << "Hello, " << "I am " << "a C++ sentence";

Câu lệnh trên sẽ in thông báo Hello, I am a C++ sentence lên màn hình. Sự tiện lợi của việc sử dụng lặp lại toán tử chèn (<<) thể hiện rõ khi chúng ta muốn hiển thị nhiều biến và hằng hơn là chỉ một biến:

cout << "Hello, I am " << age << " years old and my email address is " << email_add;

Cần phải nhấn mạnh rằng cout không nhảy xuống dòng sau khi xuất dữ liệu, vì vậy hai câu lệnh sau :

cout << "This is a sentence.";
cout << "This is another sentence.";

sẽ được hiển thị trên màn hình:

This is a sentence.This is another sentence.

Bởi vậy khi muốn xuống dòng chúng ta phải sử dụng kí tự xuống dòng, trong C++ là \n:

cout << "First sentence.\n ";
cout << "Second sentence.\nThird sentence.";

sẽ viết ra màn hình như sau:

First sentence.
Second sentence.
Third sentence.

Thêm vào đó, để xuống dòng bạn có thể sử dụng tham số endl. Ví dụ

cout << "First sentence." << endl;
cout << "Second sentence." << endl;

sẽ in ra màn hình:

First sentence.
Second sentence.

Tham số endl có một tác dụng đặc biệt khi nó được dùng với các dòng dữ liệu sử dụng bộ đệm: các bộ đệm sẽ được flushed ( chuyển toàn bộ thông tin từ bộ đệm ra dòng dữ liệu). Tuy nhiên, theo mặc định cout không sử dụng bộ đệm.

Nhập dữ liệu (cin).

Thao tác vào chuẩn trong C++ được thực hiện bằng cách sử dụng toán tử đã quá tải >> với dòng cin. Theo sau toán tử này là biến sẽ lưu trữ dữ liệu được đọc vào. Ví dụ:

int age;
cin >> age;

khai báo biến age có kiểu int và đợi nhập dữ liệu từ cin (bàn phím) để lưu trữ nó trong biến kiểu nguyên này.

cin chỉ bắt đầu sử lý dữ liệu nhập từ bàn phím sau khi phím Enter được gõ. Vì vậy dù bạn chỉ nhập một kí tự thì cin vẫn sẽ kiên nhẫn chờ cho đến khi bạn gõ phím Enter.

Người sử dụng chương trình có thể là một trong những nguyên nhân gây ra lỗi trong một chương trình đơn giản sử dụng cin (như chương trình trên). Trong khi bạn muốn nhận một số nguyên thì người sử dụng lại nhập vào tên của họ (là một xâu kí tự). Kết quả là chương trình sẽ chạy sai vì đó không phải là những gì mà chương trình mong đợi từ người dùng. Bởi vậy khi bạn sử dụng dữ liệu nhập vào từ cin bạn phải tin chắc rằng người dùng sẽ hoàn toàn hợp tác và rằng anh ta sẽ không nhập tên của mình khi chương trình yêu cầu nhập số nguyên. Sau này, khi nghiên cứu việc sử dụng các xâu kí tự chúng ta sẽ xem xét các giải pháp khả thi để giải quyết các lỗi loại này.

Bạn có thể dùng cin để nhập một lúc nhiều dữ liệu từ người dùng:

cin >> a >> b;

tương đương với

cin >> a;
cin >> b;

Trong cả hai trường hợp người sử dụng phải cung cấp hai dữ liệu, một cho biến a và một cho biến b và được ngăn cách bởi một dấu trống hợp lệ: một dấu cách, dấu tab hay kí tự xuống dòng.

Trong trường hợp kiểu không được chỉ rõ (như trong ví dụ cuối) trình dịch sẽ coi nó là kiểu int.

2/ Các cấu trúc điều khiển và hàm

Bài 2.1

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 <iostream.h>
int main ()
{
int n;
cout << "Enter the starting number > ";
cin >> n;
while (n>0) {
cout << n << ", ";
--n;
}
cout << "FIRE!";
return 0;
}

Enter the starting number > 8
8, 7, 6, 5, 4, 3, 2, 1, FIRE!

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 <iostream.h>
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 <iostream.h>
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 <iostream.h>
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 <iostream.h>
int main ()
{
for (int n=10; n>0; n--) {
if (n==5) continue;
cout << n << ", ";
}
cout << "FIRE!";
return 0;
}

10, 9, 8, 7, 6, 4, 3, 2, 1, FIRE!

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 <iostream.h>
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ệ.
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.

Ma Bư · 01-01-1970, 07:00 AM

Bài 2.2

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 <iostream.h>
int addition (int a, int B)
{ int r; r=a+b; return �;}
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 �;

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 � 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 <iostream.h>
int subtraction (int a, int B)
{ int r; r=a-b; return �;}
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 <iostream.h>
void dummyfunction (void)
{ cout << "I'm a function!";}
int main (){ dummyfunction (); return 0;}

I'm a function!

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 ();

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.

Ma Bư · 01-01-1970, 07:33 AM

Bài 2.3

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 <iostream.h>
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 đó.

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 <iostream.h>
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 <iostream.h>
int divide (int a, int b=2){ int r; r=a/b; return �;}
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)

chúng ta chỉ dùng một tham số nhưng hàm divide cho phép đến hai. Bởi vậy hàm divide sẽ tự cho tham số thứ hai giá trị bằng 2 vì đó là giá trị mặc định của nó (chú ý phần khai báo hàm được kết thúc bởi int b=2). Vì vậy kết quả sẽ là 6 (12/2).

Trong lệnh thứ hai:

divide (20,4)

có hai tham số, bởi vậy giá trị mặc định sẽ được bỏ qua. Kết quả của hàm sẽ là 5 (20/4).

Quá tải các hàm.

Hai hàm có thể có cũng tên nếu khai báo tham số của chúng khác nhau, điều này có nghĩa là bạn có thể đặt cùng một tên cho nhiều hàm nếu chúng có số tham số khác nhau hay kiểu dữ liệu của các tham số khác nhau (hay thậm chí là kiểu dữ liệu trả về khác nhau). Ví dụ:

// overloaded function
#include <iostream.h>
int divide (int a, int B){ return (a/b);}
float divide (float a, float B){ return (a/b);}
int main (){ int x=5,y=2; float n=5.0,m=2.0; cout << divide (x,y); cout << "\n"; cout << divide (n,m); return 0;}

2
2.5

Trong ví dụ này chúng ta định nghĩa hai hàm có cùng tên nhưng một hàm dùng hai tham số kiểu int và hàm còn lại dùng kiểu float. Trình biên dịch sẽ biết cần phải gọi hàm nào bằng cách phân tích kiểu tham số khi hàm được gọi.

Để đơn giản tôi viết cả hai hàm đều có mã lệnh như nhau nhưng điều này không bắt buộc. Bạn có thể xây dựng hai hàm có cùng tên nhưng hoạt động hoàn toàn khác nhau.

Các hàm inline.

Chỉ thị inline có thể được đặt trước khao báo của một hàm để chỉ rõ rằng lời gọi hàm sẽ được thay thế bằng mã lệnh của hàm khi chương trình được dịch. Việc này tương đương với việc khai báo một macro, lợi ích của nó chỉ thể hiện với các hàm rất ngắn, tốc độ chạy chương trình sẽ được cải thiện vì nó không phải gọi một thủ tục con.

Cấu trúc của nó như sau:

inline type name ( arguments ... ) { instructions ... }
lời gọi hàm cũng như bất kì một hàm nào khác. Không cần thiết phải đặt từ khoá inline trong lệnh gọi, chỉ cần trong lời khai báo hàm là đủ.

Đệ qui.

Các hàm có thể gọi chính nó. Điều này có thể có ích với một số tác vụ như là một số phương pháp sắp xếp hay tính giai thừa của một số. Ví dụ, để tính giai thừa của một số (n), công thức toán học của nó như sau:

n! = n * (n-1) * (n-2) * (n-3) ... * 1

và một hàm đệ qui để tính toán sẽ như sau:

// factorial calculator
#include <iostream.h>
long factorial (long a){ if (a > 1) return (a * factorial (a-1)); else return (1);}
int main (){ long l; cout << "Type a number: "; cin >> l; cout << "!" << l << " = " << factorial (l); return 0;}

Type a number: 9
!9 = 362880

Chú ý trong hàm factorial chúng ta có thể lệnh gọi chính nó nhưng chỉ khi tham số lớn hơn 1, nếu không thì hàm sẽ thực hiện một vòng lặp vô hạn vì sau khi đến 0 nó sẽ tiếp tục nhân cả những số âm.

Hàm này có một hạn chế là kiểu dữ liệu mà nó dùng (long) không cho phép tính giai thừa quá 12!.

Khai báo mẫu cho hàm.

Cho đến giờ chúng ta hoàn toàn phải định nghĩa hàm trước lệnh gọi đầu tiên đến nó, mà thường là trong main, vì vậy hàm main luôn phải nằm cuối chương trình. Nếu bạn thử lặp lại một vài ví dụ về hàm trước đây nhưng thử đặt hàm main trước bất kì một hàm được gọi từ nó, bạn gần như chắc chắn sẽ nhận được thông báo lỗi. Nguyên nhân là một hàm phải được khai báo trước khi nó được gọi như nhưnggx gì chúng ta đã làm trng tất cả các ví dụ.

Nhưng có một cách khác để tránh phải viết tất cả mã chương trình trước khi chúng có thể được dùng trong main hay bất kì một hàm nào khác. Đó chính là khai báo mẫu cho hàm. Cách này bao gồm việc khai báo hàm một cách ngắn gọn nhưng đủ để cho trình dịch có thể biết các tham số và kiểu dữ liệu trả về của hàm.

Dạng của nó như sau:

type name ( argument_type1, argument_type2, ...);

Đây chính là phần đầu của định nghĩa hàm, ngoại trừ:

Nó không có bất kì lệnh nào cho hàm. Điều này có nghĩa là nó không bao gồm thân hàm với tất cả các lệnh thường được bọc trong cặp ngoặc nhọn { }.

Nó kết thúc bằng dấu chấm phẩy (; ).

Trong phần liệt kê các tham số chỉ cần viết kiểu của chúng là đủ. Việc viết tên của các tham số trong phần khai báo mẫu là không bắt buộc.

Ví dụ:

// prototyping
#include <iostream.h>
void odd (int a);void even (int a);
int main (){ int i;
do { cout << "Type a number: (0 to exit)"; cin >> i; odd (i); }
while (i!=0); return 0;}
void odd (int a){ if ((a%2)!=0) cout << "Number is odd.\n"; else even (a);} void even (int a){ if ((a%2)==0) cout << "Number is even.\n"; else odd (a);}

Type a number (0 to exit): 9
Number is odd.
Type a number (0 to exit): 6
Number is even.
Type a number (0 to exit): 1030
Number is even.
Type a number (0 to exit): 0
Number is even.

Ví dụ này rõ ràng không phải là một ví dụ về sự hiệu quả. Tôi chắc chắn rằng các bạn có thể nhận được kết quả như trên chỉ với một nửa số dòng lệnh. Tuy nhiên nó giúp cho chúng ta thấy được việc khai báo mẫu các hàm là như thế nào. Hơn nữa, trong ví dụ này việc khai báo mẫu ít nhất một hàm là bắt buộc.

Đầu tiên chúng ta thấy khai báo mẫu của hai hàm odd và even:

void odd (int a);
void even (int a);

cho phép hai hàm này có thể được sử dụng trước khi chúng được định nghĩa hoàn chỉnh. Tuy nhiên lý do đặc biệt giải thích tại sao chương trình này lại cần ít nhất một hàm phải được khi báo mẫu là trong odd có một lời gọi đến even và trong even có một lời gọi đến odd. Vì vậy nếu không có hàm nào được khai báo trước thì lỗi chắc chắn sẽ xẩy ra.

Rất nhiều lập trình viên kinh nghiệm khuyên rằng tất cả các hàm nên được khai báo mẫu. Đó cũng là lời khuyên của tôi, nhất là trong trường hợp có nhiều hàm hoặc chúng rất dài, khi đó việc khai báo tất cả các hàm ở cùng một chỗ cho phép chúng ta biết phải gọi các hàm như thế nào, vì vậy tiết kiệm được thời gian.

Ma Bư · 01-01-1970, 07:00 AM

3/ Dữ liệu nâng cao

Bài 3.1

Mảng

Mảng là một dãy các phần tử có cùng kiểu được đặt liên tiếp trong bộ nhớ và có thể truy xuất đến từng phần tử bằng cách thêm một chỉ số vào sau tên của mảng.

Điều này có nghĩa là, ví dụ, chúng ta có thể lưu 5 giá trị kiểu int mà không cần phải khai báo 5 biến khác nhau.Ví dụ, một mảng chứa 5 giá trị nguyên kiểu int có tên là billy có thể được biểu diễn như sau:

trong đó mỗi một ô trống biểu diễn một phần tử của mảng, trong trường hợp này là các giá trị nguyên kiểu int. Chúng được đánh số từ 0 đến 4 vì phần tử đầu tiên của mảng luôn là 0 bất kể độ dài của nó là bao nhiêu.

Như bất kì biến nào khác, một mảng phải được khai báo trước khi có thể sử dụng. Một khai báo điển hình cho một mảng trong C++ như sau:

type name [elements];

trong đó type là một kiểu dữ liệu hợp lệ (int, float...), name là một tên biến hợp lệ và trường elements chỉ định mảng đó sẽ chứa bao nhiêu phần tử

Vì vậy, để khai báo billy như đã trình bày ở trên chúng ta chỉ cần một dòng đơn giản như sau:

int billy [5];

Chú ý: Trường elements bên trong cặp ngoặc [] phải là một giá trị hằng khi khai báo một mảng, vì mảng là một khối nhớ tĩnh có kích cỡ xác định và trình biên dịch phải có khả năng xác định xem cần bao nhiêu bộ nhớ để cấp phát cho mảng trước khi các lệnh có thể được thực hiện.

Khởi tạo một mảng.

Khi khai báo một mảng với tầm hoạt động địa phương (trong một hàm), theo mặc định nó sẽ không được khởi tạo, vì vậy nội dung của nó là không xác định cho đến khi chúng ra lưu các giá trị lên đó.

Nếu chúng ta khai báo một mảng toàn cục (bên ngoài tất cả các hàm) nó sẽ được khởi tạo và tất cả các phần tử được đặt bằng 0. Vì vậy nếu chúng ta khai báo mảng toàn cục:

int billy [5];

mọi phần tử của billy sẽ được khởi tạo là 0:

Nhưng thêm vào đó, khi chúng ta khai báo một mảng, chúng ta có thể gán các giá trị khởi tạo cho từng phần tử của nó. Ví dụ:

int billy [5] = { 16, 2, 77, 40, 12071 };

lệnh trên sẽ khai báo một mảng như sau:

Số phần tử trong mảng mà chúng ta khởi tạo với cặp ngoặc nhọn { } phải bằng số phần tử của mảng đã được khai báo với cặp ngoặc vuông [ ]. Bởi vì điều này có thể được coi là một sự lặp lại không cần thiết nên C++ cho phép để trống giữa cặp ngoặc vuông, kích thước của mảng được xác định bằng số giá trị giữa cặp ngoặc nhọn.

Truy xuất đến các phần tử của mảng.

Ở bất kì điểm nào của chương trình trong tầm hoạt động của mảng, chúng ta có thể truy xuất từng phần tử của mảng để đọc hay chỉnh sửa như là đối với một biến bình thường. Cấu trúc của nó như sau:

name[index]

Như ở trong ví dụ trước ta có mảng billy gồm 5 phần tử có kiểu int, chúng ta có thể truy xuất đến từng phần tử của mảng như sau:

Ví dụ, để lưu giá trị 75 vào phần tử thứ ba của billy ta viết như sau:

billy[2] = 75;

và, ví dụ, để gán giá trị của phần tử thứ 3 của billy cho biến a, chúng ta viết:

a = billy[2];

Vì vậy, xét về mọi phương diện, biểu thức billy[2] giống như bất kì một biến kiểu int.

Chú ý rằng phần tử thứ ba của billy là billy[2], vì mảng bắt đầu từ chỉ số 0. Vì vậy, phần tử cuối cùng sẽ là billy[4]. Vì vậy nếu chúng ta viết billy[5], chúng ta sẽ truy xuất đến phần tử thứ 6 của mảng và vượt quá giới hạn của mảng.

Trong C++, việc vượt quá giới hạn chỉ số của mảng là hoàn toàn hợp lệ, tuy nhiên nó có thể gây ra những vấn đề thực sự khó phát hiện bởi vì chúng không tạo ra những lỗi trong quá trình dịch nhưng chúng có thể tạo ra những kết quả không mong muốn trong quá trình thực hiện. Nguyên nhân của việc này sẽ được nói đến kĩ hơn khi chúng ta bắt đầu sử dụng con trỏ.

Cần phải nhấn mạnh rằng chúng ta sử dụng cặp ngoặc vuông cho hai tác vụ: đầu tiên là đặt kích thước cho mảng khi khai báo chúng và thứ hai, để chỉ định chỉ số cho một phần tử cụ thể của mảng khi xem xét đến nó.

int billy[5]; // khai báo một mảng mới.
billy[2] = 75; // truy xuất đến một phần tử của mảng.

Một vài thao tác hợp lệ khác với mảng:

billy[0] = a;
billy[a] = 75;
b = billy [a+2];
billy[billy[a]] = billy[2] + 5;

// ví dụ về mảng
#include <iostream.h>

int billy [] = {16, 2, 77, 40, 12071};
int n, result=0;

int main ()
{
for ( n=0 ; n<5 ; n++ )
{
result += billy[n];
}
cout << result;
return 0;
}

12206

Mảng nhiều chiều.

Mảng nhiều chiều có thể được coi như mảng của mảng, ví dụ, một mảng hai chiều có thể được tưởng tược như là một bảng hai chiều gồm các phần tử có kiểu dữ liệu cụ thể và giống nhau

jimmy biểu diễn một mảng hai chiều kích thước 3x5 có kiểu int. Cách khai báo mảng này như sau:

int jimmy [3][5];

và, ví dụ, cách để truy xuất đến phần tử thứ hai theo chiều dọc và thứ tư theo chiều ngang trong một biểu thức như sau:
jimmy[1][3]

(hãy nhớ rằng chỉ số của mảng luôn bắt đầu từ 0).

Mảng nhiều chiều không bị giới hạn bởi hai chỉ số (hai chiều), Chúng có thể chứa bao nhiều chỉ số tùy thích mặc dù ít khí cần phải dùng đến mảng lớn hơn 3 chiều. Hãy thử xem xét lượng bộ nhớ mà một mảng có nhiều chỉ số cần đến. Ví dụ:

char century [100][365][24][60][60];

gán một giá trị char cho mỗi giây trong một thế kỉ, phải cần đến hơn 3 tỷ giá trị chars! Chúng ta sẽ phải cần khoảng 3GB RAM để khai báo nó.

Mảng nhiều chiều thực ra là một khái niệm trừu tượng vì chúng ta có thể có kết quả tương tự với mảng một chiều bằng một thao tác đơn giản giữa các chỉ số của nó:

int jimmy [3][5]; tương đương với
int jimmy [15]; (3 * 5 = 15)

Dưới đây là hai ví dụ với cùng một kết quả như nhau, một sử dụng mảng hai chiều và một sử dụng mảng một chiều:

// multidimensional array
#include <iostream.h>

#define WIDTH 5
#define HEIGHT 3

int jimmy [HEIGHT][WIDTH];
int n,m;

int main ()
{
for (n=0;n<HEIGHT;n++)
for (m=0;m<WIDTH;m++)
{
jimmy[n][m]=(n+1)*(m+1);
}
return 0;
}

// pseudo-multidimensional array
#include <iostream.h>

#define WIDTH 5
#define HEIGHT 3

int jimmy [HEIGHT * WIDTH];
int n,m;

int main ()
{
for (n=0;n<HEIGHT;n++)
for (m=0;m<WIDTH;m++)
{
jimmy[n * WIDTH + m]=(n+1)*(m+1);
}
return 0;
}

không một chương trình nào viết gì ra màn hình nhưng cả hai đều gán giá trị vào khối nhớ có tên jimmy theo cách sau:

Chúng ta đã định nghĩa hằng (#define) để đơn giản hóa những chỉnh sửa sau này của chương trình, ví dụ, trong trường hợp chúng ta quyết định tăng kích thước của mảng với chiều cao là 4 thay vì là 3, chúng ta chỉ cần thay đổi dòng:

#define HEIGHT 3

thành

#define HEIGHT 4

và không phải có thêm sự thay đổi nào nữa đối với chương trình.

Dùng mảng làm tham số.

Vào một lúc nào đó có thể chúng ta cần phải truyền một mảng tới một hàm như là một tham số. Trong C++, việc truyền theo tham số giá trị một khối nhớ là không hợp lệ, ngay cả khi nó được tổ chức thành một mảng. Tuy nhiên chúng ta lại được phép truyền địa chỉ của nó, việc này cũng tạo ra kết quả thực tế giống thao tác ở trên nhưng lại nhanh hơn nhiều và hiệu quả hơn.

Để có thể nhận mảng là tham số thì điều duy nhất chúng ta phải làm khi khai báo hàm là chỉ định trong phần tham số kiểu dữ liệu cơ bản của mảng, tên mảng và cặp ngoặc vuông trống. Ví dụ, hàm sau:

void procedure (int arg[])

nhận vào một tham số có kiểu "mảng của char" và có tên arg. Để truyền tham số cho hàm này một mảng được khai báo:

int myarray [40];

chỉ cần gọi hàm như sau:

procedure (myarray);

Dưới đây là một ví dụ cụ thể

// arrays as parameters
#include <iostream.h>

void printarray (int arg[], int length) {
for (int n=0; n<length; n++)
cout << arg[n] << " ";
cout << "\n";
}

int main ()
{
int firstarray[] = {5, 10, 15};
int secondarray[] = {2, 4, 6, 8, 10};
printarray (firstarray,3);
printarray (secondarray,5);
return 0;
}

5 10 15
2 4 6 8 10

Như bạn có thể thấy, tham số đầu tiên (int arg[]) chấp nhận mọi mảng có kiểu cơ bản là int, bất kể độ dài của nó là bao nhiêu, vì vậy cần thiết phải có tham số thứ hai để báo cho hàm này biết độ dài của mảng mà chúng ta truyền cho nó.

Trong phần khai báo hàm chúng ta cũng có thể dùng tham số là các mảng nhiều chiều. Cấu trúc của mảng 3 chiều như sau:

base_type[][depth][depth]

ví dụ, một hàm với tham số là mảng nhiều chiều có thể như sau:

void procedure (int myarray[][3][4])

chú ý rằng cặp ngoặc vuông đầu tiên để trống nhưng các cặp ngoặc sau thì không. Bạn luôn luôn phải làm vậy vì trình biên dịch C++ phải có khả năng xác định độ lớn của các chiều thêm vào của mảng.

Mảng, cả một chiều và nhiều chiều, khi truyền cho hàm như là một tham số thường là nguyên nhân gây lỗi cho những lập trình viên thiếu kinh nghiệm. Các bạn nên đọc bài 3.3. Con trỏ để có thể hiểu rõ hơn mảng hoạt động như thế nào.

Ma Bư · 01-01-1970, 07:33 AM

Bài 3.2

Xâu kí tự

Trong tất cả các chương trình chúng ta đã thấy cho đến giờ, chúng ta chỉ sử dụng các biến kiểu số, chỉ dùng để biểu diễn các số. Nhưng bên cạnh các biến kiểu số còn có các xâu kí tự, chúng cho phép chúng ta biểu diễn các chuỗi kí tự như là các từ, câu, đoạn văn bản... Cho đến giờ chúng ta mới chỉ dùng chúng dưới dạng hằng chứ chứa quan tâm đến các biến có thể chứa chúng.

Trong C++ không có kiểu dữ liệu cơ bản để lưu các xâu kí tự. Để có thể thỏa mãn nhu cầu này, người ta sử dụng mảng có kiểu char. Hãy nhớ rằng kiểu dữ liệu này (char) chỉ có thể lưu trữ một kí tự đơn, bởi vậy nó được dùng để tạo ra xâu của các kí tự đơn.

Ví dụ, mảng sau (hay là xâu kí tự):

char jenny [20];

có thể lưu một xâu kí tự với độ dài cực đại là 20 kí tự. Bạn có thể tưởng tượng nó như sau:

Kích thước cực đại này không cần phải luôn luôn dùng đến. Ví dụ, jenny có thể lưu xâu "Hello" hay "Merry christmas". Vì các mảng kí tự có thể lưu các xâu kí tự ngắn hơn độ dài của nó, trong C++ đã có một quy ước để kết thúc một nội dung của một xâu kí tự bằng một kí tự null, có thể được viết là '\0'.

Chúng ta có thể biểu diễn jenny (một mảng có 20 phần tử kiểu char) khi lưu trữ xâu kí tự "Hello" và "Merry Christmas" theo cách sau:

Chú ý rằng sau nội dung của xâu, một kí tự null ('\0') được dùng để báo hiệu kết thúc xâu. Những ô màu xám biểu diễn những giá trị không xác định.

Khởi tạo các xâu kí tự.

Vì những xâu kí tự là những mảng bình thường nên chúng cũng như các mảng khác. Ví dụ, nếu chúng ta muốn khởi tạo một xâu kí tự với những giá trị xác định chúng ta có thể làm điều đó tương tự như với các mảng khác:

char mystring[] = { 'H', 'e', 'l', 'l', 'o', '\0' };

Tuy nhiên, chúng ta có thể khởi tạo giá trị cho một xâu kí tự bằng cách khác: sử dụng các hằng xâu kí tự.

Trong các biểu thức chúng ta đã sử dụng trong các ví dụ trong các chương trước các hằng xâu kí tự để xuất hiện vài lần. Chúng được biểu diễn trong cặp ngoặc kép ("), ví dụ:

"the result is: "
là một hằng xâu kí tự chúng ta sử dụng ở một số chỗ.

Không giống như dấu nháy đơn (') cho phép biểu diễn hằng kí tự, cặp ngoặc kép (") là hằng biểu diễn một chuỗi kí tự liên tiếp, và ở cuối chuỗi một kí tự null ('\0') luôn được tự động thêm vào.

Vì vậy chúng ta có thể khởi tạo xâu mystring theo một trong hai cách sau đây:

char mystring [] = { 'H', 'e', 'l', 'l', 'o', '\0' };
char mystring [] = "Hello";

Trong cả hai trường hợp mảng (hay xâu kí tự) mystring được khai báo với kích thước 6 kí tự: 5 kí tự biểu diễn Hello cộng với một kí tự null.

Trước khi tiếp tục, tôi cần phải nhắc nhở bạn rằng việc gán nhiều hằng như việc sử dụng dấu ngoặc kép (") chỉ hợp lệ khi khởi tạo mảng, tức là lúc khai báo mảng. Các biểu thức trong chương trình như:

mystring = "Hello";
mystring[] = "Hello";

là không hợp lệ, cả câu lệnh dưới đây cũng vậy:

mystring = { 'H', 'e', 'l', 'l', 'o', '\0' };

Vậy hãy nhớ: Chúng ta chỉ có thể "gán" nhiều hằng cho một mảng vào lúc khởi tạo nó. Nguyên nhân là một thao tác gán (=) không thể nhận vế trái là cả một mảng mà chỉ có thể nhận một trong những phần tử của nó. Vào thời điểm khởi tạo mảng là một trường hợp đặc biệt, vì nó không thực sự là một lệnh gán mặc dù nó sử dụng dấu bằng (=).

Gán giá trị cho xâu kí tự
Vì vế trái của một lệnh gán chỉ có thể là một phần tử của mảng chứ không thể là cả mảng, chúng ta có thể gán một xâu kí tự cho một mảng kiểu char sử dụng một phương pháp như sau:

mystring[0] = 'H';
mystring[1] = 'e';
mystring[2] = 'l';
mystring[3] = 'l';
mystring[4] = 'o';
mystring[5] = '\0';

Nhưng rõ ràng đây không phải là một phương pháp thực tế. Để gán giá trị cho một xâu kí tự, chúng ta có thể sử dụng loạt hàm kiểu strcpy (string copy), hàm này được định nghĩa trong string.h và có thể được gọi như sau:

strcpy (string1, string2);

Lệnh này copy nội dung của string2 sang string1. string2 có thể là một mảng, con trỏ hay một hằng xâu kí tự, bởi vậy lệnh sau đây là một cách đúng để gán xâu hằng "Hello" cho mystring:

strcpy (mystring, "Hello");

Ví dụ:

// setting value to string#include <iostream.h>#include <string.h>int main (){ char szMyName [20]; strcpy (szMyName,"J. Soulie"); cout << szMyName; return 0;}

J. Soulie

Để ý rằng chúng ta phải include file <string.h> để có thể sử dụng hàm strcpy.

Mặc dù chúng ta luôn có thể viết một hàm đơn giản như hàm setstring dưới đây để thực hiện một thao tác giống như strcpy:

// setting value to string
#include <iostream.h>
void setstring (char szOut [], char szIn [])
{ int n=0; do { szOut[n] = szIn[n]; n++; } while (szIn[n] != 0);}int main (){ char szMyName [20]; setstring (szMyName,"J. Soulie"); cout << szMyName; return 0;}

J. Soulie

Một phương thức thường dùng khác để gán giá trị cho một mảng là sử dụng trực tiếp dòng nhập dữ liệu (cin). Trong trường hợp này giá trị của xâu kí tự được gán bởi người dùng trong quá trình chương trình thực hiện.

Khi cin được sử dụng với các xâu kí tự nó thường được dùng với phương thức getline của nó, phương thức này có thể được gọi như sau:

cin.getline ( char buffer[], int length, char delimiter = ' \n');

trong đó buffer (bộ đệm) là địa chỉ nơi sẽ lưu trữ dữ liệu vào (như là một mảng chẳng hạn), length là độ dài cực đại của bộ đệm (kích thước của mảng) và delimiter là kí tự được dùng để kết thúc việc nhập, mặc định - nếu chúng ta không dùng tham số này - sẽ là kí tự xuống dòng ('\n').

Ví dụ sau đây lặp lại tất cả những gì bạn gõ trên bàn phím. Nó rất đơn giản nhưng là một ví dụ cho thấy bạn có thể sử dụng cin.getline với các xâu kí tự như thế nào:

// cin with strings
#include <iostream.h>
int main (){ char mybuffer [100]; cout << "What's your name? "; cin.getline (mybuffer,100); cout << "Hello " << mybuffer << ".\n"; cout << "Which is your favourite team? "; cin.getline (mybuffer,100); cout << "I like " << mybuffer << " too.\n"; return 0;}

What's your name? Juan
Hello Juan.
Which is your favourite team? Inter Milan
I like Inter Milan too.

Chú ý trong cả hai lời gọi cin.getline chúng ta sử dụng cùng một biến xâu (mybuffer). Những gì chương trình làm trong lời gọi thứ hai đơn giản là thay thế nội dung của buffer trong lời gọi cũ bằng nội dung mới.

Nếu bạn còn nhớ phần nói về giao tiếp với, bạn sẽ nhớ rằng chúng ta đã sử dụng toán tử >> để nhận dữ liệu trực tiếp từ đầu vào chuẩn. Phương thức này có thể được dùng với các xâu kí tự thay cho cin.getline. Ví dụ, trong chươn trình của chúng ta, khi chúng ta muốn nhận dữ liệu từ người dùng chúng ta có thể viết:

cin >> mybuffer;

lệnh này sẽ làm việc như nó có những hạn chế sau mà cin.getline không có:

Nó chỉ có thể nhận những từ đơn (không nhận được cả câu) vì phương thức này sử dụng kí tự trống(bao gồm cả dấu cách, dấu tab và dấu xuống dòng) làm dấu hiệu kết thúc..

Nó không cho phép chỉ định kích thước cho bộ đệm. Chương trình của bạn có thể chạy không ổn định nếu dữ liệu vào lớn hơn kích cỡ của mảng chứa nó.
Vì những nguyên nhân trên, khi muốn nhập vào các xâu kí tự bạn nên sử dụng cin.getline thay vì cin >>.

Chuyển đổi xâu kí tự sang các kiểu khác.
Vì một xâu kí tự có thể biểu diễn nhiều kiểu dữ liệu khác như dạng số nên việc chuyển đổi nội dung như vậy sang dạng số là rất hữu ích. Ví dụ, một xâu có thể mang giá trị "1977"nhưng đó là một chuỗi gồm 5 kí tự (kể cả kí tự null) và không dễ gì chuyển thành một số nguyên. Vì vậy thư viện cstdlib (stdlib.h) đã cung cấp 3 macro/hàm hữu ích sau:

atoi: chuyển xâu thành kiểu int.

atol: chuyển xâu thành kiểu long.

atof: chuyển xâu thành kiểu float.
Tất cả các hàm này nhận một tham số và trả về giá trị số (int, long hoặc float). Các hàm này khi kết hợp với phương thức getline của cin là một cách đáng tin cậy hơn phương thức cin>> cổ điển khi yêu cầu người sử dụng nhập vào một số:

// cin and ato* functions#include <iostream.h>#include <stdlib.h>int main (){ char mybuffer [100]; float price; int quantity; cout << "Enter price: "; cin.getline (mybuffer,100); price = atof (mybuffer); cout << "Enter quantity: "; cin.getline (mybuffer,100); quantity = atoi (mybuffer); cout << "Total price: " << price*quantity; return 0;}

Enter price: 2.75
Enter quantity: 21
Total price: 57.75

Các hàm để thao tác trên chuỗi
Thư viện cstring (string.h) không chỉ có hàm strcpy mà còn có nhiều hàm khác để thao tác trên chuỗi. Dưới đây là giới thiệu lướt qua của các hàm thông dụng nhất:

strcat: char* strcat (char* dest, const char* src);

Gắn thêm chuỗi src vào phía cuối của dest. Trả về dest.

strcmp: int strcmp (const char* string1, const char* string2);

So sánh hai xâu string1 và string2. Trả về 0 nếu hai xâu là bằng nhau.

strcpy: char* strcpy (char* dest, const char* src);

Copy nội dung của src cho dest. Trả về dest.

strlen: size_t strlen (const char* string);

Trả về độ dài của string.

Chú ý: char* hoàn toàn tương đương với char[]

Sibinh97A105 · 03-11-2007, 07:21 PM

Hê Ma Bư, sao tự dưng tới đây là dừng rùi, tiếp đi chứ, chưa thấy nói gì vế MFC hết vậy. Cậu có cuốn ebook nào hay về thuật toán và độ phức tạp của thuật toán hông? Share cho anh em tham khảo dzới

fantomas_la · 03-12-2008, 10:32 PM

Trích:

Nguyên văn bởi Sibinh97A105

Hê Ma Bư, sao tự dưng tới đây là dừng rùi, tiếp đi chứ, chưa thấy nói gì vế MFC hết vậy. Cậu có cuốn ebook nào hay về thuật toán và độ phức tạp của thuật toán hông? Share cho anh em tham khảo dzới

MFC thì bao la lắm. Biết đâu mà lần.

Hy vọng sẽ được giao lưu, học hỏi nhiều hơn về C++ programming (Cả một nghệ thuật luôn đó)
@Ma Bư: rất cám ơn lòng nhiệt tình pót bài của bạn nhé. Tiếp tục phát huy nha bạn.

fantomas_la · 03-12-2008, 10:38 PM

Còn về tải liệu MFC, mọi người có thể tham khảo cuốn này.
Advanced MFC.
[Đăng nhập để xem liên kết. ]