Bai giang Co So Lap Trinh docx

Bài giảng: Cơ sở lập trình
===================================================================
MỤC LỤC
===================================================================
Giảng viên: Hoàng Thị Vân Anh – Khoa: Tin học kinh tế 1
Bài giảng: Cơ sở lập trình
===================================================================
CHƯƠNG I: TỔNG QUAN VỀ NGÔN NGỮ LẬP TRÌNH C
I. GIỚI THIỆU NGÔN NGỮ LẬP TRÌNH
1. Các khái niệm chương trình, lập trình, lập trình viên
- Chương trình: là tập hợp dãy các lệnh điều khiển máy tính thực hiện.
- Lập trình (máy tính): là kỹ thuật cài đặt một hoặc nhiều thuật toán trừu tượng có liên
quan với nhau bằng một hoặc nhiều ngôn ngữ lập trình để tạo ra một chương trình máy
tính.
- Lập trình viên: Là người viết chương trình máy tính.
2. Sự phát triển của các công cụ lập trình.
3. Một số ngôn ngữ lập trình thông dụng.
4. Giới thiệu về ngôn ngữ lập trình C
- Ngôn ngữ C do Dennis Ritchie sáng tác năm 1972 tại phòng thí nghiệm Bell
Telephone (thuộc công ty viễn thông AT & T của Mĩ) để viết hệ điều hành UNIX.
* ưu điểm của ngôn ngữ C:
- C là ngôn ngữ mạnh và mềm dẻo.
- C được dùng phổ biến.
- C là ngôn ngữ có thể chuyển dịch, dễ thích nghi
- C là ngôn ngữ ít từ khoá.
- C là ngôn ngữ có cấu trúc modun: Các chương trình con là các hàm có thể được sử
dụng nhiều lần trong cùng một chương trình hoặc trong các chương trình khác.
* Khuyết điểm của ngôn ngữ C:
- Cú pháp khó học (nếu chưa hiểu rõ bản chất).
- Một số ký hiệu có nhiều nghĩa khác nhau: Ví dụ kí hiệu * là toán tử nhân, toán tử
không định hướng, toán tử thay thế,

* Cách khởi động C
Vào thư mục Bin trong thư mục cài đặt TC => chạy tệp TC.exe
===================================================================
Giảng viên: Hoàng Thị Vân Anh – Khoa: Tin học kinh tế 2
Bài giảng: Cơ sở lập trình
===================================================================
Chú ý: Khi màn mình làm việc của C hiển thị, muốn chương trình chạy được, ta cần
thiết lập lại một vài thông số cho phù hợp (chỉ cần cài đặt một lần đầu tiên):
Vào menu Options/ Environment/ Directories

