Bai giang ngon ngu lap trinh C.PPT

Trường đại học bách khoa hà nội
Ngôn ngữ lập trình C
Người soạn: Nguyễn Quang Huy
12/2000


Chương 1
Cơ bản về ngôn ngữ c
Tổng quan về ngôn ngữ C
Cấu trúc chung của một chương trình C
Các thành phần cơ bản của ngôn ngữ
Các kiểu dữ liệu cơ bản
Các cấu trúc lệnh cơ bản trong C
Vào ra trong C



Tổng quan về ngôn ngữ c

Do B.W.Kerninghan & D.M.Ritchie (1970) phát triển tại Bell lab.
Tại sao lại sử dụng C?
NNLT vạn năng.
Tính khả chuyển (portability).
Độ thích nghi cao, tính mềm dẻo, NNLT chuyên nghiệp.
Tính hiệu quả.


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


#include
#include

/* Chương trình chính */
void main()
{
printf("Hello, world! ");
/* Đợi ấn một phím */
getch();
}

Phần dẫn hướng biên dịch
Phần khai báo
Phần chương trình chính
Các thành phần cơ bản của ngôn ngữ


Bộ chữ viết:
phân biệt chữ hoa và chữ thường
Tên:
quy tắc đặt tên
Từ khoá: asm, break, case, char, const, continue, if, ...
Các kiểu dữ liệu cơ bản
Các biến
Các hằng
Biểu thức

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


Kiểu Phạm vi Kích thước
char 0 .. 255 1 byte
int -32768 .. 32767 2 bytes
long -2147483648 .. 2147484647 4 bytes
unsigned 0 .. 65535 2 bytes
float 3.4e-38 .. 3.4e+38 4 bytes
double 1.7e-308 .. 1.7e+308 8 bytes


Khai báo biến


[ = ];

Giá trị của biến có thể được khởi gán khi khai báo.
Ví dụ:
int i, j;
float f;
char ch, ch1 = `A`, ch2 = ` `;
double eps = 1E-6;

Khai báo hằng


Hằng tượng trưng:
#define
Ví dụ:
#define MAX 100;
#define ECHO "DHBK Hanoi"
Hằng biến:
const =;
Ví dụ:
const long MAX = 100L;
const char ECHO[30] = "DHBK Hanoi";


Biểu thức (1/5)


Các phép toán số học: +, -, *, /, %, -
Các phép toán quan hệ: >, <, >=, <=, ==, !=
Các phép toán logic: &&, ||, !
Các phép toán thao tác bit: &, |, ^, <<, >>, ~
Thao tác số học
Thao tác logic
Phép toán tăng giảm: ++, --
Phân biệt ++n; và n++;

Biểu thức (2/5)


Toán tử gán:
= ;
Biểu thức gán:
=
Ví dụ: int a = b = 5;
Biểu thức gán rút gọn:
=
=
Ví dụ: i = i + exp; --> i += exp;

Biểu thức (3/5)


Biểu thức điều kiện:
Bt1 ? Bt2 : Bt3
Ví dụ:
max = (a>b) ? a : b;
Phép toán lấy địa chỉ biến:
&
Ví dụ:
int n;
scanf("%d",&n);

Biểu thức (4/5)


Chuyển đổi kiểu tự động:
char -> int -> long -> float -> double -> long double
Phép toán chuyển đổi kiểu:
()
Ví dụ:
int n = (int) 10.24;
Thứ tự ưu tiên của các toán tử:

Biểu thức (5/5)


Toán tử Thứ tự kết hợp
(), [], -> Trái sang phải
~, ++, --, (type) Phải sang trái
*, /, % Trái sang phải
+, - Trái sang phải
<<, >> Trái sang phải
<, <=, >, >= Trái sang phải
& Trái sang phải
| Trái sang phải
^ Trái sang phải
&& Trái sang phải
|| Trái sang phải
==, !=, +=, -= Phải sang trái

Các cấu trúc lệnh cơ bản trong C


