LT C,C++
----------------------- 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
1
----------------------- 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
2
----------------------- 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.
4
----------------------- 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.
5
----------------------- 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
6
----------------------- 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 //
7
----------------------- 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*/
/*VIDU.CPP*/
#include <stdio.h>
#include <stdio.h>
int main()
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;
return 0;
}}
Báo CT kết thúc cho HĐH
Báo CT kết thúc cho HĐH
8
----------------------- 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 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);
scanf("%d %d", &a, &b);
printf("%d - %d = %d
", a, b, a - b);
printf("%d - %d = %d
", a, b, a - b);
getch();
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
Nhap 2 so nguyen: 21 17
21 - 17 = 4
21 - 17 = 4
9
----------------------- 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.
10
----------------------- 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
11
----------------------- 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
12
----------------------- 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)
13
----------------------- 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)
14
----------------------- 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)
15
----------------------- 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.
16
----------------------- 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 đó.
17
----------------------- 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
18
----------------------- 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;
}
19
----------------------- 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
20
----------------------- 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
21
-
----------------------- 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>
#include <stdio.h>
intmain(void)
intmain(void)
{
{
const long double pi = 3.141592653590L;
const long double pi = 3.141592653590L;
const t = 7;
const t = 7;
const heso = 9.123;
Lỗi const heso = 9.123;
Lỗi
days_in_week = 5;
days_in_week = 5;
return 0;
return 0;
}
}
22
----------------------- 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)
23
----------------------- 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
\’ ‘
\” “
\\ \
24
----------------------- 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’
25
----------------------- 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>
#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
#defineSUNDAY 0
int day = SUNDAY;
int day = SUNDAY;
26
----------------------- 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.
27
----------------------- 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
28
----------------------- 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
30
----------------------- 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:
<bin> <toán t>= <biu thc>
tương đương:
<bin> = <bin> <toán t> <biu thc>
a += 27; f /= 9.2; i *= j + 2;
a += 27; f /= 9.2; i *= j + 2;
a = a + 27; f = f / 9.2; i = i * (j + 2);
a = a + 27; f = f / 9.2; i = i * (j + 2);
31
----------------------- 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
32
----------------------- 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;
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 = f / g;
h = i / j;
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 }
}
33
----------------------- 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;
int i = 5, j = 4;
“i” 6
i ++;
“j” 3 i ++;
-- j;
-- j;
“i” 7
++ i;
++ i;
34
----------------------- 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;
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++;
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 main(void)
{
{
int i = 5, j = 4;
int i = 5, j = 4;
doublef;
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);
f = (double)(i / j);
return 0;
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;
int i, j = 10, k = 28;
i = ((j > 5) && (k < 100)) || (k > 24);
i = ((j > 5) && (k < 100)) || (k > 24);
38
----------------------- 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
39
----------------------- 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>
#include <stdio.h>
int main(void)
int main(void)
{
{
long big;
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;
int i, j = 100, k = -1; int i, j = 100, k = -1;
i = (j > k) ? j : k; i = (j < k) ? j : k;
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;
41
----------------------- 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.
42
----------------------- 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.
43
----------------------- 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>
#include <stdio.h>
int main(void)
int main(void)
{
{
int j = 3 * 4 + 48 / 7;
int j = 3 * 4 + 48 / 7;
printf("j = %i
", j);
printf("j = %i
", j);
return 0;
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
* / %
+ -
<< >>
< <= >= >
== !=
&
^
&&
?:
= += -= *= /= %= …
45
----------------------- Page 46-----------------------
Ví dụ
#include <stdio.h>
#include <stdio.h>
int main(void)
int main(void)
{
{
int i = 0, j, k = 7, m = 5, n;
int i = 0, j, k = 7, m = 5, n;
j = m += 2;
j = m += 2;
printf("j = %d
", j);
printf("j = %d
", j);
j = k++ > 7;
j = k++ > 7;
printf("j = %d
", j);
printf("j = %d
", j);
j = i == 0 & k;
j = i == 0 & k;
printf("j = %d
", j);
printf("j = %d
", j);
n = !i > k >> 2;
n = !i > k >> 2;
printf("n = %d
", n);
printf("n = %d
", n);
return 0;
return 0;
}
}
46
----------------------- 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
47
----------------------- 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)
%G
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.
48
----------------------- 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
49
----------------------- 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)
50
----------------------- 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
51
----------------------- 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ụ
T
Bthức ĐK if (delta > 0)
F {
Lệnh S
x1 = (-b + sqrt(delta))/2/a;
x2 = (-b - sqrt(delta))/2/a;
}
52
----------------------- 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);
F
if (a !=0 )
T
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
No
Yes
No
S1 S2
54
----------------------- 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
55
----------------------- 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
58
----------------------- 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)
F
59
----------------------- 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.
S
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
F
61
----------------------- 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;
do
{
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
64
----------------------- 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
66
----------------------- 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>;]
}
68
----------------------- 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 ?
69
----------------------- 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;
}
71
----------------------- 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).
72
----------------------- 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]);
73
}
----------------------- 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]
74
----------------------- 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.
75
----------------------- 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ớ
79
----------------------- 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
82
----------------------- 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);
84
----------------------- 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>;
85
----------------------- 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>
86
----------------------- 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;
}
88
----------------------- 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;
90
----------------------- 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*/
}
91
----------------------- 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)
93
----------------------- 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 (,).
95
----------------------- 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..
97
----------------------- 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: Truyen247.Pro