Include Directories: Thư mục chứa các tệp tin mà chúng ta gọi trong chương trình (tệp
tin .h viết sau #include)
Library Directories: Thư mục chứa các tệp tin thư viện (*.Lib)
Output Directories: Thư mục chứa các tệp tin “đối tượng” (*.OBJ), tệp tin *.exe sau
khi biên dịch.
Source Directory: Thư mục chứa các tệp tin “nguồn” (*.OBJ, *.Lib)
* Chạy chương trình: Ấn Ctrl + F9
II. Các khái niệm cơ bản
1. Các yếu tố cơ bản
1.1 Bộ chữ viết trong C
Bộ chữ viết trong ngôn ngữ C bao gồm những ký tự, ký hiệu sau: (phân biệt chữ
in hoa và in thường):
􀂃26 chữ cái latinh lớn A,B,C Z
􀂃26 chữ cái latinh nhỏ a,b,c z.
􀂃10 chữ số thập phân 0,1,2 9.
􀂃Các ký hiệu toán học: +, -, *, /, =, <, >, (, )
􀂃Các ký hiệu đặc biệt: :. , ; " ' _ @ # $ ! ^ [ ] { }
􀂃Dấu cách hay khoảng trống.
1.2 Các từ khoá trong C
Từ khóa là các từ dành riêng (reserved words) của C mà người lập trình có thể sử

dụng nó trong chương trình tùy theo ý nghĩa của từng từ.
===================================================================
Giảng viên: Hoàng Thị Vân Anh – Khoa: Tin học kinh tế 3
Phần soạn nội
dung chương
trình
Thanh
menu
Bài giảng: Cơ sở lập trình
===================================================================
auto break case char continue default do
double else extern float for goto if int
long register return
short sizeof static struct switch typedef union
unsigned void volatile while
_cs _ds _es _ss
_AH _AL _AX _BH _BL _BX
_CH _CL _CX _DH _DL _DX
_BP _DI _SI _SP
1.3 Chú thích
- Tác dụng: chú thích cho một câu lệnh hay một đoạn chương trình đã viết. Dòng
chú thích này sẽ bị bỏ qua khi biên dịch chương trình.
- Ký hiệu: /* chú thích */
hoặc // chú thích
Ví dụ 1:
#include<stdio.h>
#include<conio.h>
main()
{
printf("chao"); //in ra màn hình từ chao

getch(); //tạm dừng chương trình chờ ấn phím Enter để tiếp tục
}
Ví dụ 2:
#include <stdio.h>
#include <conio.h>
main()
{
char ten[50]; /* khai bao bien ten kieu char 50 ky tu */
clrscr(); /*lenh xoa man hinh*/
printf("Xin cho biet ten cua ban: "); /*Xuat chuoi ra man hinh*/
scanf("%s",ten); /*Doc vao 1 chuoi la ten cua ban*/
printf("\nXin chao ban %s\n",ten);
printf("Chao mung ban den voi Ngon ngu lap trinh C");
getch(); /*Dung chuong trinh, cho go phim*/
}
1.4 Dấu chấm câu
- Dấu “;” dùng để kết thúc một câu lệnh.
1.5 Cách khai báo
* Khai báo biến:
kieu_du_lieu danh_sach_bien;
chú ý : Danh sách có thể là một biến hoặc nhiều biến có cùng một kiểu dữ liệu được
viết cách nhau bởi dấu « , ». Ta có thể gán luôn giá trị cho từng biến.
ví dụ :
int i ;
float x,y,z ;
===================================================================
Giảng viên: Hoàng Thị Vân Anh – Khoa: Tin học kinh tế 4
Bài giảng: Cơ sở lập trình
===================================================================
int i=3 ;

* Khai báo hằng số
const kieu_du_lieu ten_hang = gia_tri_hang ;
ví du :
const int x=2 ;
* Khai báo hằng số tượng trưng
#define Ten_hang gia_tri ; /* viết sau dòng #include */
ví dụ 4:
#include <stdio.h>
#include<conio.h>
#define PI 3.14 /*khai báo hằng số tượng trưng */
main()
{
float R,Dien_tich;
printf("R= ");
scanf("%f",&R);
Dien_tich = PI*R*R;
printf("Dien tich = %f\n",Dien_tich);
getch();
return(0);
}
1.6 Phép gán giá trị
Tên_một_biến = biểu_thức;
ví dụ:
i=3; /* i được gán giá trị là 3 */
i=i+4; /* i cộng 4 được kết quả là 7, giá trị 7 này lại đặt vào ô nhớ có địa chỉ của i*/
chú ý: Ta có thể sử dụng phép gán kép để gán một giá trị cho nhiều biến
ví dụ:
a=b=c=3; /*gán giá trị 3 cho các biến a, b, c */
a=b + (c=3); //gán 3 cho biến c, sau đó cộng vào với b để gán kết quả nhận được cho a
2. Cấu trúc một chương trình

* Chương trình đơn giản:
#include < > /* gọi các tệp tiền xử lí */
/* HÀM CHÍNH */
main()
{
/* Các câu lệnh */
return(0); /* Có thể bỏ lệnh này */
}
// DINH NGHIA HAM
===================================================================
Giảng viên: Hoàng Thị Vân Anh – Khoa: Tin học kinh tế 5
Bài giảng: Cơ sở lập trình
===================================================================
Kiểu_dữ_liệu tên hàm (các tham số);
{
/* Các câu lệnh */
return ( ) /* Trả lại một giá trị cụ thể cho hàm */
}
* Cấu trúc tổng thể:
Chuyển sang bộ tiền xử lí
#include
#define

typedefs (Định nghĩa kiểu dữ liệu)
funtion prototype (nguyên mẫu các hàm: khai báo tên hàm với tham số)
Khai báo biến ngoài (External variables)
main() (function chính)
{
Khai báo các biến, hằng
Sử dụng các hàm khác

}
function thứ hai
{
Khai báo các biến, hằng
Sử dụng các hàm khác
}
function thứ ba
{
Khai báo các biến, hằng
Sử dụng các hàm khác
}
ví dụ 5:
#include <stdio.h>
#include <conio.h>
/* HAM CHINH */
main()
{
clrscr(); //cau lenh xoa man hinh
float x=1.5;
float y,z;
int n=3, p=5, q=10;
===================================================================
Giảng viên: Hoàng Thị Vân Anh – Khoa: Tin học kinh tế 6
Bài giảng: Cơ sở lập trình
===================================================================
float f(float, int, int); //khai bao mau ham
y= f(x,n,p);
printf("Gia tri cua y = %f\n",y);
z= f(x+0.5,q,n-1);
printf("Gia tri cua z = %f\n",z);

getch();
}
/* DINH NGHIA HAM f */
float f(float x, int b, int c)
{
float gia_tri; //khai bao bien cuc bo
gia_tri = x*x+b*x+c;
return gia_tri;
}
3. Môi trường làm việc
- TC có thể chạy trong môi trường MS_DOS hoặc môi trường Windows.
III. Các kiểu dữ liệu trong C
1. Các kiểu dữ liệu cơ bản
1.1 Kiểu số nguyên
Kiểu số nguyên (hay còn gọi là kiểu đếm được): là kiểu dữ liệu dùng để lưu các
giá trị nguyên. Kiểu số nguyên trong C được chia thành các kiểu dữ liệu con, mỗi kiểu
có một miền giá trị khác nhau
Kiểu biến Từ khoá Số byte Dải giá trị
Character char 1 -128 ÷ 127
Integer int 2 -32768 ÷ 32767
Short integer short 2 -32768 ÷ 32767
Long integer long 4 -2,147,483,648 ÷ 2,147,483,647
Unsigned character unsigned char 1 0 ÷ 255
Unsigned integer unsigned int 2 0 ÷ 65,535
Unsigned Short
integer
unsigned short 2 0 ÷ 65,535
Unsigned Long integer unsigned long 4 0 ÷ 4,294,967,295
* Các phép toán đối với số nguyên: +, -, *, / (lấy phần nguyên), % (lấy phần dư).
ví dụ: 5/3 được 1

5%3 được 2
chú ý: Muốn lấy được kết quả chính xác là số thực của phép chia hai số nguyên, ta phải
viết (float) x/y
===================================================================
Giảng viên: Hoàng Thị Vân Anh – Khoa: Tin học kinh tế 7
Bài giảng: Cơ sở lập trình
===================================================================
1.2 Kiểu số thực
Kiểu số thực dùng để lưu các số thực hay các số có dấu chấm thập phân
- Dạng viết thập phân bình thường: 3.14; -0.4545;
- Dạng viết có phần mũ (dạng viết khoa học)
ví dụ: 5.6543E +02 (= 5.6543* 10
2
)
phần định trị phần mũ
-0.001234 = -1.234*10
3
sẽ được viết lại làL -1.234E -03
chú ý: Phần định trị và phần mũ đều có dấu đi kèm. Hai phần này phải được viết liền
nhau.
Kiểu biến Từ
khoá
Số
byte
Dải giá trị
Single-precision float-point
(số thực với độ chính xác đơn)
float 4 1.2E-38 ÷ 3.4E38
Độ chính xác khoảng 7 chữ số
Double-precision float-point

(số thực với độ chính xác kép)
double 8 2.2E-308 ÷ 1.8E308
Độ chính xác khoảng 15 chữ số
Long Double-precision float-point
(Độ dài lớn)
long
double
10 3.4E-4932 ÷ 3.4E4932
Độ chính xác khoảng 19 chữ số
chú ý: Ta có thể viết E hoặc e đều được.
* Các phép toán: +, - , *, / (kết quả là số thực)
1.3 Kiểu kí tự (char)
- Mỗi ký tự chiếm 1 byte trong bộ nhớ.
Ví dụ: ‘h’ ‘A’ ‘0’ ‘?’
Mỗi giá trị kiểu kí tự là một phần tử của một tập hữu hạn các kí tự được sắp xếp có
thứ tự => ta có thể so sánh được.
(bảng mã ASCII với 128 ký tự đầu – trang 47 – Ngôn ngữ lập trình C)
* Các hàm xử lí kí tự:
Hàm Kiểu giá trị nhận được Tác dụng
toASCII(c) int Chuyển c thành mã ASCII
tolower(c) char Chuyển thành chữ thường
toupper(c) char Chuyển thành chữ hoa
chú ý: Các hàm trên nằm trong tệp <ctype.h>
ví dụ 5:
#include<stdio.h>
#include<ctype.h>
#include<conio.h>
main()
{
char ChuThuong,ChuHoa;

ChuThuong = getchar(); //doc mot ky tu tu ban phim
ChuHoa = toupper(ChuThuong); //Chuyen thanh chu hoa
===================================================================
Giảng viên: Hoàng Thị Vân Anh – Khoa: Tin học kinh tế 8
Bài giảng: Cơ sở lập trình
===================================================================
putchar(ChuHoa); //in ra man hinh
getch();
}
1.4 Hằng xâu kí tự
Xâu kí tự là dữ liệu kí tự được lưu trữ trong một mảng các ô nhớ liền nhau trong
đó ô cuối cùng chứa mã số là 0 (tức là null hay \0)
ví dụ:
“Ha Noi”
H a N o i \0
1.5 Kiểu Boolean
- là biểu thức mà kết quả chỉ nhận một trong hai giá trị true (ứng với 1) hoặc false
(ứng với 0)
* Các phép toán logic
TOÁN TỬ PHÉP TOÁN LOGIC Ý NGHĨA
&& AND Phép “và”
|| OR Phép “hoặc”
! NOT Phép “phủ định”
* Bảng sự thật
X Y X&&Y X||Y
0 0 0 0
0 số khác không 0 1
số khác không 0 0 1
số khác không số khác không 1 1
X !X

0 1
số khác không 0
* Các phép toán quan hệ (kết quả trả về là true,1 hoặc false,0):
!= so sánh khác nhau
== so sánh bằng nhau
>= so sánh lớn hơn hoặc bằng
<= so sánh nhỏ hơn hoặc bằng
> so sánh lớn hơn
< so sánh nhỏ hơn
Ví dụ:
3<5 được kết quả là true (tương ứng với 1)
!(3<5) được kết quả là false (tương ứng với 0)
===================================================================
Giảng viên: Hoàng Thị Vân Anh – Khoa: Tin học kinh tế 9
Bài giảng: Cơ sở lập trình
===================================================================
2. Chuyển đổi kiểu dữ liệu
* Sự hiệu chỉnh kiểu dữ liệu số học
- Một biểu thức toán học có thể tồn tại nhiều toán hạng với các kiểu số học khác nhau
(số nguyên, số thực)
Khi quy đổi kết quả, máy tính sẽ chuyển từ kiểu đơn giản lên kiểu cao hơn cho
phù hợp theo nguyên tắc:
int → long → float → double → long double
(2 byte) (4) (4) (8) (10)
Ví dụ:
int i;
long j;
float k;
i + j có kết quả là dữ liệu kiểu long.
i + j + k có kết quả là dữ liệu kiểu float.

chú ý: Không có kiểu char và short trong dãy nguyên tắc trên.
* Sự ưu tiên cho kiểu số:
- Trong biểu thức toán học, các biến có kiểu dữ liệu char hoặc short đều được quy đổi
về kiểu dữ liệu int rồi mới thực hiện tính (vì các phép toán số học không được định
nghĩa cho kiểu char và short).
ví dụ:
char a;
int b;
float c;
a + b cho kết quả có kiểu dữ liệu là int (vì a được chuyển sang kiểu dữ liệu int rồi
mới cộng vào b)
a + b + c cho kết quả có kiểu dữ liệu là float
* Sự chuyển đổi cho kiểu kí tự char
- Trong phép toán, char tự chuyển đổi thành int
- Trong phép tính tổng (hiệu) với một ký tự khác, kết quả sẽ là tổng (hiệu) của a với mã
ASCII của ký tự.
Ví dụ:
char a = 5;
‘B’ + a chính là ‘B’ + 5 = 66 + 5 = 71 => được kết quả là ký tự G
3. Thứ tự ưu tiên các phép toán
* Bảng tổng hợp đơn giản về thứ tự ưu tiên toán tử số học và quan hệ
TOÁN TỬ CHIỀU TÍNH
TOÁN
( )
L → R
- (toán tử 1 ngôi)
R → L
* / %
L → R
+ -

L → R
===================================================================
Giảng viên: Hoàng Thị Vân Anh – Khoa: Tin học kinh tế 10
Bài giảng: Cơ sở lập trình
===================================================================
< <= > >=
L → R
== !=
L → R
&&
L → R
||
L → R
Ví dụ:
5*(2+3) = 5*6=30
5/3*2 = 1*2 = 2
Vd6: Chương trình minh họa
#include<stdio.h>
#include<conio.h>
main()
{
int a;
a=5/3*2;
printf("kq: %f",a); //in ra man hinh gia tri cua a
getch(); //lenh tam dung chuong trinh cho an phim Enter
}
* Bảng tổng hợp đầy đủ
TOÁN TỬ CHIỀU TÍNH TOÁN
( ) [ ] -> L → R
- ++ ! sizeof( ) (toán tử một ngôi)

R → L
* / %
L → R
+ -
L → R
<< >>
L → R
< <= > >=
L → R
== !=
L → R
&
L → R
^
L → R
|
L → R
$$
L → R
||
L → R
?:
R → L
= += -= *= /= %= &= ^= |= <<= >>=
R → L
IV. Nhập xuất dữ liệu trong C
1. Các lệnh nhập dữ liệu (đọc kí tự từ bàn phím):
scanf( ), getchar( ), getch( ), gets()
* Hàm scanf( )
scanf(“dãy mã quy cách”, dãy địa chỉ các biến);

===================================================================
Giảng viên: Hoàng Thị Vân Anh – Khoa: Tin học kinh tế 11
Bài giảng: Cơ sở lập trình
===================================================================
Hàm scanf ( ) sử dụng những mã quy cách sau:
%c : Đọc một kí tự được khai báo là char
%d : Đọc một số nguyên
%u : Đọc số nguyên unsigned int
%hd : shortint
%hu : unsigned int
%lu : unsigned long
%f : Đọc số thực float, (nhập số theo một trong hai cách: thông thường hoặc
viết theo số mũ)
%e : Đọc số thực float, (nhập số theo một trong hai cách: thông thường hoặc
viết theo số mũ)
%lf hoặc %lu : đọc số thực double
%s : Đọc xâu kí tự không chứa dấu cách, dùng với địa chỉ xâu.
%o : Đọc vào số nguyên dưới dạng hệ đếm cơ số 8 (octal)
%x : 16 (hexa)
Chú ý 1: Trường hợp đọc số, máy tính sẽ bỏ qua dấu trống, cách, dấu xuống dòng cho
đến khi gặp chữ số thì bắt đầu lấy ra để đọc và chỉ dừng lại nếu kí tự không phải là
chữ số. Sau đó máy tính ghép chúng lại thành số cần lấy.
Đối với trường hợp đọc chữ, máy tính sẽ đọc chính xác tuyệt đối về số lượng.
ví dụ:
Nhập Hàm Kết quả máy tính nhận được
m^^*(25 scanf(“%d%c”,&x,&y); x=’m’ y=25
123^*hfn scanf(“%d%c”,&x,&y); x=123 y=’^’ (vd7)
Chú ý 2: Nếu chèn thêm ký hiệu vào giữa 2 mã qui cách thì khi đọc dữ liệu, máy tính sẽ
nhảy qua các dấu cách, dấu ngăn cách Enter để đọc số liệu hay một ký tự.
- Nguyên tắc của hàm scanf( ) : Dữ liệu gõ từ bàn phím được lưu trữ trong bộ nhớ đệm

để chờ xử lí. Hàm scanf( ) lấy dữ liệu từ bộ nhớ đệm đó.
* Hàm getchar( )
c= getchar( ) ;
có vai trò gần giống như lệnh scanf(″%c ″ ,&c) dùng để lấy 1 kí tự được gõ vào từ bàn
phím.
* Hàm đọc xâu kí tự gets( )
- Hàm này nằm trong tệp stdio.h
- Tác dụng: Đọc một xâu kí tự có chứa cả dấu cách cho đến khi ấn phím Enter thì dừng.
2. Các lệnh xuất dữ liệu
*Mẫu hàm:
printf(“dãy mã qui cách”, dãy các biểu thức);
Ví dụ:
int n;
float x;
===================================================================
Giảng viên: Hoàng Thị Vân Anh – Khoa: Tin học kinh tế 12
Bài giảng: Cơ sở lập trình
===================================================================
char ch;
printf(“In ra cac gia tri: %d, %f và %c”, n, x, ch);
Dãy mã qui cách Ý nghĩa
%c : in ra kí tự kiểu char, có thể dùng cho kiểu short và int
%d : in ra số nguyên int, có thể dùng cho kiểu char
%u : in ra kiểu số nguyên không dấu, unsign int, có thể
dùng cho unsign char, unsign short
%ld : in ra số nguyên kiểu long
%lu : unsigned long
%x, %X : viết dưới dạng số hexa (hệ đếm 16)
%o : octal (hệ đếm 8)
%f : in ra số thực dưới dạng bình thường (phần thập phân

có 6 chữ số), dùng cho kiểu float và double
%e, %E : in ra kiểu dố thực dưới dạng số mũ (phần định trị có
6 chữ số ở phần thập phân), dùng cho kiểu float,
double. Dấu e hay E sẽ tương ứng với kết quả e hoặc
E ở số in ra.
%g, %G : chọn cái nào ngắn hơn trong hai kiểu %f hoặc %e để
in ra.
%s : in ra xâu kí tự với địa chỉ cho trước.
* Khuôn in: %m, %m.n
- Dùng để viết có quy cách các dữ liệu được in ra
+ Dữ liệu là chữ, số: thêm một số nguyên m vào ngay sau % thì khi in dữ liệu ra sẽ
dành m vị trí dùng để viết dữ liệu đó.
+ Dữ liệu là số thực: thêm hai số nguyên m và n (viết theo qui tắc m.n) vào ngay
sau % thì khi in dữ liệu ra sẽ dành tổng m chữ số trong đó có n chữ số ở phần thập
phân.
ví dụ:
int x=1;
printf(“%3d”,x); => kết quả là: ^^1
float x=1.2345
printf((“%5.3f”,x) => kết quả là : ^1.234
* Căn lề trái : Bổ sung dấu “–” vào ngay sau dấu “%”
* Kí tự xoá trái : Bổ sung \b vào cuối của xâu kí tự. Mỗi ký hiệu \b sẽ xoá được một kí
tự.
ví dụ : printf(“In ra cac gia tri \b\b”); sẽ cho in ra dòng chữ: In ra cac gia t
* In ra dấu %: ta phải viết 2 lần %%
* In ra màn hình soạn thảo:
cprintf(“dãy mã qui cách”, dãy các biểu thức);
3. Trình bày màn hình
===================================================================
Giảng viên: Hoàng Thị Vân Anh – Khoa: Tin học kinh tế 13

Bài giảng: Cơ sở lập trình
===================================================================
- Để sử dụng các hàm này, ta cần khai báo:
#include conio.h
gotoxy(int X, int Y); //Di chuyển con trỏ đến vị trị có toạ độ cột là X, toạ độ dòng
là Y. (1 <= X <= 25, 1 <= Y <= 80)
clrscr( ); // xoá màn hình và đưa con trỏ về vị trí (1,1)
clreol(); //Clear End Of Line: xoá các kí tự nằm bên phải điểm nhắc.
textcolor(tên màu hoặc mã màu); // chọn màu cho chữ
textbackground(tên màu hoặc mã màu); //chọn màu cho nền
Chú ý: Tên màu là các chữ cái in hoa. Ta có thể cộng thêm 128 vào mã màu hoặc
+BLINK vào tên màu để có được màu nhấp nháy.
Ví dụ 8:
#include <stdio.h>
#include <conio.h>
main()
{
textbackground(RED);
clrscr();
gotoxy(3,10);
textcolor(BLACK);
cprintf("\nxin chao");//in ra man hinh soan thao
cprintf("\nChao mung ban den voi Ngon ngu lap trinh C");
getch();
}
===================================================================
Giảng viên: Hoàng Thị Vân Anh – Khoa: Tin học kinh tế 14
Bài giảng: Cơ sở lập trình
===================================================================
ÔN TẬP

1) Lệnh hiển thị dữ liệu:
printf(“dãy mã quy cách”, dãy các biểu thức); //in ra các ký tự là giá trị của các
biểu thức
putchar(c); // in ra một ký tự là giá trị của biến c
puts(“xâu ký tự”); // in ra một xâu ký tự
fprintf(stdprn, “dữ liệu đưa ra máy in %d\n”, k); //in ra máy in
fprintf(stdout, “dữ liệu đưa ra máy in %d\n”, k); //in ra màn hình = printf
cprintf(“dãy mã qui cách”, dãy các biểu thức); // in ra màn hình soạn thảo có sử
dụng các câu lệnh trang trí màn hình.
2) Lệnh nhập dữ liệu
scanf(“dãy mã quy cách”, dãy địa chỉ các biến); //nhập dữ liệu cho các biến trong
danh sách địa chỉ.
c= getchar( ) ; //nhập 1 ký tự cho biến c.
gets(str ); //nhập 1 xâu ký tự cho biến str
(kết thúc bằng Enter)
3) Lệnh xoá bộ nhớ đệm của bàn phím
fflush(stdin);
4) Lệnh trang trí màn hình
gotoxy(cột x, dòng y) ;
textcolor(màu hoặc mã màu) ; //chọn màu cho chữ
textbackground(màu hoặc mã màu); //chọn màu cho nền
wherex() ; //cho biết toạ độ cột
wherey() ; //cho biết toạ độ dòng.
===================================================================
Giảng viên: Hoàng Thị Vân Anh – Khoa: Tin học kinh tế 15
Bài giảng: Cơ sở lập trình
===================================================================
ÔN TẬP CHƯƠNG I
1. Hãy xây dựng chương trình tính chu vi, diện tích hình chữ nhật với chiều dài và chiều rộng
nhập vào từ bàn phím.