Câu lệnh đơn: ;
Câu lệnh ghép: {...}
Cấu trúc tuần tự
Cấu trúc điều kiện
Cấu trúc lặp

Cấu trúc điều kiện (1/2)


Câu lệnh if :
if (Biểu thức) ;
hoặc:
if (Biểu thức) ;
else ;
Ví dụ:
if (a else max=a;

Cấu trúc điều kiện (2/2)


Câu lệnh SWITCH :
switch (Biểu_thức_nguyên){
case N1 : Lenh1;
case N2 : Lenh2;
...
[default : Lenh;]
}
Ví dụ:
switch (ch){
case 1 :
case 2 : printf("1 ou 2"); break;
case 3 : printf("3"); break;
default : printf("greater than 3");
}

Cấu trúc lặp (1/3)


Câu lệnh FOR:
for ( Bt1; Bt2; Bt3 ) Lenh;

Ví dụ: tính N!

long Gt,i,N;
...
Gt = 1;
for (i=1; i<=N; i++)
Gt *= i;

Cấu trúc lặp (2/3)


Câu lệnh WHILE:
while () Lenh;

Ví dụ: đọc một dãy 20 số nguyên từ bàn phím
int day[20];
int chiso = 0;
while (chiso<20)
{
printf(" So thu %d :",chiso);
scanf("%d",&day[chiso]);
chiso++;
}

Cấu trúc lặp (3/3)


Câu lệnh DO WHILE :
do Lenh1;
while ();

Ví dụ: Tính tích vô hướng của hai vectơ X,Y:
int X[MAXL], Y[MAXL], chiso=0;
tichvohuong = 0;
do {
tichvohuong += X[chiso]*Y[chiso];
} while (++chiso < MAXL);

Vào ra trong C (1/5)


Vào ra qua các kênh xuất/nhập (I/O streams):
Giá trị --> Kênh xuất --> Khuôn dạng --> Thiết bị ra
Thiết bị vào --> Kênh vào --> Khuôn dạng --> Biến
Thư viện các hàm vào ra: stdio.h và conio.h
#include
#include
Hàm printf() và scanf()

Vào ra trong C (2/5)


Hàm printf():
printf( [,, ...] );
: xâu định dạng
: các tham số tương ứng
Ví dụ:
printf("n = %d ", -10); /* --> -10 */
printf("n = %u ", -10); /* --> 65526 */
printf("A : %4c ", `A`); /* --> A */
printf("A : %d ", `A`); /* --> 65 */
printf("f = %4.2f", 123.4); /* --> 123.40 */

Vào ra trong C (3/5)


Định dạng Kiểu Ghi chú
%d int Só nguyên
%i int Hệ 10 có dấu
%o int Hệ 8 không dấu
%u int Số nguyên không dấu
%x int Hệ 16 không dấu
%X int Hệ 16 không dấu
%e, %E float, double Dấu chấm động
%f, %lf float, double Dấu phẩy tĩnh
%g. %G float, double Dấu phẩy tĩnh hoặc động
%c char Ký tự
%s char * Xâu ký tự

Vào ra trong C (4/5)


Hàm scanf():
scanf(, {

, ...} );
: xâu định dạng
< address>: địa chỉ của các tham số tương ứng
Ví dụ:
int n;
long l;
float f;
double d;
printf("Nhập các giá trị cho các biến n,l,f,d:");
scanf("%d%ld%f%lf", &n, &l, &f, &d);
Vào ra trong C (5/5)


Định dạng Kiểu Ghi chú
%d int Só nguyên
%o int Hệ 8 không dấu
%x int Hệ 16 không dấu
%c char Ký tự
%s char * Xâu ký tự
%f float
%lf double
%ld long



Ví dụ 1 : Tính tổng hai số


#include
int main()
{
int a, b, c;
printf("Enter the first value:");
scanf("%d", &a);
printf("Enter the second value:");
scanf("%d", &b);
c = a + b;
printf("%d + %d = %d ", a, b, c);
return 0;
}




Ví dụ 2 : Đổi nhiệt độ


#include
int main()
{
int a = 0;
while (a <= 100)
{
printf("%4d degrees F = %4d degrees C ",
a, (a - 32) * 5 / 9);
a += 10;
}
return 0;
}
Ví dụ 2 : Đổi nhiệt độ (t.)

0 degrees F = -17 degrees C
10 degrees F = -12 degrees C
20 degrees F = -6 degrees C
30 degrees F = -1 degrees C
40 degrees F = 4 degrees C
50 degrees F = 10 degrees C
60 degrees F = 15 degrees C
70 degrees F = 21 degrees C
80 degrees F = 26 degrees C
90 degrees F = 32 degrees C
100 degrees F = 37 degrees C

Ví dụ 2 : Đổi nhiệt độ (t.)

#include
int main()
{
float a = 0;
while (a <= 100)
{
printf("%6.2f degrees F = %6.2f degrees C ",
a, (a - 32.0) * 5.0 / 9.0);
a += 10;
}
return 0;
}

Ví dụ 2 : Đổi nhiệt độ (t.)

0.00 degrees F = -17.78 degrees C
10.00 degrees F = -12.22 degrees C
20.00 degrees F = -6.67 degrees C
30.00 degrees F = -1.11 degrees C
40.00 degrees F = 4.44 degrees C
50.00 degrees F = 10.00 degrees C
60.00 degrees F = 15.56 degrees C
70.00 degrees F = 21.11 degrees C
80.00 degrees F = 26.67 degrees C
90.00 degrees F = 32.22 degrees C
100.00 degrees F = 37.78 degrees C

Ví dụ 3: Giải phương trình bậc nhất một ẩn :
#include
#include
void main(void)
{ float a,b;
/* doc du lieu tu ban phim */
printf(" Nhap hai so A,B :");
scanf("%f %f2",&a,&b);
/* giai phuong trinh */
if (a==0)
if (b==0)
printf("Phuong trinh co vo so nghiem! ");
else
printf("Phuong trinh vo nghiem ");
else
printf("Phuong trinh co nghiem la : x=%f ",-b/a);
printf("An phim bat ky de ket thuc ...");
getch();
}
Chương 2
Hàm trong C
Khai báo hàm
Phạm vi của biến
Truyền tham số
Đệ qui

Khai báo hàm
[] ([])
[]
{


...
return ;
...
}
Ví dụ:
float fct1(a,b)
int a, float b;
{...}
fct2(float x, char c) {...}
void toto(int n); {...}
Trả về giá trị của hàm
Khai báo hàm (t.)
Ví dụ 1: Hàm fact() tính giai thừa n!:
long fact(int n)
{
long i,gt = 1;
for(i=1; i<=n; i++)
gt *= i;
return gt;
}
...
long t = fact(10);


Khai báo hàm (t.)
Ví dụ 2: Hàm rand() sinh một số ngẫu nhiên từ 0 đến 32767:

int r-seed = 10;
...
int rand()
/* from K&R
- produces a random number between 0 and 32767.*/
{
r_seed = r_seed * 1103515245 +12345;
return (unsigned int)(r_seed / 65536) % 32768;
}
...
int n = rand();
if (rand() > 100) {...}


Tham số của hàm
Truyền theo tham trị
Hai kiểu tham số: tham số thực và tham số con trỏ.
Làm thế nào để sử dụng tham biến? -> sử dụng con trỏ!
void swap(a,b)
float* a, float* b;
{ float tmp;
tmp = (*a);
(*a) = (*b);
(*b) = tmp;
}
...
swap(&x, &y);

Tham số của hàm (tiếp)
Tham số của hàm main:
void main() {...}
main(int argc, char *argv[]) {...}
Ví dụ: In ra các tham số dòng lệnh
#include
main (int argc, char *argv[]) {
int i;
for (i=0; i printf("Tham so thu %d la: %s ",i+1, argv[i]);
}
Hàm nguyên mẫu (prototype)
Báo cho trình dịch biết kiểu trả về; số lượng, kiểu và thứ tự các tham số của hàm
Nếu không có hàm nguyên mẫu, trình dịch sẽ tự động tạo ra nguyên mẫu hàm khi gặp hàm lần đầu tiên.

Ví dụ:
float fct1(int, float);
int fct2(float, char);
int atoi(char*);
void swap(float*, float*);

Tệp tiêu đề (header file)
Chứa các khai báo (hằng, biến, kiểu)
Chứa các nguyên mẫu hàm.
Được tải vào trong tệp thi hành (implementation file) bằng lệnh: #include <...>

Ví dụ: Một số thư viện thông dụng
stdio.h
conio.h
stdlib.h
string.h
math.h
Cấp lưu trữ và phạm vi biến
Phạm vi sử dụng (scope): local, global
Thời gian tồn tại (life time)
Cấp lưu trữ (storage class)
Cấp lưu trữ động và phạm vi cục bộ:
auto (mặc định)
register
Cấp lưu trữ tĩnh và phạm vi toàn cục:
static
extern
Cấp lưu trữ và phạm vi biến
Ví dụ:
#include
void foo();
void main() {
int i;
clrscr();
for (i=1; i<=10; i++)
foo();
}
void foo() {
static int count = 1;
printf("Count = %d ", count++);
}
Count = 1
Count = 2
Count = 3
Count = 4
Count = 5
Count = 6
Count = 7
Count = 8
Count = 9
Count = 10
Đệ quy
C cung cấp khả năng đệ quy cho các hàm thông qua lời gọi đến chính nó.

Ví dụ: Tính giai thừa

long fact(int n)
{
if(n=0) return(1);
else return(fact(n-1)*n);
}
Chương 3
các kiểu dữ liệu Có cấu trúc
Kiểu con trỏ (pointer)
Kiểu mảng (array)
Kiểu xâu ký tự (string)
Kiểu cấu trúc (struct)
Kiểu hợp (union)
Kiểu tệp (file)
Kiểu con trỏ (1/6)
Con trỏ là biến dùng để chứa địa chỉ của biến khác.
Con trỏ trong C được sử dụng để:
Tạo các cấu trúc dữ liệu động (từ heap)
Truyền tham biến trong các hàm
Truy nhập đến các phần tử của mảng
Tham chiếu đến biến khác

Kiểu con trỏ (2/6)
Khai báo con trỏ:
* ;
Ví dụ:
int * pi = NULL;
char * pchar;
Hằng NULL.
Toán tử & và *:
&
*
Ví dụ:
int n = 10;
int *pi = &n;
*pi = 20;
Kiểu con trỏ (3/6)
Phép gán hai con trỏ cùng kiểu:
Ví dụ:
int n, *pi = &n, *qi;
qi = pi;
Hai con trỏ khác kiểu: phải ép kiểu!
Ví dụ:
int *pi;
float *pf;
...
qf = pi; // ERROR!
qf = (float *)pi; // OK
Kiểu con trỏ (4/6)
Phép cộng con trỏ với số nguyên:
Ví dụ:
int n = 0x0102, *pi = &n;
char *pc = (char *)pi;
printf("%d",*pc); // 2
printf("%d",*(pc+1)); // 1
Phép trừ hai con trỏ cùng kiểu:
Ví dụ:
int m = 5 n = 30;
int *pi = &m, *qi = &n;
printf("%d",qi-pi); // 1
Các phép so sánh các con trỏ cùng kiểu.
Kiểu con trỏ (5/6)
Con trỏ void*: là con trỏ có thể nhận địa chỉ của bất kỳ vùng nhớ nào.
Ví dụ:
void *px, *py;
int n = 1;
float x = 0.5;
px = &n;
py = &x;
Không thể thực hiện các phép tính số học trên con trỏ void


Kiểu con trỏ (6/6)
Con trỏ hàm: trỏ tới điểm xâm nhập của hàm.
[Kiểu_trả_về] (*con_trỏ_hàm) [ds_tham_số]);
Ví dụ:
long (*fact_ptr)(int);
Lời gọi hàm gián tiếp qua con trỏ hàm:
Ví dụ:
fact_ptr = fact;
printf("%ld",fact_ptr(10));
Dùng con trỏ hàm làm tham số hình thức của hàm:
Ví dụ:
void sapXep(int *a, int (*cmp)(int, int)) {
...
if (cmp(a[i],a[j])) {
...
}
Kiểu mảng (1/3)
Khai báo mảng một chiều:
Kiểu biến_mảng[số phần tử];
Ví dụ:
int a[100];
float x[1000];
Khởi gán các phần tử của mảng:
Ví dụ:
int a[5] = {1,2,3,4,5};
float b[] = {0.5, 1.1, 3.2, 4.0};
Khai báo mảng nhiều chiều:
Kiểu biển_mảng[NO1][NO2]...;
Ví dụ:
int a[10][10];
float x[255][255];
Kiểu mảng (2/3)
Truy nhập vào các phần tử của mảng:
biến_mảng[chỉ số]
Ví dụ:
a[0]=1;
Sử dụng mảng làm tham số cho hàm: dùng con trỏ!
Ví dụ:
void tong(int *);
Con trỏ và mảng: ta có thể sử dụng tên của một mảng như con trỏ và ngược lại:
int a[100], *pi = a;
(pi+i) ? &a[i]
*(pi+i) ? a[i]
Ví dụ:
Kiểu mảng (3/3): Example
#include
#define SOPHANTU 3
main(){
int list[SOPHANTU] = {239,241,159} ,i;
printf(“cac dia chi la:”);
for(i=0; i < SOPHANTU; i++)
printf(“%4p”,&list[i]);
printf(“ chua cac gia tri:”);
for(i=0; i < SOPHANTU; i++)
printf(“%4d”,list[i]));
printf(“ ”);
}
cac dia chi la: 163A 163C 163E
chua cac gia tri: 239 241 159
Kiểu xâu ký tự (1/3)
Xâu ký tự là một trường hợp đặc biệt của mảng khi kiểu phần tử của mảng là char.
Ví dụ:
char sentence[40];
char chao[] = "Hello !";
Ký tự kết thúc xâu ``
Con trỏ char*:
Ví dụ:
char *pstr;
char *pstr2 = "Hello !";
Không có các toán tử trên xâu!
char chao[] = "Hello !";
char *pstr = chao; // chỉ là phép gán con trỏ!
Các hàm xử lý xâu nằm trong thư viện

Kiểu xâu ký tự (2/3)
Một số hàm xử lý xâu thông dụng:
int strlen(char *st);
void strcpy(char *des,char src);
void strncpy(char *des, char *src, unsigned n);
void strcat(char *st1, const char *st2,unsigned n );
int strcmp(char *st1, char *st2);
int strncmp(char *st1, char *st2,unsigned n);
int stricmp(char *st, char ch);
char *strrchr(char *st, char ch);

Kiểu xâu ký tự (3/3): Example
Ví dụ : Hàm atoi() sau tính giá trị nguyên của một xâu ký tự biểu diễn một số:
atoi(s)
char s[];
{
int i,n = 0;
for(i=0; s[i]>=`0` && s[i]<=`9`; i++)
n=10*n+s[i]-`0`;
return n;
}
...
int n = atoi("123");


Kiểu cấu trúc (1/5)
Khai báo cấu trúc:
struct Tên_kiểu {
/* khai báo các trường ở đây */
Kiểu tên_trường;
...
} tên_biến;
Ví dụ:
struct Address {
char name[30];
unsigned int number;
char street[40];
char city[20];
} addr;
Kiểu cấu trúc (2/5)
Khai báo biến cấu trúc:
struct Tên_kiểu tên_biến;
Ví dụ:
struct Address addr1, addr2;
Khai báo cấu trúc với typedef:
#typedef struct Tên_kiểu Tên_kiểu_mới
Ví dụ:
#typedef struct Address TAddress;
TAddress addr1, addr2;
Kiểu cấu trúc (3/5)
Truy nhập tới các trường trong cấu trúc:
tên_biến.tên_trường
Ví dụ:
strcpy(addr.name,"Nguyen Van A");
addr.number = 100;
Trường hợp con trỏ cấu trúc:
Ví dụ:
TAddress *pAddr;
...
(*pAddr).number = 100;
pAddr->number = 100;
Kiểu cấu trúc (4/5)
Cấu trúc thường được dùng để xây dựng một bảng các cấu trúc:
Ví dụ:
TAddress addrs[50];
Cấu trúc được sử dụng trong các danh sách móc nối:
struct Simple {
TAddress addr;
struct Simple *next;
};
Kiểu cấu trúc (5/5)
Cấu trúc bit:
struct Tên_kiểu {
/* khai báo các trường ở đây */
...
tên_trường : độ_dài;
...
};
Ví dụ:
struct Person {
char name[50];
unsigned short age:6; // 0..64
int sex:1; // 0..1
};
Kiểu hợp (1/2)
Khai báo kiểu hợp :
union Tên_kiểu {
type_1 trường_1 : độ_rộng_1;
type_2 trường_2 : độ_rộng_2;
...
} tên_biến;

Các trường đều có cùng địa chỉ
Kích thước của hợp là kích thước của trường dài nhất
Các thao tác trên hợp cũng giống như trên cấu trúc.

Kiểu hợp (2/2)
Ví dụ:
union Registers {
struct WORDREGS {
unsigned int ax,bx,cx,dx,si,di,cflag,flags;
} x;
struct BYTEREGS {
unsigned char al,ah,bl,bh,cl,ch,dl,dh;
} h;
};
...
union Registers reg;
reg.h.ah = 1;
reg.x.cx = 15;
Kiểu tệp
Trong C có hai loại tệp: tệp nhị phân và tệp văn bản
Khai báo tệp: con trỏ tệp
FILE *fp;
Các thao tác trên tệp:
Hệ thống vào ra mức 2 (mức cao) : làm việc qua các kênh vào/ra.
Hệ thống vào ra mức 1 (mức thấp) : làm việc qua các thẻ tệp.

Kiểu tệp : Hệ thống vào ra mức 2
fopen(): mở một tệp tin :
FILE *fopen(char *filename,char *mode);
Các chế độ mở tệp:
"r" "rb" "rt" "r+b" "r+t"
"w" "wb" "wt" "w+b" "w+t"
"a" "ab" "at" "a+b" "a+t"
Ví dụ:
fp=fopen("exercise","w");
fclose(): đóng tệp tin đã được mở trước đó bởi fopen():
int fclose(FILE *fp);
Kiểu tệp : Hệ thống vào ra mức 2
Một số hàm cơ bản :
putc()
getc()
fseek()
fprintf()
fscanf()
fflush()
feof()
ferror()
rewind()


Hệ thống vào ra mức 2: Example
Ví dụ: Tạo tệp backup của autoexec.bat:

#include

int main(void)
{
FILE *in, *out;
if ((in = fopen("\AUTOEXEC.BAT", "rt")) == NULL)
{
fprintf(stderr, "Cannot open input file. ");
return 1;
}

Hệ thống vào ra mức 2: Example (t.)
if ((out = fopen("\AUTOEXEC.BAK", "wt")) == NULL)
{
fprintf(stderr, "Cannot open output file. ");
return 1;
}

while (!feof(in))
fputc(fgetc(in), out);
fclose(in);
fclose(out);
return 0;
}

Kiểu tệp : Hệ thống vào ra mức 1
Một số hàm cơ bản :
read()
write()
open()
close()
lseek()


Hệ thống vào ra mức 1: Example
Ví dụ: Tạo một tệp văn bản bằng hàm open

#include
#include
#include
#include

int main(void)
{
int handle;
char msg[] = "Hello world";

Hệ thống vào ra mức 1: Example (t.)
if ((handle = open("TEST.$$$", O_CREAT | O_TEXT)) == -1)
{
perror("Error:");
return 1;
}
write(handle, msg, strlen(msg));
close(handle);
return 0;
}

END
Thank you!