Đọc truyện LT C,C++

LT C,C++

Trước Sau

Màu nền

Font chữ

Font size

Chiều cao dòng

----------------------- Page 1-----------------------

NGÔN NG LP TRÌNH

C/C++

Nguyễn Đình Thuân

Khoa Công Nghệ Thông Tin

Đại học Nha Trang

Nha Trang, 7-2007

----------------------- Page 2-----------------------

Nội dung môn học

Chương 1: Tổng quan

Chương 2: Các toán tử

Chương 3: Các cấu trúc điều khiển

Chương 4: Dữ liệu có cấu trúc

Chương 5: Các hàm trong C

Chương 6: Các cấu trúc dữ liệu khác

Chương 7: Đồ họa trong C

----------------------- Page 3-----------------------

Chương 1: Tổng quan

1.1 Giới thiệu

– Đã có nhiều sách trên thế giới viết về C/C++ và hầu

hết là ca ngợi, nhất là các lập trình viên luôn xem

C/C++ là công cụ mạnh và uyển chuyển.

– C là kết quả của quá trình phát triển khởi đầu từ ngôn

ngữ BCPL (do Martin Richards đưa ra vào năm 1967)

là sản phẩm của dự án Combine Programming

Language giữa 2 trường Đại học London và

Cambridge. Ngôn ngữ B (do Ken Thompson phát triển

từ ngôn ngữ BCPL vào năm 1970 khi viết hệ điều

hành UNIX đầu tiên trên máy PDP-7) và ngôn ngữ B

3 là tiền thân của ngôn ngữ C.

----------------------- Page 4-----------------------

1.1 Giới thiệu (tiếp)

– Năm 1978, hai tác giả Brian Kernighan và Dennish

Ritchie và đã cho xuất bản quyển The C Programming

Language (Prentice-Hall) và được phổ biến rộng rãi

đến nay. Vì vậy ngôn ngữ C thường được gán cho

“Tiêu chuẩn K&R”.

– Hiện nay có gần 30 trình biên d ch C đang phổ biến

trên th trường và chúng không nhất quán nhau. Để

cải thiện tình trạng này, chuẩn ANSI C cũng được ra

đời vào năm 1978, nhằm chăm lo việc phát triển các

môi trường và các hàm thư viện của C.

----------------------- Page 5-----------------------

Các đặc điểm của ngôn ngữ C:

o Tính cô đọng (compact): C chỉ có 32 từ khóa chuẩn và 40 toán tử chuẩn,

nhưng hầu hết đều được biểu diễn bằng những chuỗi ký tự ngắn gọn.

o Tính cấu trúc (structured): C có một tập hợp những chỉ th của lập trình

như cấu trúc lựa chọn, lặp… Từ đó các chương trình viết bằng C được

tổ chức rõ ràng, dễ hiểu.

o Tính tương thích (compatible): C có bộ tiền xử lý và một thư viện chuẩn vô

cùng phong phú nên khi chuyển từ máy tính này sang máy tính khác các

chương trình viết bằng C vẫn hoàn toàn tương thích.

o Tính linh động (flexible): C là một ngôn ngữ rất uyển chuyển và cú pháp,

chấp nhận nhiều cách thể hiện, có thể thu gọn kích thước của các mã

lệnh làm chương trình chạy nhanh hơn.

o Biên d ch (compile): C cho phép biên d ch nhiều tập tin chương trình riêng

rẽ thành các tập tin đối tượng (object) và liên kết (link) các đối tượng đó

lại với nhau thành một chương trình có thể thực thi được (executable)

thống nhất.

----------------------- Page 6-----------------------

1.2 Môi trường làm việc Turbo C

1. Gọi Turbo C

2. Soạn thảo chương trình mới

3. Ghi chương trình đang soạn thảo vào đĩa

4. Thực hiện chương trình

5. Mở một chương trình đã có trên đĩa

6. Thoát khỏi Turbo C và trở về DOS (hay Windows)

7. Sử dụng một số lệnh trên thanh menu

----------------------- Page 7-----------------------

1.3 Các thành phần trong chương trình C

- Bộ ký tự

- Các từ khoá trong C

- Lời chú thích đặt trong cặp dấu /* và */

hoặc sau //

----------------------- Page 8-----------------------

Ví dụ 1:

Thư viện nhập xuất chuẩn

Ghi chú Thư viện nhập xuất chuẩn

Ghi chú

/*VIDU.CPP*/

#include <stdio.h>

int main()