2. Hãy xây dựng chương trình tính tổng, hiệu, tích, thương của 2 số nguyên nhập vào từ bàn
phìm.
3. Hãy xây dựng một phần mềm ứng dụng là trò chơi đáp ứng yêu cầu sau:
- Nhập vào một mã ASCII
- Nhập vào ký tự mà bạn dự đoán (người thứ nhất).
- Hiển thị kết quả của mã ASCII mà người trước đã nhập (người thứ hai).
4. Hãy xây dựng phần mềm ứng dụng là trò chơi đáp ứng yêu cầu sau:
- Bắt đầu nhập 3 số nguyên dương (người thứ nhất)
- Xoá màn hình (người thứ nhất)
- Nhập lại 3 số bạn đã nhớ (người thứ 2).
- Hiển thị 3 số ban đầu.
5. Xây dựng chương trình đáp ứng yêu cầu sau:
- Nhập số nguyên a từ bàn phím
- Tính tổngvà tích của các số nguyên liên tiếp kể từ số đã nhập (a, a+1. a+2. a+3. a+4)
6. Xây dựng chương trình tính số tiền lãi lĩnh được sau một năm biết số tiền gửi ban đầu là S
(nhập vào từ bàn phìm), lãi suất hàng tháng là 2%. Biết rằng mỗi tháng người gửi sẽ rút lãi
một lần.
7. Hãy xây dựng chương trình nhập kí tự đầu tiên của tên các bạn trong nhóm và hiển thị ra
màn hình bằng 2 cách: viết hoa, viết thường.
8. Hãy xây dựng phần mềm ứng dụng đáp ứng yêu cầu sau:
- Nhập vào 5 ký tự
- Chuyển các ký tự đó thành các ký tự viết hoa.
- Hiển thị ra màn hình như sau:
+ dòng đầu là tất cả các ký tự viết hoa
+ các dòng sau, mỗi dòng hiển thị một ký tự.
9. Xây dựng chương trình tính bình phương và căn bậc hai của một số nguyên được nhập vào
từ bàn phím.
10. Xây dựng chương trình tính lập phương của tổng 3 số nguyên dương nhập vào từ bàn phím
11. Xây dựng chương trình tính giá trị của f = a*x*x + b*x + c với a, b, c là các số cho trước,
x là số được nhập và từ bàn phím.

===================================================================
Giảng viên: Hoàng Thị Vân Anh – Khoa: Tin học kinh tế 16
CHƯƠNG II: CÁC CÂU LỆNH ĐIỀU KHIỂN
I. Các câu lệnh lựa chọn:
1. if … else …
a) Mẫu lệnh:
* Mẫu lệnh 1:
if (biểu thức lôgic)
côngviệc1;
else
côngviệc2;
- Cách thực hiện: Nếu biểu thức lôgic nhận giá trị đúng thì máy tính sẽ thực hiện công
việc1. Trường hợp ngược lại (biểu thức logic nhận giá trị sai) thì máy tính thực hiện
công việc 2.
Ví dụ:
if (a>b)
max=a;
else
max=b;
* Mẫu lệnh 2:
if (biểu thức lôgic)
côngviệc;
- Cách thực hiện: Nếu biểu thức lôgic nhận giá trị đúng thì máy tính sẽ thực hiện lệnh
trong cấu trúc if
Ví dụ:
if ((x==a)&&(y==b)&&(z==c))
printf(“ban da nhap dung ca ba so”);
* Chú ý: côngviệc, côngviệc1, côngviêc2 có thể là một câu lệnh đơn hoặc một câu lệnh
ghép (nằm giữa hai dấu {}) hoặc cũng có thể là câu lệnh có cấu trúc.
b) Ví dụ