{{

printf(“Day la vi du

");

printf(“Day la vi du

");

Hàm main printf(“don gian Lap trinh C

");

Hàm main printf(“don gian Lap trinh C

");

return 0;

}}

Báo CT kết thúc cho HĐH

----------------------- Page 9-----------------------

Ví dụ 2

#include <stdio.h>

Khai báo 2 biến số #include <stdio.h>

#include <conio.h>

nguyên, “a” và “b” #include <conio.h>

int main(void)

{{

int a, b;

Nhập 2 số nguyên int a, b;

printf(“Nhap 2 so ngguyen: ");

vào a và b printf(“Nhap 2 so ngguyen: ");

scanf("%d %d", &a, &b);

printf("%d - %d = %d

", a, b, a - b);

printf("%d - %d = %d

", a, b, a - b);

getch();

Viết các biểu thức “a”, return 0;

return 0;

“b” và “a-b” theo định }}

dạng %d

Nhap 2 so nguyen: 21 17

21 - 17 = 4

----------------------- Page 10-----------------------

Ghi chú:

Phần chú thích được trình biên d ch bỏ qua

Các từ có phân biệt chữ hoa và chữ thường

Câu lệnh luôn được kết thúc bằng dấu ;

Chuỗi ký tự phải ghi giữa cặp nháy kép “

In xuống dòng dùng ký tự

Chương trình C gồm 1 hoặc nhiều hàm, hàm

được gọi thực hiện đầu tiên là hàm main.

----------------------- Page 11-----------------------

1.4 Các bước cơ bản khi viết

chương trình

1. Phân tích, đặc tả bài toán

2. Tìm lời giải (thuật toán) và kiểu dữ liệu.

3. Viết chương trình bằng ngôn ngữ lập trình

4. Chạy thử sửa lỗi.

5. Tổng kết chương trình

----------------------- Page 12-----------------------

1.5 Các kiểu dữ liệu cơ bản

trong C

Kiểu Từ khóa Kích thước

Ký tự char 1 byte

Số nguyên int 2 bytes

Số thực float 4 bytes

Số thực chính double 8 bytes

xác kép

Không giá tr void

----------------------- Page 13-----------------------

Kiểu logic trong C

Trong C không có kiểu dữ liệu logic

(nhận các giá tr ĐÚNG – SAI), thay vào

đó các biểu thức so sánh sẽ cho kết quả

là SỐ

Biểuthức có giá tr 0 (0.0) ứng với kết

quả SAI (FALSE)

Biểu thức có giá tr khác không như : 1,

3.5, -7, 10.4, … đều được xem là ĐÚNG

(TRUE)

----------------------- Page 14-----------------------

1.5 Các kiểu dữ liệu cơ bản (tiếp)

Bộ chuyển kiểu (modifiers)

signed (có du)

unsigned (không du)

short (số nguyên ngắn)

long (s nguyên dài gp ôi)

----------------------- Page 15-----------------------

DataType

Type Length Range

unsigned char 8 bits 0 to 255

char 8 bits -128 to 127

enum 16 bits -32,768 to 32,767

unsigned int 16 bits 0 to 65,535

short int 16 bits -32,768 to 32,767

int 16 bits -32,768 to 32,767

unsigned long 32 bits 0 to 4,294,967,295

long 32 bits -2,147,483,648 to 2,147,483,647

float 32 bits 3.4 * (10**-38) to 3.4 * (10**+38)

double 64 bits 1.7 * (10**-308) to 1.7 * (10**+308)

long double 80 bits 3.4 * (10**-4932) to 1.1 * (10**+4932)

----------------------- Page 16-----------------------

1.6 Khai báo trong C

- Tất cả các yếu tố trong chương trình do người lập trình

đặt ra phải được khai báo trước khi sử dụng, khai báo

trước hết phải đặt tên cho yếu tố đó.

- Tên hay còn gọi là danh hiệu(identifier) dùng để đặt cho

biến, hằng, kiểu, hàm, ... Tên được đặt theo qui đ nh:

Gồm chữ cái, chữ số, dấu gạch chân.

Không bắt đầu bằng chữ số

Không trùng với từ khóa.

– Tên chuẩn là một số tên do C đặt sẵn như: sin, cos...

– Độ dài tối đa của tên là không giới hạn, tuy nhiên chỉ

có 31 ký tự đầu tiên là có ý nghĩa.

----------------------- Page 17-----------------------

1. Khai báo biến

Khai báo:

<kiểu> <tên biến>;

Biến là đại lượng được người lập trình đ nh

nghĩa và được đặt tên thông qua việc khai báo

biến. Biến dùng để chứa dữ liệu trong quá

trình thực hiện chương trình và giá tr của biến

có thể thay đổi trong quá trình này.

Mỗi biến thuộc về một kiểu dữ liệu xác đ nh và

có giá tr thuộc kiểu đó.

----------------------- Page 18-----------------------

1. Khai báo biến (tiếp)

Ví dụ:

int a, b, c; /*Ba biến a, b,c có kiểu int*/

long int chu_vi; /*Biến chu_vi có kiểu long*/

float nua_chu_vi; /*Biến nua_chu_vi có kiểu float*/

double dien_tich; /*Biến dien_tich có kiểu double*/

a) Khai báo biến ngoài (biến toàn cục): Các biến được đặt

bên ngoài tất cả các hàm(kể cả hàm main) và phạm vi

sử dụng trong toàn bộ chương trình.

b) Khai báo biến trong(biến cục bộ): Các biến được đặt ở

bên trong hàm hay khối lệnh. Các biến này chỉ có tác

dụng trong hàm hoặc khối lệnh tương ứng

----------------------- Page 19-----------------------

1. Khai báo biến (tiếp)

Ví dụ 1:

#include <stdio.h>

#include<conio.h>

int a; //khai bao bien ngoai

int main ()

{

int I,j; //khai bao bien ben trong hàm main

clrscr();

i=1; j=2;

a=3;

printf("

Gia tri cua i la %d",i);

printf("

Gia tri cua j la %d",j);

printf("

Gia tri cua bienngoai a la %d",a);

getch();

return 0;

}

----------------------- Page 20-----------------------

2. Khai báo hằng

Khai báo const [kiểu] <tên hằng> = <giá tr >;

Hoặc được khai báo thông qua gán giá tr đầu

Hằng (Constant) là đại lượng không đổi trong quá trình thực thi

của chương trình.

Hằng bao gồm hằng số nguyên, hằng số thực, hằng ký tự, hằng

chuỗi ký tự.

a) Hằng số:

Hằng số nguyên: 10, -167

Hằng số thực: 1.234, -0.34E3

- Ngầm đ nh, trình biên d ch ghép hằng vào kiểu dữ liệu tương ứng

nhỏ nhất

Ví dụ: hằng số 10 có kiểu int

hằng số 60000 có kiểu unsigned

hằng số 100000 có kiểu long

- C qui ước các hằng số thực có kiểu double

----------------------- Page 21-----------------------

2. Khai báo hằng (tiếp)

- Trường hợp muốn chỉ rõ kiểu của hằng, dùng tiếp vĩ

ngữ(suffix): U(unsigned), L (long), F(float)

- Ví dụ:

- 1,123,31000,-234 có kiểu int

- -34L, 20000L có kiểu long

- 34U, 40000 có kiểu unsigned

- 23.45F, 34,4-3F có kiểu float

- 12.23, 4522,78 có kiểu double

- Hằng bắt đầu 0X là hằng thuộc hệ cơ số 16

- Hằng bắt đầu 0 là hằng thuộc hệ cơ số 8

- Ví dụ:

- int i=0x20, j=20, k=020; // i=32 và k=16 trong hệ cơ số 10

----------------------- Page 22-----------------------

Ví dụ về hằng

Các hằng pi, t, heso được tạo với từ khóa const

#include <stdio.h>

intmain(void)

{

const long double pi = 3.141592653590L;

const t = 7;

const heso = 9.123;

Lỗi const heso = 9.123;

Lỗi

days_in_week = 5;

return 0;

}

----------------------- Page 23-----------------------

b) Hằng ký tự

- Hằng ký tự là một ký tự riêng biệt được viết trong

cặp dấu nháy đơn (‘ ‘). Mỗi một ký tự tương ứng

với một giá tr trong bảng mã ASCII. Hằng ký tự

cũng được xem như tr số nguyên.

Ví dụ: ‘a’, ‘A’, ‘0’, ‘9’

- Có thể thực hiện các phép toán số học trên 2 ký

tự (thực chất là thực hiện phép toán trên giá tr

ASCII của chúng)

----------------------- Page 24-----------------------

b) Hằng ký tự(tiếp)

Một số ký tự không tin được (có tr ASCII từ 0 đến 31) trình

biên d ch C nhận biết điều này bằng cặp ký tự bắt đầu

bằng ‘\’:

newline

\t tab

\b backspace

\r carriage return

\f form feed

\a alert

\’ ‘

\” “

\\ \

----------------------- Page 25-----------------------

Hằng chuỗi ký tự

Hằng chuỗi ký tự là một chuỗi hay một xâu ký tự

được đặt trong cặp dấu nháy kép (“ ”).

- Các chuỗi được lưu trữ trong bộ nhớ như là một

dãy các ký tự liên tiếp và kết thúc bằng ký tự

rỗng (NULL) có mã ASCII là 0.

Ví dụ: “Ngon ngu lap trinh C”

“Khoa CNTT-DHNT”

- Phân biệt: “A” và ‘A’

----------------------- Page 26-----------------------

Hằng x lý trước biên dịch

Các hằng có thể được xác lập trước khi biên

d ch

– Bản chất là tìm kiếm và thay thế

– Thường được đặt tên với các chữ cái in hoa

Tìm từ “PI”, thay bằng 3.1415....

#include <stdio.h>

#definePI 3.141592653590L Lưu ý: không

#definePI 3.141592653590L

#defineDAYS_IN_WEEK 7 có “=” và “;”

#defineDAYS_IN_WEEK 7

#defineSUNDAY 0

int day = SUNDAY;

----------------------- Page 27-----------------------

3. Biểu thức

Biểu thức là sự kết hợp giữa các toán tử (operator) và

các toán hạng (operand) theo đúng một trật tự nhất đ nh.

Mỗi toán hạng có thể là một hằng, một biến hoặc một

biểu thức khác.

Trong trường hợp, biểu thức có nhiều toán tử, ta dùng

cặp dấu ngoặc đơn () để chỉ đ nh toán tử nào được thực

hiện trước.

Ví dụ: Biểu thức nghiệm của phương trình bậc hai:

(-b + sqrt(Delta))/(2*a)

Trong đó 2 là hằng; a, b, Delta là biến.

----------------------- Page 28-----------------------

Chương 2: Các toán t

1. Toán tử gán

2. Toán tử số học

3.Toán tử quan hệ

4. Toán tử logic

5. Toán tử thao tác bit

6. Toán tử sizeof

7. Toán tử chọn theo điều kiện

8, Toán tử con trỏ

9. Toán tử dấu phẩy

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

11. Hàm xuất dữ liệu

12. Hàm nhập dữ liệu

----------------------- Page 29-----------------------

1. Toán t gán:

Cú pháp

<biến> = <biều thức>

Có thể sử dụng liên tiếp nhiều phép gán

Giá tr được gán sẽ sẵn sàng cho lệnh kế tiếp

“n = 22” gán trước, lại

int i, j, k, l, m, n; gán “n” cho “m”, “m”

int i, j, k, l, m, n;

cho “l”, … i, j, k, l, m,

i = j = k = l = m = n = 22; n đều nhận giá trị 22.

i = j = k = l = m = n = 22;

printf("%i

", j = 93);

printf("%i

", j = 93);

29 “j” được gán 93, giá trị 93 sẽ

được in ra màn hình

----------------------- Page 30-----------------------

Toán t gán (tiếp)

Có thể sử dụng liên tiếp nhiều phép gán

int i, j, k, l, m, n; “n = 11” gán trước, lại

int i, j, k, l, m, n; gán “n” cho “m”, “m”

cho “l”, … i, j, k, l, m,

i = j = k = l = m = n = 11; n đều nhận giá trị 11.

i = j = k = l = m = n = 11;

printf("%i

", j = 91);

printf("%i

", j = 91);

“j” được gán 91, giá trị 91 sẽ

được in ra màn hình

----------------------- Page 31-----------------------

Một số phép gán đặc biệt

Các phép gán kết hợp toán tử khác:

+= -= *= /= %=

&= |= ^=

<<= >>=

Tổng quát:

tương đương:

a += 27; f /= 9.2; i *= j + 2;

a = a + 27; f = f / 9.2; i = i * (j + 2);

----------------------- Page 32-----------------------

2. Các các phép toán số học

+ cộng

- trừ

* nhân

/ chia

% chia lấy dư

Lu ý:

– “/” cho kt qu ph thuc vào kiu ca các toán hng

– “%” không thc hin ưc vi các s thc

----------------------- Page 33-----------------------

Ví dụ về toán t chia “/”

Trình biên d ch dựa vào kiểu của các toán

hạng để quyết đ nh phép chia tương ứng

int main(void)

“i”, “j” kiểu int, “/” là int main(void)

{

phép chia lấy nguyên {

k nhận giá trị 1 int i = 5, j = 4, k;

int i = 5, j = 4, k;

double f = 5.0, g = 4.0, h;

“f”, “g” kiểu double, “/”

là phép chia số thực k = i / j;

k = i / j;

h nhận giá trị 1.25

h = f / g;

h = i / j;

Phép chia nguyên, bất

kể “h” có kiểu double. return 0;

return 0;

Kết quả là 1.00000 }

}

----------------------- Page 34-----------------------

Phép tăng (giảm) 1

NNLT C có 2 toán tử đặc biệt hỗ trợ việc tăng (giảm)

giá tr của một biến thay đổi 1 đơn v

++ tăng 1

-- giảm 1

Các toán tử này có thể đặt ở trước hoặc sau biến.

int i = 5, j = 4;

“i” 6



i ++;

“j” 3 i ++;



-- j;

“i” 7

 ++ i;

++ i;

----------------------- Page 35-----------------------

Trước hay sau ?

Thứ tự thực hiện các toán tử ++ và -- phụ thuộc

vào v trí của chúng (trước hay sau) so với biến:

#include <stdio.h>

#include <stdio.h> Tương đương:

1. j++;

intmain(void)

intmain(void) 2. i = j;

{

int i, j = 5;

i = ++j; Tương đương:

i = ++j;

printf("i=%d, j=%d

", i, j); 1. i = j;

printf("i=%d, j=%d

", i, j);

j = 5; 2. j++;

j = 5;

i = j++;

printf("i=%d, j=%d

", i, j);

printf("i=%d, j=%d

", i, j);

i=6, j=6

return 0; i=6, j=6

return 0;

i=5, j=6

} i=5, j=6

35 }

----------------------- Page 36-----------------------

Chuyển kiểu/Ép kiểu (Type Casting)

Chuyểnkiểu làm thay đổi tm thi kiểu của một

biến trong một biểu thức.

int main(void)

{

int i = 5, j = 4;

doublef;

Phép chia số nguyên

được thực hiện, kết f = (double)i / j;

f = (double)i / j;

quả, 1, được đổi sang f = i / (double)j;

f = i / (double)j;

kiểu double, 1.00000 f = (double)i / (double)j;

f = (double)i / (double)j;

f = (double)(i / j);

return 0;

36 }

}

----------------------- Page 37-----------------------

3. Các toán t quan hệ (Relational Operators)

NNLT C hỗ trợ các toán tử quan hệ:

< bé hơn

<= bé hơn hay bằng

> lớn hơn

>= lớn hơn hay bằng

== bằng

!= khác

Tất cả đều cho kết quả 1 khi so sánh đúng

37 và 0 trong trường hợp ngược lại.

----------------------- Page 38-----------------------

4. Toán t logic

NNLT C hỗ trợ các toán tử logic:

&& và (and)

|| hoặc (or)

! phủ đ nh (not)

Tất cả đều cho kết quả 1 hoặc 0 tương ứng

các trường hợp ĐÚNG hoặc SAI

int i, j = 10, k = 28;

i = ((j > 5) && (k < 100)) || (k > 24);

----------------------- Page 39-----------------------

5. Toán t thao tác bit (Bitwise Operators)

Các toán tử trên bit chỉ có tác dụng trên các kiểu số

nguyên:

& And

| Or

^ Xor

~ Not

<< Shift Left

>> Shift Right

----------------------- Page 40-----------------------

6. Toán t sizeof

sizeof(Obj)

Cho biết kích thước của đối tượng theo số byte

#include <stdio.h>

int main(void)

{

long big;

printf("\"big\" is %u bytes

", sizeof(big));

printf("\"big\" is %u bytes

", sizeof(big));

printf("a short is %u bytes

", sizeof(short));

printf("a short is %u bytes

", sizeof(short));

printf("a double is %u bytes

", sizeof (double));

printf("a double is %u bytes

", sizeof (double));

"big" is 4 bytes

return 0; "big" is 4 bytes

return 0; a short is 2 bytes

} a short is 2 bytes

40 } a double is 8 bytes

a double is 8 bytes

----------------------- Page 41-----------------------

7. Toán t chọn theo điều kiện

(iu kin) ? BT1 : BT2

Biểu thức nhận giá tr BT1 nếu điều kiện khác 0

(ĐÚNG), các trường hợp khác nhận giá tr BT2

int i, j = 100, k = -1; int i, j = 100, k = -1;

i = (j > k) ? j : k; i = (j < k) ? j : k;

Nu (j > k)

Nu (j > k) Nu (j < k)

Nu (j < k)

i = j;

i = j; i = j;

i = j;

Ngưc li

Ngưc li Ngưc li

Ngưc li

i = k;

i = k; i = k;

i = k;

----------------------- Page 42-----------------------

8. Toán t con trỏ

+ Một con trỏ là đ a chỉ trong bộ nhớ của một biến. Một biến

con trỏ là một biến được khai báo riêng để chứa một con

trỏ đến một đối tượng của kiểu đã chỉ ra nó.

+ Có hai toán tử được sử dụng để thao tác với các con trỏ.

- Toán tử thứ nhất là &, là một toán tử quy ước trả về đ a

chỉ bộ nhớ của hệ số của nó.

Ví dụ: p = &n

Đặt vào biến m đ a chỉ bộ nhớ của biến count.

Chẳng hạn, biến n ở v trí bộ nhớ 2000, giả sử n có giá tr

là 100. Sau câu lệnh trên p sẽ nhận giá tr 2000.

- Toán tử thứ hai là *, là một bổ sung cho &; đây là một

toán tử quy ước trả về giá tr của biến được cấp phát tại

đ a chỉ theo sau đó.

Ví dụ: m = *p

Sẽ đặt giá tr của n vào m. Bây giờ m sẽ có giá tr là 100 vì

100 được lưu trữ tại đ a chỉ 2000.

----------------------- Page 43-----------------------

9. Toán t dấu phẩy ,

Toán tử dấu , được sử dụng để kết hợp các

biểu thức lại với nhau. Bên trái của toán tử

dấu , luôn được xem là kiểu void. Điều đó

có nghĩa là biểu thức bên phải trở thành giá

tr của tổng các biểu thức được phân cách

bởi dấu phẩy.

Ví dụ: x = (y=3,y+1);

Trước hết gán 3 cho y rồi gán 4 cho x. Cặp

dấu ngoặc đơn là cần thiết vì toán tử dấu ,

có độ ưu tiên thấp hơn toán tử gán.

----------------------- Page 44-----------------------

10. Độ ưu tiên của toán t

Thứ tự thực hiện các toán tử trong một biểu thức phụ

thuộc vào ưu tiên của chúng.

Có 15 mức ưu tiên.

Thông thường, toán tử một ngôi có độ ưu tiên cao hơn

toán tử hai ngôi.

Các cặp dấu ngoặc đơn () thường được dùng để chỉ rõ

thứ tự các toán tử.

#include <stdio.h>

int main(void)

{

int j = 3 * 4 + 48 / 7;

printf("j = %i

", j);

printf("j = %i

", j);

return 0;

j = 18

44 } j = 18

}

----------------------- Page 45-----------------------

Bảng thứ tự thực hiện các toán t

Toán t Thứ tự (nếu cùng ĐƯT)

() [] -> .

! ++ -- - + (cast) * & sizeof 

* / %

+ -

<< >>

< <= >= >

== !=

?: 

= += -= *= /= %= … 

----------------------- Page 46-----------------------

Ví dụ

#include <stdio.h>

int main(void)

{

int i = 0, j, k = 7, m = 5, n;

j = m += 2;

printf("j = %d

", j);

printf("j = %d

", j);

j = k++ > 7;

printf("j = %d

", j);

printf("j = %d

", j);

j = i == 0 & k;

printf("j = %d

", j);

printf("j = %d

", j);

n = !i > k >> 2;

printf("n = %d

", n);

printf("n = %d

", n);

return 0;

}

----------------------- Page 47-----------------------

11. Hàm xuất - printf

Xuất dữ liệu ra màn hình:

printf(“Chuỗi đ nh dạng ”, Các biểu thức);

printf("%d- %d=%d

",a,b, a - b);

Các ký tự hằng được in nguyên văn

Các ký tự đ nh dạng được thay bằng giá tr của biểu thức tương

ứng:

%d: ký tự đ nh dạng số nguyên kiểu int

Các ký tự điều khiển:

– xuống dòng; \t – dấu tab;

\\ – dấu \; \“– dấu “…

Thư viện: stdio.h

----------------------- Page 48-----------------------

11. Hàm xuất – printf (tiếp)

%d Xut s nguyên

%[.s ch s thp phân] f Xut s thc có <s ch s thp phân> theo quy tc làm tròn s.

%o Xut s nguyên h bát phân

%x Xut s nguyên h thp lc phân

%c Xut mt ký t

%s Xut chui ký t

%e hoc %E hoc %g hoc Xut s nguyên dng khoa hc (nhân 10 m x)

Ví d

%d In ra s nguyên

%4d In s nguyên ti a 4 ký s, nu s cn in nhiu hn 4 ký s thì in ht

%f In s thc

%6f In s thc ti a 6 ký s (tính luôn du chm), nu s cn in nhiu hn 6

ký s thì in ht

%.3f In s thc có 3 s l, nu s cn in có nhiu hn 3 s l thì làm tròn.

----------------------- Page 49-----------------------

12. Hàm nhập - scanf

Nhập dữ liệu từ bàn phím

scanf(“Chuỗi đ nh dạng”, đ a chỉ của các biến);

scanf("%d %d", &a, &b);

– Trong chuỗi đ nh dạng chỉ có ký tự đ nh dạng và khoảng

trắng.

– Dữ liệu phải được nhập vào các biến.

– Trước tên biến phải ghi dấu & - toán tử đ a chỉ. Nếu

không có toán tử đ a chỉ, giá tr của biến sẽ không được

cập nhật

– Thư viện: stdio.h

----------------------- Page 50-----------------------

12. Hàm nhập – scanf(tiếp)

nh dng Ý ngha

%[s ký s]d Nhp s nguyên có ti a <s ký s>

%[s ký s] f Nhp s thc có ti a <s ký s> tính c du chm

%c Nhp mt ký t

Ví d:

%d Nhp s nguyên

%4d Nhp s nguyên ti a 4 ký s, nu nhp nhiu hn 4 ký s thì ch nhn ưc 4 ký s

u tiên

%f Nhp s thc

%6f Nhp s thc ti a 6 ký s (tính luôn du chm), nu nhp nhiu hn 6 ký s thì ch

nhn ưc 6 ký su tiên (hoc 5 ký s vi du chm)

----------------------- Page 51-----------------------

Chương 3: Các cấu trúc điều khiển

1. Lệnh if

2. Lệnh switch

3. Lệnh for

4. Lệnh while

5. Lệnh do .. While

----------------------- Page 52-----------------------

1. Lệnh if

Dùng để thực hiện hay không một

phát biểu theo một điều kiện. Chỉ có 1

Dạng 1: phát biểu

trong thân

if (<Bthức ĐK>) <Lệnh S>; của if

Ví dụ

Bthức ĐK if (delta > 0)

F {

Lệnh S

x1 = (-b + sqrt(delta))/2/a;

x2 = (-b - sqrt(delta))/2/a;

}

----------------------- Page 53-----------------------

Dạng 2 của lệnh if

Dùng để chọn lựa phát biểu nào sẽ được thực hiện

giữa 2 phát biểu.

Cú pháp:if (< Bthức ĐK >) <Lệnh S1> ; else <Lệnh S2> ;

#include <stdio.h>

#include <conio.h>

int main ()

{

float a;

Bthức ĐK

printf("Nhap a = "); scanf("%f",&a);

if (a !=0 )

printf("Nghich dao cua %f la %f",a,1/a);

Lệnh S1 Lệnh S2 else

printf(“Khong the tim nghich dao cua a”);

getch();

return 0;

53 }

----------------------- Page 54-----------------------

Trường hợp đặc biệt

Xét phát biểu sau:

if (<ĐK1>) if (<ĐK2>) <S1>; else <S2>;

else else

else sẽ thuộc về if nào gần 1 chưa có else

Yes

ĐK2 ĐK2

Yes

S1 S2

----------------------- Page 55-----------------------

2. Lệnh switch

Dùng để chọn một Cú pháp:

trong số những switch (<Biểu thức>)

phát biểu để thực {

hiện tùy theo giá tr case <giá tr 1>: <LệnhS1>; break;

của biu thc chn.

…

Các giá tr case: chỉ case <giá tr n>: <Lệnh Sn>; break;

ra các trường hợp [default : <lệnh mặc đ nh Sn+1>;]

phân nhánh. }

Các giá tr case là

một hay nhiều giá BiểuThức

tr rời rạc theo sau

là dấu : và một phát Gtr 1 Gtr 2 Gtr N default

biểu tương ứng, kết

thúc là break. S1 S2 Sn Sn+1

----------------------- Page 56-----------------------

Ví dụ 1

Nhập vào một số nguyên, chia số nguyên này cho 2 lấy phần dư. Kiểm tra

nếu phần dư bằng 0 thì in ra thông báo “số chẵn”, nếu số dư bằng 1 thì

in thông báo “số lẻ”.

#include <stdio.h>

#include<conio.h>

int main ()

{ int songuyen, phandu;

clrscr();

printf("

Nhap vao so nguyen ");

scanf("%d",&songuyen); phandu=(songuyen % 2);

switch(phandu)

{

case 0: printf("%d la so chan ",songuyen); break;

case 1: printf("%d la so le ",songuyen); break;

}

getch();

return 0;

56 }

----------------------- Page 57-----------------------

Ví dụ 2

Ví dụ 2: Nhập vào 2 số nguyên và 1 phép toán.

- Nếu phép toán là ‘+’, ‘-‘, ‘*’ thì in ra kết qua là tổng, hiệu, tích của 2 số.

- Nếu phép toán là ‘/’ thì kiểm tra xem số thứ 2 có khác không hay không? Nếu khác không thì in ra

thương của chúng, ngược lại thì in ra thông báo “khong chia cho 0”.

#include <stdio.h>

#include<conio.h>

int main ()

{ int so1, so2; float thuong; char pheptoan;

printf("

Nhap vao 2 so nguyen "); scanf("%d%d",&so1,&so2);

fflush(stdin); /*Xóa ký tự enter trong vùng đệm trước khi nhập phép toán */

printf("

Nhap vao phep toan "); scanf("%c",&pheptoan);

switch(pheptoan)

{ case '+': printf("

%d + %d =%d",so1, so2, so1+so2); break;

case '-': printf("

%d - %d =%d",so1, so2, so1-so2); break;

case '*': printf("

%d * %d =%d",so1, so2, so1*so2); break;

case '/': if (so2!=0)

{ thuong=float(so1)/float(so2);

printf("

%d / %d =%f", so1, so2, thuong); }

else printf("Khong chia duoc cho 0"); break;

default : printf("

Chua ho tro phep toan %c", pheptoan); break;

}

getch();

57 return 0;

}

----------------------- Page 58-----------------------

3. Lệnh for

Lệnh for cho phép lặp lại các lệnh cho đến khi Biểu thức

điều kiện 2 là sai

Cú pháp: for (<biểuthức 1>;<biểuthức 2>;<biểuthức 3>) <lệnh S>

Ví dụ: Viết chương trình nhập vào một số nguyên

Bthức 1

n. Tính tổng của các số nguyên từ 1 đến n.

#include <stdio.h>

#include<conio.h>

int main ()

{ unsigned int n,i,tong; BThức 3

printf("

Nhap vao so n:");scanf("%d",&n);

tong=0;

for (i=1; i<=n; i++) tong+=i; Lệnh S

printf("

Tong tu 1 den %d =%d ",n,tong); T

getch(); Bthức 2

return 0;

} F

----------------------- Page 59-----------------------

4. Lệnh while

Dùng để lặp lại một công việc nào đó Ví dụ:

cho đến khi điều kiện sai. gt=1; i=1;

Cú pháp while (i<n)

while (<Biu thc K>) <Lnh S> {

while kiểm tra điều kiện trước rồi mới i++;

thực hiện lệnh S.

gt=gt*i;

Số lầp lặp là không biết trước. }

Số lần lặp tối thiểu là 0 và tối đa là

không xác đ nh.

Chú ý: Trong thân ca while phi có

ít nht mt phát biu có kh nng T

thay i giá tr ca iu kin. Nu Lệnh S BTĐK

không s lp vô tn (infinite loop)

----------------------- Page 60-----------------------

Ví dụ về lệnh while

Ví dụ 2: Viết chương trình nhập vào một số nguyên n. Tính tổng của các

số nguyên từ 1 đến n.

#include <stdio.h>

#include<conio.h>

int main ()

{ unsigned int n,i,tong;

printf("

Nhap vao so nguyen duong n:"); scanf("%d",&n);

tong=0;

i=1;

while (i<=n)

{

tong+=i;

i++;

}

printf("

Tong tu 1 den %d =%d ",n,tong);

getch();

return 0;

60 }

----------------------- Page 61-----------------------

5. Lệnh do .. while

Vòng lặp do … while dùng để lặp lại một công việc

nào đó khi điều kiện còn đúng.

Cú pháp:

do <Lnh S> while (<Biu thc điu kin>)

Thực hiện xong lệnh S mới kiểm tra điều kiện.

Số lầp lặp là không biết trước.

Số lần lặp tối thiểu là 1 và tối đa là không xác

đ nh.

Chú ý: Trong thân ca do .. While phi có ít

nht mt phát biu có kh nng thay i giá tr

ca iu kin. Nu không s lp vô tn (infinite

loop) T

BTĐK

----------------------- Page 62-----------------------

Ví dụ về lệnh do .. while

Viết chương trình nhập vào một số nguyên n. Tính tổng của các số nguyên

từ 1 đến n.

#include <stdio.h>

#include<conio.h>

int main ()

{ unsigned int n,i,tong;

printf("

Nhap vao so nguyen duong n:"); scanf("%d",&n);

tong=0;

i=1;

{

tong+=i;

i++;

} while (i<=n);

printf("

Tong tu 1 den %d =%d ",n,tong);

getch();

62 return 0;

}

----------------------- Page 63-----------------------

6. CÁC CÂU LỆNH ĐẶC BIỆT

1. Lệnh break Cú pháp: break

Dùng để thoát khỏi vòng lặp. Khi gặp câu lệnh này trong vòng lặp, chương trình sẽ

thoát ra khỏi vòng lặp và chỉ đến câu lệnh liền sau nó. Nếu nhiều vòng lặp thì

break sẽ thoát ra khỏi vòng lặp gần nhất. Ngoài ra, break còn được dùng trong

cấu trúc lựa chọn switch.

2. Lệnh continue Cú pháp: continue

- Khi gặp lệnh này trong các vòng lặp, chương trình sẽ bỏ qua phần còn lại trong

vòng lặp và tiếp tục thực hiện lần lặp tiếp theo.

- Ðối với lệnh for, biểu thức 3 sẽ được tính tr và quay lại bước 2.

- Ðối với lệnh while, do while; biểu thức điều kiện sẽ được tính và xét xem có thể

tiếp tục thực hiện <Lệnh S> nữa hay không? (dựa vào kết quả của biểu thức điều

kiện).

Ví dụ: while (x != y)

{

…

if (x==a) continue;

b+=6;

…

if (y==b) break;

63 } …

----------------------- Page 64-----------------------

Chương 4: Các hàm trong C

1. Khái niệm hàm trong C

Tại sao phải dùng chương trình con:

– Có công việc cần phải được thực hiện tại nhiều nơi trong chương

trình => tách công việc đó thành chương trình con

– Phân đoạn, module chương trình để thuận tiện trong quản lý,

trình bày và phát triển.

Trong C, chương trình con được gọi là hàm. Hàm trong C có

thể trả về kết quả thông qua tên hàm hay có thể không trả về

kết quả.

Hàm có hai loại: hàm chuẩn (hàm được trình biên d ch C viết

sẵn) và hàm tự đ nh nghĩa.

Một hàm khi được đ nh nghĩa thì có thể được gọi trong

chương trình.

Trong C, hàm main() được gọi thực hiện đầu tiên

----------------------- Page 65-----------------------

Ví dụ

Viết hàm main dùng để nhập vào 2 số nguyên a,b và in ra màn hình số lớn trong 2

số đã nhập

#include <stdio.h>

#include <conio.h>

int max(int a, int b);

int main()

{

int a, b, c;

printf("

Nhap vao 3 so a, b,c ");

scanf("%d%d%d",&a,&b,&c);

printf("

So lon la %d",max(a, max(b,c)));

getch();

return 0;

}

int max(int a, int b)

{

return (a>b) ? a:b;

65 }

----------------------- Page 66-----------------------

Ghi chú

- Dòng int max(int a, int b); gọi là Prototype của hàm, qui đ nh

kiểu trả về của hàm, số lượng tham số và kiểu của chúng.

- Các Prototype của các hàm sẵn có chứa trong các tập tin *.h

- Hàm có thể được gọi bởi hàm main(), hoặc từ một hàm khác

hoặc chính nó(đệ qui).

- Hàm có thể có tham số hoặc không.

- Hàm chỉ có 1 điểm vào (lệnh đầu tiên của hàm) nhưng có thể

có nhiều điểm ra (lệnh return).

- Một hàm có thể được viết ngay trong văn bản chương trình

(như trên), hoặc được viết trong tập tin khác và đưa vào

chương trình bằng chỉ th #include, hoặc được biên d ch riêng

rẽ và kết nối lại.

- Khác với ngôn ngữ lập trình Pascal:

- Ngôn ngữ C không có khái niệm thủ tục (thật ra thủ tục không

khác hàm, ở thủ tục không quan tâm đến giá tr trả về)

- Không cho phép các hàm lồng vào nhau

----------------------- Page 67-----------------------

2. Hàm thư viện/hàm chuẩn

Hàm thư viện là những hàm đã được đ nh nghĩa sẵn trong một thư viện

nào đó, muốn sử dụng các hàm thư viện thì phải khai báo thư viện trước

khi sử dụng bằng lệnh #include <tên thư viện.h>

Ý nghĩa ca mt s th vin thng dùng:

1. stdio.h : Thư viện chứa các hàm vào/ ra chuẩn (standard input/output). Gồm các

hàm printf(), scanf(), getc(), putc(), gets(), puts(), fflush(), fopen(), fclose(),

fread(), fwrite(), getchar(), putchar(), getw(), putw()…

2. conio.h : Thư viện chứa các hàm vào ra trong chế độ DOS (DOS console). Gồm

các hàm clrscr(), getch(), getche(), getpass(), cgets(), cputs(), putch(),

clreol(),…

3. math.h: Thư viện chứa các hàm tính toán gồm các hàm abs(), sqrt(), log().

log10(), sin(), cos(), tan(), acos(), asin(), atan(), pow(), exp(),…

4. alloc.h: Thư viện chứa các hàm liên quan đến việc quản lý bộ nhơ. Gồm các

hàm calloc(), realloc(), malloc(), free(), farmalloc(), farcalloc(), farfree(), …

5. io.h: Thư viện chứa các hàm vào ra cấp thấp. Gồm các hàm open(), _open(),

read(), _read(), close(), _close(), creat(), _creat(), creatnew(), eof(),

filelength(), lock(),…

6. graphics.h: Thư viện chứa các hàm liên quan đến đồ họa. Gồm initgraph(),

line(), circle(), putpixel(), getpixel(), setcolor(), …

...

Muốn sử dụng các hàm thư viện thì ta phải xem cú pháp của các hàm và sử dụng

67 theo đúng cú pháp (xem trong phần trợ giúp của Turbo C).

----------------------- Page 68-----------------------

3. Hàm của người s dụng

– Hàm người dùng là những hàm do người lập

trình tự tạo ra nhằm đáp ứng nhu cầu xử lý của

mình.

Cấu trúc của hàm:

<kiểu kết quả> <Tên hàm> ([<kiểu> <tham số>][,<kiểu><tham số>][…])

{

[Khai báo]

<câu lệnh thực hiện hàm>

[return <Biểu thức>;]

}

----------------------- Page 69-----------------------

Truyền Bằng Trị - Tham biến - Tham Chiếu

Ví dụ: Viết chương trình hoán v 2 phần tử int main()

#include<stdio.h> { int m=12; n=28;

Swap1(m,n);

// Truyền bằng tham trị

1 void Swap1 (int x, int y) printf(“m=%d n=%d

”,m,n”);

2 { Swap2(&m,&n);

3 int temp = x;

4 x = y; printf(“m=%d n=%d

”,m,n”);

5 y = temp; Swap3(m,n);

6 }

// Truyền bằng tham biến (con trỏ) printf(“m=%d n=%d

”,m,n”);

7 void Swap2 (int *x, int *y) return 0;

8 {

9 int temp = *x; }

10 *x = *y;

11 *y = temp;

}

12 // Truyền bằng tham chiếu

13 void Swap3 (int &x, int &y)

14 {

15 int temp = x;

16 x = y;

17 } y = temp; ?

18 ?

----------------------- Page 70-----------------------

4. Tham trị và tham biến

Mặc nhiên, việc truyền tham số cho hàm trong C là truyền theo giá tr ; nghĩa là

các giá tr thực (tham số thực) không b thay đổi giá tr khi truyền cho các

tham số hình thức

Ví dụ 1: Giả sử muốn in ra các, mỗi dòng gồm 50 ký tự nào đó. Để đơn giản ta

viết hàm, hàm này sẽ in ra trên một dòng 50 ký tự cho trước.

#include <stdio.h> Lưu ý:

#include <conio.h> - Trong hàm InKT ở trên, biến ch gọi là

tham số hình thức được truyền bằng giá

void InKT(char ch)

tr (gọi là tham tr của hàm). Các tham tr

{ int i;

của hàm coi như là một biến cục bộ trong

for(i=1;i<=50;i++) printf(“%c”,ch);

hàm và chúng được sử dụng như là dữ

] printf(“

”);

liệu đầu vào của hàm.

}

-Khi chương trình con được gọi để thi

hành, tham tr được cấp ô nhớ và nhận

int main()

giá tr là bản sao giá tr của tham số thực.

{

char c = ‘A’; -Việc thay đổi giá tr của chúng không có

ý nghĩa gì đối với bên ngoài hàm, không

InKT(‘*’); /* In ra 50 dau * */

ảnh hưởng đến chương trình chính,

InKT(‘+’);

nghĩa là không làm ảnh hưởng đến tham

InKT(c);

70 return 0; số thực tương ứng.

}

----------------------- Page 71-----------------------

5. HÀM ĐỆ QUY

Đ nh nghĩa: Một hàm được gọi là đệ quy nếu bên trong thân hàm có lệnh gọi đến chính nó.

Ví dụ: Đ nh nghĩa giai thừa của một số nguyên dương n như sau:

n!=1* 2 * 3 *…* (n-1) *n = (n-1)! *n (với 0!=1)

Như vậy, để tính n! ta thấy nếu n=0 thì n!=1 ngược lại thì n!=n * (n-1)!

Với đ nh nghĩa trên thì hàm đệ quy tính n! được viết:

#include <stdio.h>

#include <conio.h>

/*Hàm tính n! bằng đệ quy*/

unsigned int giaithua_dequy(int n)

{ int main()

if (n==0) return 1; {

else return n*giaithua_dequy(n-1); int n;

} printf("

Nhap so n can tinh giai thua "); scanf("%d",&n);

printf("

Goi ham de quy: %d !=%u",n,giaithua_dequy(n));

/*Hàm tính n! không đệ quy*/ printf("

Goi ham khong de quy: %d != %u",

unsigned int giaithua_khongdequy(int n) n,giaithua_khongdequy(n));

{ unsigned int kq,i; getch();

kq=1; return 0;

for (i=2;i<=n;i++) kq=kq*i; }

return kq;

}

----------------------- Page 72-----------------------

Đặc điểm cần lưu ý khi viết hàm đệ quy

- Hàm đệ quy phải có 2 phần:

+ Phần dừng hay phải có trường hợp nguyên tố. Trong ví dụ ở

trên thì trường hợp n=0 là trường hợp nguyên tố.

+ Phần đệ quy: là phần có gọi lại hàm đang được đ nh nghĩa.

Trong ví dụ trên thì phần đệ quy là n>0 thì n! = n * (n-1)!

- Sử dụng hàm đệ quy trong chương trình sẽ làm chương trình dễ

đọc, dễ hiểu và vấn đề được nêu bật rõ ràng hơn. Tuy nhiên

trong đa số trường hợp thì hàm đệ quy tốn bộ nhớ nhiều hơn

và tốc độ thực hiện chương trình chậm hơn không đệ quy.

- Tùy từng bài có cụ thể mà người lập trình quyết đ nh có nên dùng

đệ quy hay không (có những trường hợp không dùng đệ quy

thì không giải quyết được bài toán).

----------------------- Page 73-----------------------

6. Tham số của hàm main()

- Là 2 tham số : argc và argv

- Tham số argc là số nguyên chỉ tham số trên dòng lệnh, có giá tr nhỏ nhất =1,

vì bản thân tên chương trình là tham số thứ nhất

- Tham số argv là mảng các con trỏ, trỏ đến các tham số trên dòng lệnh: char

*argv[ ];

argv[0]: chứa đ a chỉ của tên chương trình

argv[1]: chứa đ a chỉ của tham số thứ nhất

argv[2]: chứa đ a chỉ của tham số thứ hai

Ví dụ: Chương trình sau đã được biên d ch thành MYPRO.EXE, nếu nhập trên dòng lệnh

MYPRO thì có dòng nhắc nhở, nếu nhập MYPRO LAN thì Chao ban LAN

#include <stdio.h>

main(int argc, char *argv[])

{

if (argc !=2) printf(“Phai nhap Ten”);

else printf(“Chao ban %s

”,argv[1]);

}

----------------------- Page 74-----------------------

Chương 5: Dữ liệu có cấu trúc

1. Kiểu mảng:

- Mảng là một tập hợp các phần tử cố đ nh có cùng một kiểu, gọi là

kiểu phần tử. Kiểu phần tử có thể là có các kiểu bất kỳ: ký tự, số,

chuỗi ký tự…; cũng có khi ta sử dụng kiểu mảng để làm kiểu

phần tử cho một mảng (trong trường hợp này ta gọi là mảng của

mảng hay mảng nhiều chiều).

- Có thể chia mảng làm 2 loại: mảng 1 chiều và mảng nhiều chiều.

- Khai báo mảng với số phần t xác định

Cú pháp: <Kiểu> <Tên mảng ><[số phần t ]>

Ý nghĩa:

- Tên mảng: đây là một cái tên đặt đúng theo quy tắc đặt tên của

danh biểu. Tên này cũng mang ý nghĩa là tên biến mảng.

- Số phần t : là một hằng số nguyên, cho biết số lượng phần tử tối

đa trong mảng là bao nhiêu (nói khác là kích thước của mảng).

- Kiểu: mỗi phần tử của mảng có dữ liệu thuộc kiểu gì.

- Khi khai báo một biến mảng gồm có s phn tphần tử, phần tử

thứ nhất là tên mng [0], phần tử cuối cùng là tên mng[s

phn t -1]

----------------------- Page 75-----------------------

1. Kiểu mảng(tiếp)

Ví dụ: int a[10]; /* Khai báo biến mảng a gồm 10 phần tử , phần tử thứ

nhất là a[0], phần tử cuối cùng là a[9].*/

Có thể coi mảng a là một dãy liên tiếp các phần tử trong bộ nhớ như sau:

V trí 0 1 2 3 4 5 6 7 8 9

Tên phn t a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9]

2. Khai báo mảng với số phần tử không xác đ nh

Cú pháp: <Kiểu> <Tên mảng> <[]>

Khi khai báo, không cho biết rõ số phần tử của mảng, kiểu khai báo

này thường được áp dụng trong các trường hợp: vừa khai báo vừa

gán giá tr , khai báo mảng là tham số hình thức của hàm.

a. Vừa khai báo vừa gán giá tr

Cú pháp: <Kiểu> <Tên mảng> []= {Các giá tr phân cách bởi dấu ,}

Nếu vừa khai báo vừa gán giá tr thì mặc nhiên C sẽ hiểu số phần tử

của mảng là số giá tr mà chúng ta gán cho mảng trong cặp dấu {}.

b. Khai báo mảng là tham số hình thức của hàm, trong trường hợp này ta

không cần chỉ đ nh số phần tử của mảng là bao nhiêu.

----------------------- Page 76-----------------------

1. Kiểu mảng(tiếp)

- Truy xuất từng phần tử của mảng

+ Mỗi phần tử của mảng được truy xuất thông qua Tên biến mảng

theo sau là chỉ số nằm trong cặp dấu ngoặc vuông [ ]. Chẳng hạn

a[0] là phần tử đầu tiên của mảng a được khai báo ở trên. Chỉ số

của phần tử mảng là một biểu thức mà giá tr là kiểu số nguyên.

+ Với cách truy xuất theo kiểu này, Tên biến mảng[Chỉ số] có thể coi

như là một biến có kiểu dữ liệu là kiểu được chỉ ra trong khai báo

biến mảng.

Ví dụ 2: Vừa khai báo vừa gán tr cho 1 mảng 1 chiều các số nguyên. In

mảng số nguyên này lên màn hình.

#include <stdio.h>

#include <conio.h>

int main()

{

int n,i,j,tam;

int dayso[]={66,65,69,68,67,70};

n=sizeof(dayso)/sizeof(int); /*Lấy số phần tử*/

printf("

Noi dung cua mang ");

for (i=0;i<n;i++) printf("%d ",dayso[i]);

return 0;

76 }

----------------------- Page 77-----------------------

1. Kiểu mảng(tiếp)

Ví dụ 4: Nhập vào một dãy n số và sắp xếp các số theo thứ tự tăng.

#include<conio.h>

#include<stdio.h>

void Nhap(int a[],int N)

{ int i; int main()

for(i=0; i< N; i++)

{ { int b[20], N;

printf("Phan tu thu %d: ",i); printf("So phan tu cua mang N=

scanf("%d",&a[i]); ");

} scanf("%d",&N);

}

Nhap(b,N);

void InMang(int a[], int N) printf("Mang vua nhap: ");

{ int i; InMang(b,N);

for (i=0; i<N;i++) printf("%d ",a[i]); SapXep(b,N); /* Gọi hàm sắp

printf("

");

} xếp*/

void SapXep(int a[], int N) printf("Mang sau khi sap xep: ");

{ int t,i;

for(i=0;i<N-1;i++) InMang(b,N);

for(int j=i+1;j<N;j++) getch();

if (a[i]>a[j]) return 0;

{ t=a[i]; a[i]=a[j]; a[j]=t; } }

77 }

----------------------- Page 78-----------------------

1. Kiểu mảng(tiếp)

Ví dụ: Viết chương trình cho phép nhập 2 ma trận a, b có m dòng n cột, thực hiện phép toán

cộng hai ma trận a,b và in ma trận kết quả lên màn hình.

#include<conio.h>

#include<stdio.h> int main()

void Nhap(int a[][10],int M,int N) { int a[10][10], b[10][10], M, N;

{ int i,j; int c[10][10];/* Ma tran tong*/

for(i=0;i<M;i++) printf("So dong M= "); scanf("%d",&M);

for(j=0; j<N; j++){ printf("So cot M= "); scanf("%d",&N);

printf("Phan tu o dong %d cot %d: ",i,j); printf("Nhap ma tran A

"); Nhap(a,M,N);

scanf("%d",&a[i][j]); printf("Nhap ma tran B

"); Nhap(b,M,N);

} printf("Ma tran A:

"); InMaTran(a,M,N);

} printf("Ma tran B:

"); InMaTran(b,M,N);

void InMaTran(int a[][10], int M, int N) CongMaTran(a,b,M,N,c);

{ int i,j; printf("Ma tran tong C:

");

for(i=0;i<M;i++){ InMaTran(c,M,N);

for(j=0; j< N; j++) printf("%d ",a[i][j]); getch();

printf("

"); return 0;

} }

}

/* Cong 2 ma tran A & B ket qua la ma tran C*/

void CongMaTran(int a[][10],int b[][10],int M,int N,int c[][10])

{ int i,j;

for(i=0;i<M;i++)

78 for(j=0; j<N; j++) c[i][j]=a[i][j]+b[i][j];

}

----------------------- Page 79-----------------------

Mảng nhiều chiều

Mùa xuân Mùa hè Mùa thu Mùa đông

Sydney 26 34 22 17

Melbourne 24 32 19 13 int Mua[3][4];

Brisbane 28 38 25 20

26 34 22 17 24 32 19 13 28 38 25 20

... ...

First row Second row Third row

hàng u hàng hai hàng ba

Cách tổ chức trong bộ nhớ

----------------------- Page 80-----------------------

2. Kiểu chuỗi ký tự

- Kiểu chuỗi ký tự là một trường Ví dụ: Nhập vào một chuỗi và hiển th

trên màn hình chuỗi vừa nhập.

hợp đặc biệt của mảng các ký

#include<conio.h>

tự. Chuỗi ký tự kết thúc bằng #include<stdio.h>

ký tự có mã ASCII là 0 (‘\0’) #include<string.h>

- Do đó, char[10]; //lưu trữ tối int main()

đa 9 ký tự { char Ten[12];

printf("Nhap chuoi: ");gets(Ten);

Ghi chú:

printf("Chuoi vua nhap: ");puts(Ten);

+ Khi áp dụng các phép toán getch();

trên chuỗi, ta phải sử dụng return 0;

các hàm (string.h) }

Ví dụ:-Hàm strcpy(chuỗi1,chuỗi 2):

chép chuỗi 2 vào chuỗi 1

-Hàm strcmp(chuỗi1,chuỗi2):

so sánh 2 chuỗi trả về 0 nếu 2

80 chuỗi bằng nhau ….

----------------------- Page 81-----------------------

3. Kiểu con trỏ

- Các biến trước đây đều là biến có kích thước và kiểu dữ liệu xác đ nh. Gọi các biến

kiểu này là biến tĩnh. Khi khai báo biến tĩnh, các ô nhớ sẽ được cấp phát mà không biết

trong quá trình chạy chương trình có sử dụng hết chúng hay không.

- Các biến tĩnh dạng này sẽ tồn tại trong suốt thời gian thực thi chương trình dù có

những biến mà chương trình chỉ sử dụng 1 lần rồi bỏ. Các hạn chế về biến tĩnh:

- Cấp phát ô nhớ dư, gây ra lãng phí ô nhớ.

- Cấp phát ô nhớ thiếu, chương trình thực thi b lỗi.

- Để giải quyết những hạn chế trên, ngôn ngữ C cung cấp cho ta một loại biến đặc biệt

gọi là biến động với các đặc điểm sau:

- Chỉ phát sinh trong quá trình chạy chương trình chứ không phát sinh lúc bắt đầu chương trình.

- Khi chạy chương trình, kích thước của biến, vùng nhớ và đ a chỉ vùng nhớ được cấp phát cho

biến có thể thay đổi.

- Sau khi sử dụng xong có thể giải phóng để tiết kiệm chỗ trong bộ nhớ.

- Vì thế, ngôn ngữ C lại cung cấp cho ta một loại biến đặc biệt nữa để khắc phục tình

trạng này, đó là biến con trỏ (pointer) với các đặc điểm:

- Biến con trỏ không chứa dữ liệu mà chỉ chứa đ a chỉ của dữ liệu hay chứa đ a chỉ của ô nhớ

- Kích thước của biến con trỏ không phụ thuộc vào kiểu dữ liệu, luôn có kích thước cố đ nh là 2

81 bytes nếu trong cùng 1 đoạn và 4 bytes nếu khác đoạn.

----------------------- Page 82-----------------------

3. Kiểu con trỏ(tiếp)

a. Khai báo biến con trỏ

Cú pháp: <Kiểu> * <biến con trỏ>

Ví dụ 1: Khai báo 2 biến a,b có kiểu int và 2 biến pa, pb là 2 biến con trỏ kiểu int.

int a, b, *pa, *pb;

Ví dụ 2: Khai báo biến f kiểu float và biến pf là con trỏ float

float f, *pf;

b. Các phép toán trên con trỏ

+. Phép gán con trỏ: Hai con trỏ cùng kiểu có thể gán cho nhau.

Ví dụ: int a, *p, *a ; float *f;

a = 5 ;

p = &a ;

q = p ; /* đúng */

f = p ; /* sai do khác kiểu */

+ Cộng, trừ con trỏ với một số nguyên: Có thể cộng (+), trừ (-) 1 con trỏ với 1 số

nguyên N nào đó; kết quả trả về là 1 con trỏ. Con trỏ này chỉ đến vùng nhớ cách

vùng nhớ của con trỏ hiện tại N phần tử.

- Đơn v tăng hay giảm của con trỏ có kích thướccủa biến được trỏ đến

----------------------- Page 83-----------------------

4. Con trỏ được dùng như mảng.

Ví d: Cho 1 mảng 1 chiều các số nguyên a có 5 phần tử, truy cập các phần tử theo

kiểu mảng và theo kiểu con trỏ.

#include <stdio.h> int main()

#include <conio.h> { int a[20],N,i;

/* Nhập mảng bình thường*/ printf("So phan tu N= ");scanf("%d",&N);

void NhapMang(int a[], int N) NhapMang(a,N);

{ int i;

printf("Truy cap theo kieu mang: ");

for(i=0;i<N;i++)

{ printf("Phan tu thu %d: ",i); for(i=0;i<N;i++) printf("%d ",a[i]);

scanf("%d",&a[i]); printf("

Truy cap theo kieu con tro: ");

} for(i=0;i<N;i++) printf("%d ",*(a+i));

} getch();

/* Nhập mảng theo dạng con trỏ*/ return 0;

void NhapContro(int a[], int N) }

{ int i;

for(i=0;i<N;i++)

{ printf("Phan tu thu %d: ",i);

scanf("%d",a+i);

}

83 }

----------------------- Page 84-----------------------

5. Con trỏ và cấp phát động

a. Hàm cấp phát:

void *malloc(size_t size): Cấp phát vùng nhớ có kích thước là size.

void *calloc(size_t nitems, size_t size): Cấp phát vùng nhớ có kích thước là

nitems*size.

Ví d: Giả sử ta có khai báo:

int a, *pa, *pb; pa = (int*)malloc(sizeof(int)); /* Cấp phát vùng nhớ có kích

thước bằng với kích thước

của một số nguyên */

pb= (int*)calloc(10, sizeof(int)); /* Cấp phát vùng nhớ có thể chứa được 10 số

nguyên*/

Lưu ý: Khi sử dụng hàm malloc() hay calloc(), ta phải ép kiểu vì nguyên mẫu các

hàm này trả về con trỏ kiểu void.

b. Thu hồi vùng nhớ: Một vùng nhớ đã cấp phát cho biến động do biến con trỏ giữ

đ a chỉ, khi không còn sử dụng nữa, ta sẽ thu hồi lại vùng nhớ này nhờ hàm

free().

Cú pháp: void free(void *block)

Ý ngha: Giải phóng vùng nhớ được quản lý bởi con trỏ block.

Ví d: Ở ví dụ trên, sau khi thực hiện xong, thu hồi vùng nhớ cho 2 biến con trỏ pa

và pb như sau:

free(pa); free(pb);

----------------------- Page 85-----------------------

Chương 6: Các cấu trúc dữ

liệu khác

1. Kiểu cấu trúc(Structure): là kiểu dữ liệu bao gồm

nhiều thành phần có kiểu khác nhau, mỗi thành

phần được gọi là một trường (field)

a. Khai báo:

Cách 2: Sử dụng từ khóa

Cách 1: typedef để đ nh nghĩa kiểu:

struct <Tên cấu trúc> typedef struct

{ {

<Kiểu> <Trường 1> ; <Kiểu> <Trường 1> ;

<Kiểu> <Trường 2> ; <Kiểu> <Trường 2> ;

…….. ……..

<Kiểu> <Trường n> ; <Kiểu> <Trường n> ;

}; } <Tên cấu trúc>;

----------------------- Page 86-----------------------

1. Kiểu cấu trúc(tiếp)

struct svien typedef struct

{ {

char hoten[30]; char hoten[30];

char diachi[40]; char diachi[40];

float dtb; float dtb;

}; } sinhvien;

Khai báo biến:

struct svien sv1,sv2;

sinhvien sv3, sv4;

b. Truy xuất đến một trường của biến cấu trúc

Cách 1: <biến cấu trúc>.<tên trường>

Cách 2: <biến con trò đến cấu trúc> -> <tên trường>

----------------------- Page 87-----------------------

Ví dụ về kiểu cấu trúc

#include<conio.h>

#include<stdio.h>

#include<string.h>

typedef struct

{ unsigned char Ngay,Thang,Nam;

} NgayThang;

typedef struct

{ char MSSV[10];

char HoTen[40];

NgayThang NgaySinh;

int Phai;

char DiaChi[40];

} SinhVien;

/* Hàm in lên màn hình 1 mẩu tin SinhVien*/

void InSV(SinhVien s)

{

printf("%7s %20s %2d-%2d-%4d %s

",s.MSSV,s.HoTen,

s.NgaySinh.Ngay,s.NgaySinh.Thang,s.NgaySinh.Nam,s.DiaChi);

87 }

----------------------- Page 88-----------------------

Ví dụ về kiểu cấu trúc(tiếp)

int main()

{

SinhVien SV, s;

printf("Nhap MSSV: ");gets(SV.MSSV);

printf("Nhap Ho va ten: ");gets(SV.HoTen);

printf("Sinh ngay: ");scanf("%d",&SV.NgaySinh.Ngay);

printf("Thang: ");scanf("%d",&SV.NgaySinh.Thang);

printf("Nam: ");scanf("%d",&SV.NgaySinh.Nam);

printf("Gioi tinh (0: Nu), (1: Nam): ");scanf("%d",&SV.Phai);

flushall();

printf("Dia chi: ");gets(SV.DiaChi);

InSV(SV);

s=SV; /* Gán tr cho mẩu tin s*/

InSV(s);

getch();

return 0;

}

----------------------- Page 89-----------------------

Ví dụ về con trỏ đến kiểu cấu trúc

#include<conio.h>

#include<stdio.h>

typedef struct

{ unsigned char Ngay,Thang,Nam;

} NgayThang;

int main()

{

NgayThang Ng={25,2,2007};

NgayThang *p;

p=&Ng;

printf("Truy cap cau truc thong thuong %d-%d-%d

Ng.Ngay,Ng.Thang,Ng.Nam);

printf("Truy cap qua con tro %d-%d-%d

p->Ngay,p->Thang,p->Nam);

printf("Truy cap qua vung nho con tro %d-%d-%d

(*p).Ngay,(*p).Thang,(*p).Nam);

getch();

89 return 0;

}

----------------------- Page 90-----------------------

2. Kiểu tập tin

a. Khái niệm:

- Là kiểu dữ liệu cho phép lưu trữ dữ liệu ở bộ nhớ ngoài (đĩa). Khi kết thúc

chương trình thì dữ liệu vẫn còn do đó chúng ta có thể sử dụng nhiều lần.

- Ngoài ra, kiểu tập tin có thể có kích thước lớn với số lượng các phần tử

không hạn chế (chỉ b hạn chế bởi dung lượng của bộ nhớ ngoài).

– Biến tập tin: là một biến thuộc kiểu dữ liệu tập tin dùng để đại diện cho

một tập tin. Dữ liệu chứa trong một tập tin được truy xuất qua các thao

tác với thông số là biến tập tin đại diện cho tập tin đó.

– Con trỏ tập tin: Khi một tập tin được mở ra để làm việc, tại mỗi thời

điểm, sẽ có một v trí của tập tin mà tại đó việc đọc/ghi thông tin sẽ xảy ra.

Người ta hình dung có một con trỏ đang chỉ đến v trí đó và đặt tên nó là

con trỏ tập tin.

b. Khai báo:

FILE <Danh sách các biến con trỏ> ;

Ví dụ: FILE *f1,*f2;

----------------------- Page 91-----------------------

c. Các thao tác trên tập tin

+Mở tập tin

Cú pháp: FILE *fopen(char *Path, const char *Mode)

Trong đó:

- Path: chuỗi chỉ đường dẫn đến tập tin trên đĩa.

- Type: chuỗi xác đ nh cách thức mà tập tin sẽ mở.

Ví dụ: Mở một tập tin tên C:\BAITAP\VIDU.TXT để ghi.

FILE *f;

f = fopen(“C:\\BAITAP\\VIDU.TX”, “w”);

if (f!=NULL)

{

/* Các câu lệnh để thao tác với tập tin*/

/* Đóng tập tin*/

}

----------------------- Page 92-----------------------

Bảng các giá trị của Mode

Ch Ý ngha

r M tp tin vn bn c

w To ra tp tin vn bn mi ghi

a Ni vào tp tin vn bn

rb M tp tin nh phân c

wb To ra tp tin nh phân ghi

ab Ni vào tp tin nh phân

r+ M mt tp tin vn bn c/ghi

w+ To ra tp tin vn bn c ghi

a+ Ni vào hay to mi tp tin vn bn c/ghi

r+b M ra tp tin nh phân c/ghi

w+b To ra tp tin nh phân c/ghi

92 a+b Ni vào hay to mi tp tin nh phân

----------------------- Page 93-----------------------

c. Các thao tác trên tập tin

+ Hàm đóng tập tin: Hàm fclose() được dùng để đóng tập tin

được mở bởi hàm fopen(). Hàm này sẽ ghi dữ liệu còn lại

trong vùng đệm vào tập tin và đóng lại tập tin.

Cú pháp: int fclose(FILE *f)

+ Hàm kiểm tra đến cuối tập tin hay chưa?

Cú pháp: int feof(FILE *f)

Kiểm tra xem đã chạm tới cuối tập tin hay chưa và trả về

EOF nếu cuối tập tin được chạm tới, ngược lại trả về 0.

+ Hàm di chuyển con trỏ tập tin về đầu tập tin - Hàm rewind()

Khi ta đang thao tác một tập tin đang mở, con trỏ tập tin luôn

di chuyển về phía cuối tập tin. Muốn cho con trỏ quay về đầu

tập tin như khi mở nó, ta sử dụng hàm rewind().

Cú pháp: void rewind(FILE *f)

----------------------- Page 94-----------------------

d. Truy cập vào tập tin văn bản

+ Hàm ghi dữ liệu lên tập tin văn bản: Hàm putc()

Hàm này được dùng để ghi một ký tự lên một tập tin văn bản đang được mở để làm việc.

Cú pháp: int putc(int c, FILE *f)

Trong đó, tham số c chứa mã Ascii của một ký tự nào đó. Mã này được ghi lên tập tin liên kết

với con trỏ f. Hàm này trả về EOF nếu gặp lỗi.

+ Hàm này dùng để ghi một chuỗi ký tự chứa trong vùng đệm lên tập tin văn bản.

Cú pháp: int puts(const char *buffer, FILE *f)

Trong đó, buffer là con trỏ có kiểu char chỉ đến v trí đầu tiên của chuỗi ký tự được ghi vào. Hàm

này trả về giá tr 0 nếu buffer chứa chuỗi rỗng và trả về EOF nếu gặp lỗi.

Ví dụ: Viết chương trình ghi chuỗi ký tự lên tập tin văn bản C:\BAITHO.TXT

#include<stdio.h>

#include<conio.h>

int main()

{ FILE *f;

f=fopen(“C:\\BAITHO","r+");

if (f!=NULL) {

fputs(“Chi co thuyen moi hieu.

",f);

fputs(« Bien menh mong duong nao.",f);

fclose(f);

}

getch();

94 return 0;

}

----------------------- Page 95-----------------------

d. Truy cập vào tập tin văn bản(tiếp)

+ Hàm dùng để ghi dữ liệu có đ nh dạng lên tập tin văn bản.

Cú pháp: fprintf(FILE *f, const char *format, varexpr)

Trong đó: format: chuỗi đ nh dạng (giống với các đ nh dạng

của hàm printf()), varexpr: danh sách các biểu thức, mỗi biểu

thức cách nhau dấu phẩy (,).

+ Hàm dùng để đọc dữ liệu từ tập tin văn bản đang được mở để

làm việc.

Cú pháp: int getc(FILE *f)

Hàm này trả về mã Ascii của một ký tự nào đó (kể cả EOF)

trong tập tin liên kết với con trỏ f.

+ Hàm đọc dữ liệu từ tập tin văn bản vào danh sách các biến theo

đ nh dạng.

Cú pháp: fscanf(FILE *f, const char *format, varlist)

Trong đó: format: chuỗi đ nh dạng (giống hàm scanf());

varlist: danh sách các biến mỗi biến cách nhau dấu phẩy (,).

----------------------- Page 96-----------------------

Ví dụ

Viết chương trình chép tập tin C:\BAITHO.TXT ở trên sang tập tin D:\BAIHAT.TXT.

#include<stdio.h>

#include<conio.h>

int main()

{ FILE *f1,*f2;

f1=fopen(“C:\\BAITHO.TXT","rt");

f2=fopen("D:\\BAIHAT.TXT","wt");

if (f1!=NULL && f2!=NULL)

{

int ch=fgetc(f1);

while (! feof(f1))

{

fputc(ch,f2);

ch=fgetc(f1);

}

fcloseall();

}

getch();

96 return 0;

}

----------------------- Page 97-----------------------

e. Truy cập vào tập tin nhị phân

+ Hàm ghi dữ liệu lên tập tin nh phân - Hàm fwrite()

Cú pháp: size_t fwrite(const void *ptr, size_t size, size_t n, FILE *f)

Trong đó:

- ptr: con trỏ chỉ đến vùng nhớ chứa thông tin cần ghi lên tập tin.

- n: số phần tử sẽ ghi lên tập tin.

- size: kích thước của mỗi phần tử.

- f: con trỏ tập tin đã được mở.

- Giá tr trả về của hàm này là số phần tử được ghi lên tập tin. Giá tr này bằng n trừ

khi xuất hiện lỗi.

+Đọc dữ liệu từ tập tin nh phân - Hàm fread()

Cú pháp: size_t fread(const void *ptr, size_t size, size_t n, FILE *f)

Trong đó:

- ptr: con trỏ chỉ đến vùng nhớ sẽ nhận dữ liệu từ tập tin.

- n: số phần tử được đọc từ tập tin.

- size: kích thước của mỗi phần tử.

- f: con trỏ tập tin đã được mở.

- Giá tr trả về của hàm này là số phần tử đã đọc được từ tập tin. Giá tr này bằng n

hay nhỏ hơn n nếu đã chạm đến cuối tập tin hoặc có lỗi xuất hiện..

----------------------- Page 98-----------------------

e. Truy cập vào tập tin nhị phân(tiếp)

+ Hàm di chuyển con trỏ tập tin - Hàm fseek()

- Việc ghi hay đọc dữ liệu từ tập tin sẽ làm cho con trỏ tập tin d ch chuyển

một số byte, đây chính là kích thước của kiểu dữ liệu của mỗi phần tử của

tập tin.

- Khi đóng tập tin rồi mở lại nó, con trỏ luôn ở v trí ngay đầu tập tin.

Nhưng nếu ta sử dụng kiểu mở tập tin là “a” để ghi nối dữ liệu, con trỏ tập

tin sẽ di chuyển đến v trí cuối cùng của tập tin này.

- Ta cũng có thể điều khiển việc di chuyển con trỏ tập tin đến v trí chỉ đ nh

bằng hàm fseek().

Cú pháp: int fseek(FILE *f, long offset, int whence)

Trong đó:

- f: con trỏ tập tin đang thao tác.

- offset: số byte cần d ch chuyển con trỏ tập tin kể từ v trí trước đó. Phần tử đầu tiên

là v trí 0.

- whence: v trí bắt đầu để tính offset, ta có thể chọn điểm xuất phát là:

0 SEEK_SET V trí đầu tập tin

1 SEEK_CUR V trí hiện tại của con trỏ tập tin

2 SEEK_END V trí cuối tập tin

- Kết quả trả về của hàm là 0 nếu việc di chuyển thành công. Nếu không thành công,

98 1 giá tr khác 0 (đó là 1 mã lỗi) được trả về.

Bạn đang đọc truyện trên: Truyen2U.Pro

Trước Sau