Ví dụ 9: Viết chương trình tìm số lớn nhất trong 2 chữ số được nhập vào từ bàn
phím.
#include <stdio.h>
#include <conio.h>
main()
{
clrscr();
int a,b,max;
printf("Nhap hai so:\n");
scanf("%d%d",&a,&b);
if (a>b)
max=a;
else
max=b;
printf("So lon nhat la: %d",max);
getch();
}
2. SWITCH
a) Mẫu lệnh
switch (biểu thức)
{
case hằng_1: [công_việc1]
case hằng_2: [công_việc2]

case hằng_n: [công_việcn]
[default: [công_việcn+1]]
}
* Giải thích:
- biểu thức, hằng1, hằng2, , hằngn có thể nhận giá trị là các số nguyên hoặc char (sẽ
tự đổi thành int)

- công việc có thể là một câu lệnh đơn hoặc 1 câu lệnh ghép hoặc 1 cấu trúc lệnh khác.
Trong công việc thường sử dụng thêm lệnh break để thoát luôn ra khỏi cấu trúc lệnh
switch.
* Cách thực hiện:
- Nếu biểu thức nhận giá trị hằng nào thì công việc tương ứng với hằng đó được thực
hiện. Sau đó, nếu không gặp lệnh break thì nó sẽ thực hiện tiếp công việc ở các trường
hợp hằng còn lại.
- Nếu tất cả các hằng đều không phải là giá trị của biểu thức thì công việc thứ n+1 sẽ
được thực hiện.
b) Ví dụ
Ví dụ 10:
#include<stdio.h>
#include<conio.h>
main()
{
clrscr();
int a=1;
switch(a)
{
case 0: printf("so do la 0\n");
case 1: printf("so do la 1\n");
case 2: printf("so do la 2\n");
default: printf("khong phai so 0 1 2");
}
getch();
}
Ví dụ 10_break:
#include<stdio.h>
#include<conio.h>
main()

{
clrscr();
int a=1;
switch(a)
{
case 0: printf("so do la 0\n");
break;
case 1: printf("so do la 1\n");
break;
case 2: printf("so do la 2\n");
break;
default: printf("khong phai so 0 1 2");
}
getch();
}
BÀI TẬP
Bài 1: Hãy viết chương trình tìm số lớn nhất trong hai số nhập vào từ bàn phím mà
không phải sử dụng biến phụ max?
Bài 2: Hãy viết chương trình tìm số lớn nhất trong hai số và tính hiệu dương của hai số
đó.
Bài 3: Hãy viết phần mềm giải phương trình bậc nhất ax-b=0
Bài 4: Hãy viết phần mềm giải phương trình bậc hai ax
2
+bx+c=0 với a, b, c là các số
nhập vào từ bàn phím
Bài 5: Hãy viết phần mềm tính số tiền lãi lĩnh được sau thời gian t tháng biết:
- Nếu gửi ít hơn 6 tháng thì lãi suất hàng tháng là 2%
- Nếu gửi từ 7 tháng đến 1 năm thì lãi suất hàng tháng là 3% (áp dụng cho toàn
bộ thời gian gửi).
- Nếu gửi trên 1 năm thì lãi suất hàng tháng là 4% (áp dụng cho toàn bộ thời gian

gửi).
Phương thức gửi: Cứ sau mỗi tháng người gửi sẽ được rút lãi một lần.
Bài 6: Cho bốn số a, b, c, d đọc vào từ bàn phím. Hãy tìm giá trị cực đại gán cho biến
có tên là Max và in ra màn hình.
Bài 7: Viết chương trình nhập một số nguyên x với 2<=x<= 8 và in ra màn hình thứ
trong tuần biết rằng
- Nếu số nhập vào là 2 thì in ra dòng thông báo “thu hai”
- Nếu số nhập vào là 3 thì in ra dòng thông báo là “thu ba”
-
- Nếu số nhập vào là 8 thì in ra dòng thông báo là “chủ nhật”.
II. Các lệnh lặp
1. Vòng lặp xác định FOR
* Mẫu lệnh
for ([khởi tạo]; [điều kiện]; [bthức thay đổi gtrị biến điều khiển])
công_việc;
Trong đó:
- khởi tạo: là biểu thức cho biết giá trị khởi tạo của biến điều khiển
- điều kiện : là biểu thức cho biết điều kiện của biến điều khiển để thực hiện công việc
- bthức thay đổi gtrị biến điều khiển : là biểu thức cho biết giá trị của biến kiều khiển
được thay đổi như thế nào sau mỗi vòng lặp.
- công việc : có thể là một câu lệnh đơn hoặc một câu lệnh ghép (gồm nhiều lệnh đơn
đặt giữa 2 dấu ″ ″)
Ví dụ 1:
for (ch = ‘A’; ch<= ‘Z’; ch++)
printf(“%c”, ch);
Ví dụ 2:
i=1;
for (; i<=24; i++) printf(“%d\n”,i);
Ví dụ 3:
i=1;

for (; i<=24; )
{
printf(“%d\n”,i);
i++;
End
}
* Cách thực hiện: Begin
biến đkhiển = gtrị khởi tạo
biến điều khiển sai
có thoả mãn đk?
đúng

công việc được thực hiện
biến đkhiển nhận giá trị mới
//Chuyen doi ki tu
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
main()
{
clrscr();
char chu[80];
int tong, dem;
//doc vao xau ki tu
for (dem=0; (chu[dem]=getchar())!= '\n'; ++dem); //lenh rong
tong=dem;
//hien thi xau ki tu duoi dang chu hoa
for (dem=0; dem<tong; ++dem)
putchar(toupper(chu[dem]));
getch();

}
Chú ý: Nếu trong công việc là lệnh for khác thì ta có cấu trúc for lồng nhau.
2. Vòng lặp không xác định DO … WHILE
* Mẫu lệnh
do <công việc>
while (biểu thức logic);
Trong đó:
- công việc : là một lệnh đơn hoặc một lệnh ghép được đặt trong dấu " " hoặc là lệnh
rỗng.
- biểu thức logic: nhận 1 trong 2 giá trị đúng hoặc sai
* Cách thực hiện:
Begin
Công việc thực hiện
biểu thức logic
End
đúng
sai
Ví dụ 12:
// nhap cac so nguyen tu ban phim sao cho tong cua chung lon hon 100
#include <stdio.h>
#include <conio.h>
main()
{
clrscr();
int n, tong=0;
do
{
printf("Nhap so: ");
scanf("%d",&n);
tong+=n;

}
while (tong<=100);
printf("Tong cac so da nhap la: %d",tong);
getch();
}
3. WHILE
* Mẫu lệnh
while (biểu thức logic);
<công việc>
Trong đó:
- biểu thức logic: nhận 1 trong 2 giá trị đúng hoặc sai
- công việc : là một lệnh đơn hoặc một lệnh ghép được đặt trong dấu " "
* Cách thực hiện:
Begin
biểu thức logic
công việc thực hiện
End
Ví dụ 13: Nhập các số nguyên từ bàn phím sao cho tổng của chúng lớn hơn 100
sai
đúng
#include <stdio.h>
#include <conio.h>
main()
{
clrscr();
int n, tong=0;
while (tong <=100)
{
printf("Nhap so: ");
scanf("%d",&n);

tong+=n;
}
printf("Tong cac so da nhap la: %d",tong);
getch();
}
III. Các lệnh rẽ nhánh vô điều kiện :
1. BREAK
* Mẫu lệnh
break;
* Tác dụng
- Lệnh break có tác dụng thoát ra khỏi câu lệnh có cấu trúc trực tiếp chứa nó và thực
hiện tiếp các câu lệnh phía sau của chương trình.
Ví dụ 10_break (trang 19)
2. CONTINUE
* Mẫu lệnh
continue;
* Tác dụng
- Lệnh continue cho phép chuyển sang vòng lặp tiếp theo mà không cần thực hiện các
câu lệnh phía sau trong công việc của vòng lặp.
Ví dụ : 8.15 (giáo trình trang 151)
3. GOTO
*Mẫu lệnh
goto tên_vị_trí_mới;
Chú ý: Tên_vị_trí_mới là ký hiệu đánh dấu câu lệnh mà máy tính sẽ thực hiện ngay khi
gặp lệnh goto. Ta có thể ký hiệu đánh dấu câu lệnh đó như sau:
Tên_vị_trí_mới: câu_lệnh;
Ví dụ: 8.16 (giáo trình trang 151).
CHƯƠNG III: HÀM TRONG NGÔN NGỮ LẬP TRÌNH C

I. Khái niệm về hàm

1. Hàm thư viện
- Hàm thư viện: là những chương trình con chuẩn, thông dụng đã được lập sẵn và được
chương trình dịch quản lý. Các hàm này được chứa trong các đơn vị chương trình khác
nhau dưới dạng các tệp tiêu đề (header) như stdio.h, conio.h,
2. Hàm tự tạo
- Hàm tự tạo: là chương trình con được người lập trình viết.
Ví dụ 14a:
#include<stdio.h>
#include<conio.h>
main()
{
float f_thi_du(float, int, int); //mau ham, prototype
float x=1.5;
float y, z;
int n=3, p=5, q=10;
y=f_thi_du(x, n, p);
printf("gia tri cua y la %f\n",y);
z=f_thi_du(x+0.5, q, n-1);
printf("gia tri cua y = %f\n",z);
getch();
}
//Khai bao ham
float f_thi_du(float x, int b, int c)
{
float gia_tri; //khai bao bien cuc bo
gia_tri=x*x+b*x+c;
return gia_tri;
}
II. Cách xây dựng hàm
1. Xây dựng hàm

* Khai báo hàm:
Kiểu_gtrị_của_hàm Tên_hàm (các_tham_số_hình_thức)
{
Côngviệc;
[return (gtrị của hàm);]
}