BỘ LAO ĐỘNG - THƯƠNG BINH VÀ XÃ HỘITỔNG CỤC DẠY NGHỀ

GIÁO TRÌNHMôn học: LẬP TRÌNH CNGHỀ: QUẢN TRỊ MẠNG

TRÌNH ĐỘ: CAO ĐẲNG NGHỀ

( Ban hành kèm theo Quyết định số: 120/QĐ-TCDN ngày 25 tháng 02 năm 2013 của Tổng cục trưởng Tổng cục dạy nghề)

Hà Nội, năm 2013

TUYÊN BỐ BẢN QUYỀN: Tài liệu này thuộc loại sách giáo trình nên các nguồn thông tin có thể

được phép dùng nguyên bản hoặc trích dùng cho các mục đích về đào tạo và tham khảo.

Mọi mục đích khác mang tính lệch lạc hoặc sử dụng với mục đích kinh doanh thiếu lành mạnh sẽ bị nghiêm cấm.

MÃ TÀI LIỆU: MH18

LỜI GIỚI THIỆU

Ngày nay, khoa học máy tính thâm nhập vào mọi lĩnh vực. Tự động hóa

hiện đang là ngành chủ chốt điều hướng sự phát triển thế giới. Bất cứ ngành

nghề nào cũng cần phải hiểu biết ít nhiều về Công nghệ Thông tin và lập trình

nói chung. Cụ thể, C là một ngôn ngữ lập trình cấp cao mà mọi lập trình viên

cần phải biết. Vì thế, trong giáo trình này, chúng ta sẽ nghiên cứu chi tiết cấu

trúc ngôn ngữ C.

Môn học này là nền tảng để tiếp thu hầu hết các môn học khác trong

chương trình đào tạo. Mặt khác, nắm vững ngôn ngữ C là cơ sở để phát triển các

ứng dụng.

Học xong môn này, sinh viên phải nắm được các vấn đề sau:

- Khái niệm về ngôn ngữ lập trình.

- Khái niệm về kiểu dữ liệu

- Kiểu dữ liệu có cấu trúc (cấu trúc dữ liệu).

- Khái niệm về giải thuật

- Ngôn ngữ biểu diễn giải thuật.

- Ngôn ngữ sơ đồ (lưu đồ), sử dụng lưu đồ để biểu diễn các giải thuật.

- Tổng quan về Ngôn ngữ lập trình C.

- Các kiểu dữ liệu trong C.

- Các lệnh có cấu trúc.

- Cách thiết kế và sử dụng các hàm trong C.

- Một số cấu trúc dữ liệu trong C.

Hà Nội, ngày 25 tháng 02 năm 2013

Tham gia biên soạn

1. Chủ biên Trần Thị Hà Khuê

2. Thành viên Võ Thị Ngọc Tú

3. Thành viên Dương Hiển Tú

MỤC LỤC

LỜI GIỚI THIỆU...............................................................................................3MỤC LỤC...........................................................................................................4

1. Vị trí, tính chất, ý nghĩa và vai trò môn học:.......................................................7

2. Mục tiêu của môn học:........................................................................................7

3. Nội dung môn học:..............................................................................................7

CHƯƠNG 1: GIỚI THIỆU VỀ NGÔN NGỮ C..........................................91.1.TỔNG QUAN VỀ NGÔN NGỮ LẬP TRÌNH C...............................................9

1.2.KHỞI ĐỘNG VÀ THOÁT KHỎI CHƯƠNG TRÌNH C.................................11

1.2.1. KHỞI ĐỘNG CHƯƠNG TRÌNH C..........................................................111.2.2. THOÁT KHỎI CHƯƠNG TRÌNH C........................................................121.2.3. CÁC VÍ DỤ ĐƠN GIẢN...........................................................................12

CHƯƠNG 2: CÁC THÀNH PHẦN CƠ BẢN TRONG NGÔN NGỮ C.142.1.Từ khóa..............................................................................................................14

2.1.1. Bộ chữ viết trong C....................................................................................142.1.2. Từ khóa......................................................................................................15

2.2.Tên.....................................................................................................................15

2.3.Kiểu dữ liệu.......................................................................................................16

2.3.1. Kiểu số nguyên...........................................................................................162.3.2. Kiểu số thực...............................................................................................17

2.4.Các phép toán....................................................................................................17

2.4.1. Các phép toán số học.................................................................................172.4.2. Các phép toán quan hệ và logic.................................................................182.4.3. Phép toán tăng giảm...................................................................................202.4.4. Thứ tự ưu tiên các phép toán......................................................................21

2.5.Ghi chú..............................................................................................................22

2.5.1. Ghi chú.......................................................................................................222.5.2. Cấu trúc chương trình C.............................................................................23

2.6.Khai báo biến.....................................................................................................24

2.6.1. Biến............................................................................................................242.6.2. Vị trí khai báo biến trong C.......................................................................252.6.3. Biểu thức....................................................................................................25

2.7.Nhập/xuất dữ liệu..............................................................................................26

2.7.1. Lệnh gán.....................................................................................................262.7.2. Lệnh nhập...................................................................................................27

2.7.3. Lệnh xuất....................................................................................................28

2.8.Bài tập thực hành...............................................................................................29

CHƯƠNG 3: CẤU TRÚC RẼ NHÁNH CÓ ĐIỀU KIỆN........................303.1.Lệnh và khối lệnh..............................................................................................30

3.1.1. Lệnh...........................................................................................................303.1.2. Khối lệnh....................................................................................................30

3.2.Lệnh if...............................................................................................................31

3.2.1. Dạng 1 (if thiếu).........................................................................................313.2.2. Bài tập thực hành.......................................................................................323.2.3. Dạng 2 (if đủ).............................................................................................323.2.4. Bài tập thực hành.......................................................................................333.2.5. Cấu trúc else if...........................................................................................333.2.6. Bài tập thực hành.......................................................................................353.2.7. Cấu trúc if lồng nhau..................................................................................353.2.8. Bài tập thực hành.......................................................................................37

3.3.Lệnh switch().....................................................................................................37

3.3.1. Cấu trúc switch…case (switch thiếu).........................................................373.3.2. Bài tập thực hành.......................................................................................393.3.3. Cấu trúc switch…case…default (switch đủ).............................................403.3.4. Bài tập thực hành.......................................................................................423.3.5. Cấu trúc switch lồng..................................................................................423.3.6. Bài tập thực hành.......................................................................................44

CHƯƠNG 4: CẤU TRÚC VÒNG LẶP......................................................454.1.Lệnh for.............................................................................................................45

4.2.Lệnh break.........................................................................................................48

4.3.Lệnh continue....................................................................................................49

4.4.Lệnh while.........................................................................................................50

4.5.Lệnh do..while...................................................................................................51

4.6.Vòng lặp lồng nhau...........................................................................................53

4.7.So sánh sự khác nhau của các vòng lặp.............................................................54

4.8.Bài tập thực hành...............................................................................................54

CHƯƠNG 5: HÀM.......................................................................................555.1.Các ví dụ về hàm...............................................................................................55

5.1.1. Khái niệm về hàm......................................................................................555.1.2. Các ví dụ về hàm........................................................................................57

5.2.THAM SỐ DẠNG THAM BIẾN VÀ THAM TRỊ..........................................61

5.2.1. Tham số dạng tham trị...............................................................................615.2.2. Bài tập thực hành về tham trị.....................................................................635.2.3. Tham số dạng tham biến............................................................................63

5.2.4. Bài tập thực hành.......................................................................................64

5.3.SỬ DỤNG BIẾN TOÀN CỤC.........................................................................65

5.3.1. Sử dụng biến toàn cục................................................................................655.3.2. Bài tập thực hành.......................................................................................67

5.4.Dùng dẫn hướng #define...................................................................................70

CHƯƠNG 6: MẢNG VÀ CHUỖI...............................................................726.1.GIỚI THIỆU KIỂU DỮ LIỆU “KIỂU MẢNG” TRONG C............................72

6.2.MẢNG MỘT CHIỀU........................................................................................73

6.2.1. Khai báo.....................................................................................................736.2.2. Truy xuất từng phần tử của mảng..............................................................746.2.3. Bài tập thực hành.......................................................................................77

6.3.MẢNG NHIỀU CHIỀU....................................................................................78

6.3.1. Khai báo.....................................................................................................796.3.2. Truy xuất từng phần tử của mảng hai chiều...............................................806.3.3. Bài tập thực hành.......................................................................................82

6.4.CHUỖI..............................................................................................................83

6.4.1. KHÁI NIỆM..............................................................................................846.4.2. KHAI BÁO................................................................................................846.4.3. CÁC THAO TÁC TRÊN CHUỖI KÝ TỰ................................................856.4.4. Bài tập thực hành.......................................................................................90

TÀI LIỆU THAM KHẢO..................................................................................93

MÔN HỌC LẬP TRÌNH CMã môn học: MH18

1. Vị trí, tính chất, ý nghĩa và vai trò môn học:

- Vị trí: Môn học được bố trí sau khi sinh viên học xong các môn học chung, các môn học cơ sở chuyên ngành đào tạo chuyên môn nghề.

- Tính chất: Lập trình C là môn học lý thuyết cơ sở nghề.- Ý nghĩa và vai trò: Môn học này là nền tảng để tiếp thu hầu hết các môn

học khác trong chương trình đào tạo. Mặt khác, nắm vững ngôn ngữ C là cơ sở để phát triển các ứng dụng.

2. Mục tiêu của môn học:

- Trình bày được công dụng của ngôn ngữ lập trình C;- Trình bày được cú pháp, công dụng của các câu lệnh trong ngôn ngữ C;- Phân tích được chương trình: xác định nhiệm vụ chương trình (phải làm

gì?).- Viết chương trình và thực hiện chương trình đơn giản trong máy tính bằng

ngôn ngữ C.- Bố trí làm việc khoa học đảm bảo an toàn cho người và phương tiện học

tập.3. Nội dung môn học:

Số TT Tên chương, mục

Thời gian Tổng

sốLý

thuyếtThực hành

Bài tập

Kiểm tra* (LT hoặcTH)

I Giới thiệu về ngôn ngữ C 1 1II Các thành phần trong ngôn ngữ C 7 6 1

Từ khóaTênKiểu dữ liệuGhi chúKhai báo biếnNhập/xuất dữ liệu

III Cấu trúc rẽ nhánh có điều kiện 12 5 6 1Lệnh và khối lệnhLệnh ifLệnh switch

IV Cấu trúc vòng lặp 12 6 6Lệnh forLệnh BreakLệnh continue

Số TT Tên chương, mục

Thời gian Tổng

sốLý

thuyếtThực hành

Bài tập

Kiểm tra* (LT hoặcTH)

Lệnh whileLệnh do…whileVòng lặp lồng nhauSo sánh sự khác nhau của các vòng lặp

V Hàm 13 5 7 1Các ví dụ về hàm Tham số dạng tham biến và tham trịSử dụng biến toàn cụcDùng dẫn hướng #define

VI Mảng và chuỗi 15 7 7 1MảngChuỗi

Cộng 60 30 27 3

CHƯƠNG 1: GIỚI THIỆU VỀ NGÔN NGỮ C

Mã chương: MH18-01

Ý nghĩa:

C là ngôn ngữ rất có hiệu quả và được ưa chuộng nhất để viết các phần

mềm hệ thống, mặc dù nó cũng được dùng cho việc viết các ứng dụng. Ngoài ra,

C cũng thường được dùng làm phương tiện giảng dạy trong khoa học máy

tính mặc dù ngôn ngữ này không được thiết kế dành cho người nhập môn.

Mục tiêu:- Trình bày được lịch sử phát triển của ngôn ngữ C;- Mô tả được những ứng dụng thực tế của ngôn ngữ C.- Một số thao tác cơ bản của trình soạn thảo C.- Tiếp cận một số lệnh đơn giản thông qua các ví dụ- Thực hiện các thao tác an toàn với máy tính.

Nội dung:1.1. TỔNG QUAN VỀ NGÔN NGỮ LẬP TRÌNH C

Mục tiêu:- Trình bày được lịch sử phát triển của ngôn ngữ C;- Mô tả được những ứng dụng thực tế của ngôn ngữ C.- Mô tả những đặc điểm cơ bản của ngôn ngữ C

C là ngôn ngữ lập trình cấp cao, được sử dụng rất phổ biến để lập trình hệ

thống cùng với Assembler và phát triển các ứng dụng.

Vào những năm cuối thập kỷ 60 đầu thập kỷ 70 của thế kỷ XX, Dennish

Ritchie (làm việc tại phòng thí nghiệm Bell) đã phát triển ngôn ngữ lập trình C

dựa trên ngôn ngữ BCPL (do Martin Richards đưa ra vào năm 1967) và

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à được cài đặt lần

đầu tiên trên hệ điều hành UNIX của máy DEC PDP-11. Năm 1978, Dennish

Ritchie và B.W Kernighan đã cho xuất bản quyển “Ngôn ngữ lập trình C” và

được phổ biến rộng rãi đến nay.

Lúc ban đầu, C được thiết kế nhằm lập trình trong môi trường của hệ điều

hành Unix nhằm mục đích hỗ trợ cho các công việc lập trình phức tạp. Nhưng

về sau, với những nhu cầu phát triển ngày một tăng của công việc lập trình, C

đã vượt qua khuôn khổ của phòng thí nghiệm Bell và nhanh chóng hội nhập

vào thế giới lập trình để rồi các công ty lập trình sử dụng một cách rộng rãi.

Sau đó, các công ty sản xuất phần mềm lần lượt đưa ra các phiên bản hỗ trợ

cho việc lập trình bằng ngôn ngữ C và chuẩn ANSI C cũng được khai sinh từ

đó.

Ngôn ngữ lập trình C là một ngôn ngữ lập trình hệ thống rất mạnh và rất

“mềm dẻo”, có một thư viện gồm rất nhiều các hàm (function) đã được tạo

sẵn. Người lập trình có thể tận dụng các hàm này để giải quyết các bài toán

mà không cần phải tạo mới. Hơn thế nữa, ngôn ngữ C hỗ trợ rất nhiều phép

toán nên phù hợp cho việc giải quyết các bài toán kỹ thuật có nhiều công thức

phức tạp. Ngoài ra, C cũng cho phép người lập trình tự định nghĩa thêm các

kiểu dữ liệu trừu tượng khác. Tuy nhiên, điều mà người mới vừa học lập trình

C thường gặp “rắc rối” là “hơi khó hiểu” do sự “mềm dẻo” của C. Dù vậy, C

được phổ biến khá rộng rãi và đã trở thành một công cụ lập trình khá mạnh,

được sử dụng như là một ngôn ngữ lập trình chủ yếu trong việc xây dựng

những phần mềm hiện nay.

Ngôn ngữ C có những đặc điểm cơ bản sau:

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.

1.2. KHỞI ĐỘNG VÀ THOÁT KHỎI CHƯƠNG TRÌNH C

Mục tiêu:- Một số thao tác cơ bản của trình soạn thảo C.- Tiếp cận một số lệnh đơn giản thông qua các ví dụ- Thực hiện các thao tác an toàn với máy tính.

1.2.1. KHỞI ĐỘNG CHƯƠNG TRÌNH C

Nhập lệnh tại dấu nhắc DOS: gõ BC (Enter) (nếu đường dẫn đã được

cài bằng lệnh path trong đó có chứa đường dẫn đến thư mục chứa tập tin

BC.EXE). Nếu đường dẫn chưa được cài đặt ta ta tìm xem thư mục BORLAND

C (hoặc TURBO C) nằm trong ổ đĩa nào. Sau đó ta gõ lệnh sau:

<ỗ đĩa>:\BORLAND C\BIN\BC (Enter)

Nếu vừa khởi động BC vừa soạn thảo chương trình với một tập tin có tên

do chúng ta đặt, thì gõ lệnh: BC [đường dẫn]<tên file cần soạn thảo>, nếu tên

file cần soạn thảo đã có thì được nạp lên, nếu chưa có sẽ được tạo mới.

Khởi động tại Windows: Bạn vào menu Start, chọn Run, bạn gõ vào hộp

Open 1 trong các dòng lệnh như nhập tại DOS. Hoặc bạn vào Window Explorer,

chọn ổ đĩa chứa thư mục BORLANDC, vào thư mục BORLANDC, vào thư mục

BIN, khởi động tập tin BC.EXE.

Ví dụ: gõ D:\BORLANDC\BIN\BIN\BC E:\BAITAP_BC\VIDU1.CPP

Câu lệnh trên có nghĩa khởi BC và nạp tập tin VIDU1.CPP chứa trong thư

mục BAITAP_BC trong ổ đĩa E. Nếu tập tin này không có sẽ được tạo mới.

Màn hình sau khi khởi động thành công:

Hình 1.1. Màn hình sau khi khởi động C thành công

1.2.2. THOÁT KHỎI CHƯƠNG TRÌNH C

Ấn phím F10 (kích hoạt Menu), chọn menu File, chọn Quit;

Hoặc ấn tổ hợp phím Alt – X

1.2.3. CÁC VÍ DỤ ĐƠN GIẢN

1 /* Chuong trinh in ra cau bai hoc C dau tien */

2 #include<stdio.h>34 void main()5 {6 printf(“Bai hoc C dau tien”);7 }

Kết quả in ra màn hình:

Bai hoc C dau tien

Dòng thứ 1: bắt đầu bằng /* và kết thúc bằng */ cho biết hang này là hang

diễn giải (chú thích). Khi dịch và chạy chương trình, dòng này không được dịch

và cũng không thi hành lệnh gì cả. Mục đích của việc ghi chú này giúp chương

trình rõ ràng hơn. Sau này chúng ta đọc lại chương trình biết chương trình làm

gì.

Dòng thứ 2: chứa phát biểu tiền xử lý #include <stdio.h>. Vì trong chương

trình này chúng ta sử dụng hàm thư viện của C là printf, do đó chúng ta cần phải

có khai báo của hàm thư viện này để báo cho trình biên dịch C biết. Nếu không

khai báo chương trình sẽ báo lỗi.

Dòng thứ 3: Hằng trắng viết ra với ý đồ làm cho bảng chương trình thoáng,

dễ đọc.

Dòng thứ 4: void main(void) là thành phần chính của mọi chương trình C

(bạn có thể viết main() hoặc void main() hoặc main(void)). Tuy nhiên, bạn nên

viết theo dạng void main(void) để chương trình rõ rang hơn. Mọi chương trình C

đều bắt đầu thi hành từ hàm main. Cặp dấu ngoặc () cho biết đây là khối hàm

(function). Hàm void main(void) có từ khóa void đầu tiên cho biết hàm này

không trả về giá trị, từ khóa void trong ngoặc đơn cho biết hàm này không nhận

vào đối số.

Dòng thứ 5 và 7: cặp dấu ngoặc móc {} giói hạn thân của hàm. Thân hàm

bắt đầu bằng dấu { và kết thúc bằng dấu }.

Dòng thứ 6: printf(“Bai hoc C dau tien.”);, chỉ thị cho máy in ra chuỗi ký tự

nằm trong nháy kép (“”). Hàng này được gọi là một câu lệnh, kết thúc một câu

lệnh trong C phải là dấu chấm phẩy (;).

Chú ý:

- Các từ include, stdio.h, void, main, print phải viết bằng chữ thường.- Chuỗi trong nháy kép cần in ra “Bạn có thể viết chữ HOA, thường tùy ý”.- Kết thúc câu lệnh phải có dấu chấm phẩy- Kết thúc tên hàm không có dấu chấm phẩy hoặc bất cứ dấu gì.- Ghi chú phải đặt trong cặp /*……*/- Thân hàm phải được bao bởi cặp {}.- Các câu lệnh trong thân hàm phải viết thụt vào.

Sau khi nhập xong đoạn chương trình vào máy. Bạn ấn và giữ phím Ctrl,

gõ F9 để dịch và chạy chương trình. Khi đó chúng ta thấy chương trình chớp rất

nhanh và không thấy kết quả gì cả. Bạn Ấn và giữ phím Alt, gõ F5 để xem kết

quả, khi xem xong, ấn phím bất kỳ để quay về màn hình soạn thảo chương trình.

CHƯƠNG 2: CÁC THÀNH PHẦN CƠ BẢN TRONG

NGÔN NGỮ C

Mã chương: MH18-02

Ý nghĩa:

Ngôn ngữ C hỗ trợ rất nhiều phép toán nên phù hợp cho việc giải quyết các

bài toán kỹ thuật có nhiều công thức phức tạp. Ngoài ra, C cũng cho phép người

lập trình tự định nghĩa thêm các kiểu dữ liệu trừu tượng khác.

Mục tiêu: - Sử dụng được hệ thống kí hiệu và từ khóa- Khai báo tên đúng- Trình bày được các kiểu dữ liệu- Khai báo biến đúng- Thực hiện được việc nhập và xuất dữ liệu- Thực hiện các thao tác an toàn với máy tính

2.1. Từ khóa

Mục tiêu: Hiểu và sử dụng đúng hệ thống ký hiệu và từ khóa.

2.1.1. Bộ chữ viết trong C

Ngôn ngữ C được xây dựng trên bộ ký tự sau:

- 26 chữ cái hoa: A B C .. Z- 26 chữ cái thường: a b c .. z- 10 chữ số: 0 1 2 .. 9- Các ký hiệu toán học: + - * / = ( ) - Ký tự gạch nối: _- Các ký tự khác: . , : ; [ ] {} ! \ & % # $ ...- Dấu cách (space) dùng để tách các từ. Ví dụ chữ SINH VIEN có 9 ký tự,

còn SINHVIEN chỉ có 8 ký tự.* Chú ý:

Khi viết chương trình, ta không được sử dụng bất kỳ ký tự nào khác ngoài

các ký tự trên.

2.1.2. Từ khóa

Từ khoá là những từ được sử dụng để khai báo các kiểu dữ liệu, để viết các

toán tử và các câu lệnh. Một số từ khóa của TURBO C được liệt kê như sau:

asm break case cdecl

char const continue default

do double else enum

extern Far float for

goto Huge if int

interrupt Long near pascal

register return short signed

sizeof static struct switch

tipedef union unsigned void

volatile while

Chú ý:

- Không được dùng các từ khoá để đặt tên cho các hằng, biến, mảng, hàm ...

- Từ khoá phải được viết bằng chữ thường, ví dụ: viết từ khoá khai báo kiểu nguyên là int chứ không phải là INT.2.2. Tên

Mục tiêu: Hiểu và khai báo tên theo đúng nguyên tắc.

Khái niệm tên rất quan trọng trong quá trình lập trình, nó không những thể

hiện rõ ý nghĩa trong chương trình mà còn dùng để xác định các đại lượng khác

nhau khi thực hiện chương trình.

Tên thường được đặt cho hằng, biến, mảng, con trỏ, nhãn… Chiều dài tối

đa của tên là 32 ký tự.

Tên biến hợp lệ là một chuỗi ký tự liên tục gồm: Ký tự chữ, số và dấu gạch

dưới. Ký tự đầu của tên phải là chữ hoặc dấu gạch dưới. Khi đặt tên không được

đặt trùng với các từ khóa.

Ví dụ 1 :

Các tên đúng: delta, a_1, Num_ODD, Case

Các tên sai:

3a_1 (ký tự đầu là số)

num-odd (sử dụng dấu gạch ngang)

int (đặt tên trùng với từ khóa)

del ta (có khoảng trắng)

f(x) (có dấu ngoặc tròn)

Lưu ý: Trong C, tên phân biệt chữ hoa, chữ thường

Ví dụ 2 : number khác Number

case khác Case

(case là từ khóa, do đó bạn đặt tên là Case vẫn đúng)

2.3. Kiểu dữ liệu

Mục tiêu: Hiểu và có thể sử dụng kiểu dữ liệu theo đúng mục đích của bài

toán.

2.3.1. Kiểu số nguyên

Trong C cho phép sử dụng số nguyên kiểu int, số nguyên dài kiểu long và

số nguyên không dấu kiểu unsigned. Kích cỡ và phạm vi biểu diễn của chúng

được chỉ ra trong bảng dưới đây:

Kiểu Phạm vi biểu diễn Kích thước

int -32768 đến 32767 2 byte

unsigned int 0 đến 65535 2 byte

long -2147483648 đến 2147483647 4 byte

unsigned long 0 đến 4294967295 4 byte

Bảng 2.1. Kích cỡ và phạm vi biểu diễn kiểu dữ liệu số nguyên

2.3.2. Kiểu số thực

Trong C cho phép sử dụng số thực gồm 3 kiểu: float, double và long

double. Kích cỡ và phạm vi biểu diễn của chúng được chỉ ra trong bảng dưới

đây:

Kiểu Phạm vi biểu diễn Số chữ số có nghĩa Kích thước

Float 3.4E-38 đến 3.4E+38 7 đến 8 4 byte

Double 1.7E-308 đến 1.7E+308 15 đến 16 8 byte

long double 3.4E-4932 đến 1.1E4932 17 đến 18 10 byte

Bảng 2.1. Kích cỡ và phạm vi biểu diễn kiểu số thực

Giải thích:

Máy tính có thể lưu trữ được các số kiểu float có giá trị tuyệt đối từ 3.4E-

38 đến 3.4E+38. Các số có giá trị tuyệt đối nhỏ hơn3.4E-38 được xem bằng 0.

Phạm vi biểu diễn của số double được hiểu theo nghĩa tương tự.

2.4. Các phép toán

Mục tiêu : Hiểu và có thể thực hiện các phép tính toán trong chương trình.

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

Phép toán Ý nghiã Ví dụ

+ Phép cộng a+b

- Phép trừ a-b

* Phép nhân a*b

/ Phép chia a/b (Chia số nguyên sẽ chặt phần thập phân)

% Phép lấy phần dư a%b (Cho phần dư của phép chia a cho b)

Bảng 2.1. Các phép toán số học

Có phép toán một ngôi - ví du -(a+b) sẽ đảo giá trị của phép cộng (a+b).

Ví dụ:

11/3=3

11%3=2

-(2+6)=-8

Các phép toán + và - có cùng thứ tự ưu tiên, có thứ tự ưu tiên nhỏ hơn các

phép *, /, % và cả ba phép này lại có thứ tự ưu tiên nhỏ hơn phép trừ một ngôi.

Các phép toán số học được thực hiện từ trái sang phải. Số ưu tiên và khả

năng kết hợp của phép toán được chỉ ra trong một mục sau này.

2.4.2. Các phép toán quan hệ và logic

Phép toán quan hệ và logic cho ta giá trị đúng (1) hoặc giá trị sai (0). Nói

cách khác, khi các điều kiện nêu ra là đúng thì ta nhận được giá trị 1, trái lại ta

nhận giá trị 0.

Các phép toán quan hệ:

Phép toán Ý nghĩa Ví dụ

> So sánh lớn hơn a>b

4>5 có giá trị 0

>= So sánh lớn hơn hoặc bằng a>=b

6>=2 có giá trị 1

< So sánh nhỏ hơn a<b

6<=7 có giá trị 1

<= So sánh nhỏ hơn hoặc bằng a<=b

8<=5 có giá trị 0

== So sánh bằng nhau a==b

6==6 có giá trị 1

!= So sánh khác nhau a!=b

9!=9 có giá trị 0

Bốn phép toán đầu có cùng số ưu tiên, hai phép sau có cùng số thứ tự ưu

tiên nhưng thấp hơn số thứ tự của bốn phép đầu.

Các phép toán quan hệ có số thứ tự ưu tiên thấp hơn so với các phép toán

số học, cho nên biểu thức: i<n-1 được hiểu là i<(n-1).

2.4.2.1. Các phép toán logic

Trong C sử dụng ba phép toán logic:

Phép phủ định một ngôi (!)

A !a

khác 0 0

bằng 0 1

Phép và (AND) && - Phép hoặc ( OR ) ||

a B a&&b a||b

khác 0 khác 0 1 1

khác 0 bằng 0 0 1

bằng 0 khác 0 0 1

bằng 0 bằng 0 0 0

Các phép quan hệ có số ưu tiên nhỏ hơn so với ! nhưng lớn hơn so với &&

và ||, vì vậy biểu thức sau:

(a<b)&&(c>d)

có thể viết lại thành:

a<b&&c>d

* Chú ý: Cả a và b có thể là nguyên hoặc thực.

2.4.3. Phép toán tăng giảm

C đưa ra hai phép toán một ngôi để tăng và giảm các biến (nguyên và

thực). Toán tử tăng là ++ sẽ cộng 1 vào toán hạng của nó, toán tử giảm -- thì sẽ

trừ toán hạng đi 1.

Ví dụ:

n=5

++n Cho ta n=6

--n Cho ta n=4

Ta có thể viết phép toán ++ và -- trước hoặc sau toán hạng như sau: ++n,

n++, --n, n-- 

Sự khác nhau của ++n và n++ ở chỗ: Trong phép n++ thì tăng sau khi giá

trị của nó đã được sử dụng, còn trong phép ++n thì n được tăng trước khi sử

dụng. Sự khác nhau giữa n-- và --n cũng như vậy.

Ví dụ:

n=5

x=++n Cho ta x=6 và n=6

x=n++ Cho ta x=5 và n=6

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

Các phép toán có độ ưu tiên khác nhau, điều này có ý nghĩa trong cùng một

biểu thức sẽ có một số phép toán này được thực hiện trước một số phép toán

khác.

Thứ tự ưu tiên của các phép toán được trình bày như sau:

TT Phép toán Trình tự kết hợp

1 () [] -> Trái qua phải

2 ! ~ & * - ++ -- (type ) sizeof Phải qua trái

3 * ( phép nhân ) / % Trái qua phải

4 + - Trái qua phải

5 << >> Trái qua phải

6 < <= > >= Trái qua phải

7 = = != Trái qua phải

8 & Trái qua phải

9 ^ Trái qua phải

10 | Trái qua phải

TT Phép toán Trình tự kết hợp

11 && Trái qua phải

12 || Trái qua phải

13 ?: Phải qua trái

14 = += -= *= /= %= <<= >>=

&= ^= |=

Phải qua trái

15 , Trái qua phải

Bảng 2.1. Thứ tự ưu tiên của các phép toán

Chú thích:

- Các phép toán tên một dòng có cùng thứ tự ưu tiên, các phép toán ở hàng trên có số ưu tiên cao hơn các số ở hàng dưới.

- Đối với các phép toán cùng mức ưu tiên thì trình tự tính toán có thể từ trái qua phải hay ngược lại được chỉ ra trong cột trình tự kết hợp.

Ví dụ:

*--px=*(--px) (Phải qua trái)

8/4*6=(8/4)*6 (Trái qua phải)

Nên dùng các dấu ngoặc tròn để viết biểu thức một cách chính xác.

2.5. Ghi chú

Mục tiêu : Biết cách ghi chú khi viết chương trình.

2.5.1. Ghi chú

Trong khi lập trình cần phải ghi chú để giải thích các biến, hằng, thao tác

xử lý giúp cho chương trình rõ ràng dễ hiểu, dễ nhớ, dễ sửa chữa và để người

đọc dễ hiểu. Trong C có các ghi chú sau: // hoặc /* nội dung ghi chú */

Ví dụ:

void main() { int a, b; //khai bao bien t kieu int a = 1; //gan 1 cho a b =3; //gan 3 cho b /* thuat toan tim so lon nhat la neu a lon hon b thi a lon nhat nguoc lai b lon nhat */ if (a > b) printf("max: %d", a); else printf("max: %d", b);

getch(); }

Khi biên dịch chương trình, C gặp cặp dấu ghi chú sẽ không dịch ra ngôn

ngữ máy.

Tóm lại, đối với ghi chú dạng // dùng để ghi chú một hàng và dạng /* …. */

có thể ghi chú một hàng hoặc nhiều hàng.

2.5.2. Cấu trúc chương trình C

Một chương trình C bao gồm các phần như: Các chỉ thị tiền xử lý, khai báo

biến ngoài, các hàm tự tạo, chương trình chính (hàm main).

Cấu trúc có thể như sau:

- Các chỉ thị tiền xử lý (Preprocessor directives)#include <Tên tập tin thư viện>

#define ….

Định nghĩa kiểu dữ liệu (phần này không bắt buộc): dùng để đặt tên lại

cho một kiểu dữ liệu nào đó để gợi nhớ hay đặt 1 kiểu dữ liệu cho riêng mình

dựa trên các kiểu dữ liệu đã có.

Cú pháp: typedef <Tên kiểu cũ> <Tên kiểu mới>

Ví dụ: typedef int SoNguyen; // Kiểu SoNguyen là kiểu int

Khai báo các prototype (tên hàm, các tham số, kiểu kết quả trả về,… của

các hàm sẽ cài đặt trong phần sau, phần này không bắt buộc): phần này chỉ là

các khai báo đầu hàm, không phải là phần định nghĩa hàm.

Khai báo các biến ngoài (các biến toàn cục) phần này không bắt buộc: phần

này khai báo các biến toàn cục được sử dụng trong cả chương trình.

- Chương trình chính ( phần này bắt buộc phải có)<Kiểu dữ liệu trả về> main()

{

Các khai báo cục bộ trong hàm main: Các khai báo này chỉ tồn tại trong hàm mà thôi, có thể là khai báo biến hay khai báo kiểu.Các câu lệnh dùng để định nghĩa hàm main.

return <kết quả trả về>; // Hàm phải trả về kết quả

}

Cài đặt các hàm

<Kiểu dữ liệu trả về> function1( các tham số)

{

Các khai báo cục bộ trong hàm. Các câu lệnh dùng để định nghĩa hàm.return <kết quả trả về>;}…Một chương trình C bắt đầu thực thi từ hàm main (thông thường là từ câu

lệnh đầu tiên đến câu lệnh cuối cùng).

2.6. Khai báo biến

Mục tiêu : Biết cách khai báo biến theo đúng nguyên tắc đặt tên.

2.6.1. Biến.

Mỗi biến cần phải được khai báo trước khi đưa vào sử dụng. Việc khai báo

biến được thực hiện theo mẫu sau:

Kiểu dữ liệu của biến tên biến ;

Ví dụ :

int a,b,c; Khai báo ba biến int là a,b,c

long dai,mn; Khai báo hai biến long là dai và mn

char kt1,kt2; Khai báo hai biến ký tự là kt1 và kt2

float x,y; Khai báo hai biến float là x và y

double canh; Khai báo một biến double là canh

Biến kiểu int chỉ nhận được các giá trị kiểu int. Các biến khác cũng có ý

nghĩa tương tự. Các biến kiểu char chỉ chứa được một ký tự. Để lưu trữ được

một xâu ký tự cần sử dụng một mảng kiểu char.

2.6.2. Vị trí khai báo biến trong C

Khi lập trình, chúng ta phải nắm rõ phạm vi của biến. Nếu khai báo và sử

dụng không đúng, không rõ ràng sẽ dẫn đến sai sót khó kiểm soát được, vì vậy

cần phải xác định đúng vị trí, phạm vi sử dụng biến trước khi sử dụng biến.

Khai báo biến ngoài (biến toàn cục): Vị trí biến đặt bên ngoài tất cả các

hàm, cấu trúc... Các biến này có ảnh hưởng đến toàn bộ chương trình. Chu trình

sống của nó là bắt đầu chạy chương trình đến lúc kết thúc chương trình.

Khai báo biến trong (biến cục bộ): Vị trí biến đặt bên trong hàm, cấu

trúc…. Chỉ ảnh hưởng nội bộ bên trong hàm, cấu trúc đó. Chu trình sống của nó

bắt đầu từ lúc hàm, cấu trúc được gọi thực hiện đến lúc thực hiện xong.

2.6.3. Biểu thức

Biểu thức là một sự kết hợp giữa các phép toán và các toán hạng để diễn

đạt một công thức toán học nào đó. Mỗi biểu thức có sẽ có một giá trị. Như vậy

hằng, biến, phần tử mảng và hàm cũng được xem là biểu thức.

Trong C, ta có hai khái niệm về biểu thức:

Biểu thức gán.

Biểu thức điều kiện .

Biểu thức được phân loại theo kiểu giá trị: nguyên và thực. Trong các mệnh

đề logic, biểu thức được phân thành đúng (giá trị khác 0) và sai (giá trị bằng 0).

Biểu thức thường được dùng trong:

Vế phải của câu lệnh gán.

Làm tham số thực sự của hàm.

Làm chỉ số.

Trong các toán tử của các cấu trúc điều khiển.

2.7. Nhập/xuất dữ liệu

Mục tiêu: Biết thực hiện lệnh nhập dữ liệu và xuất dữ liệu ra màn hình.

2.7.1. Lệnh gán.

Biểu thức gán là biểu thức có dạng:

v=e

Trong đó v là một biến (hay phần tử mảng), e là một biểu thức. Giá trị của

biểu thức gán là giá trị của e, kiểu của nó là kiểu của v. Nếu đặt dấu ; vào sau

biểu thức gán ta sẽ thu được phép toán gán có dạng:

v=e;

Biểu thức gán có thể sử dụng trong các phép toán và các câu lệnh như các

biểu thức khác. Ví dụ như khi ta viết

a=b=5;

thì điều đó có nghĩa là gán giá trị của biểu thức b=5 cho biến a. Kết quả là

b=5 và a=5.

Hoàn toàn tương tự như: a=b=c=d=6; gán 6 cho cả a, b, c và d

Ví dụ :

z=(y=2)*(x=6); {ở đây * là phép toán nhân}

gán 2 cho y, 6 cho x và nhân hai biểu thức lại cho ta z=12.

2.7.2. Lệnh nhập

Hàm scanf là hàm đọc thông tin từ thiết bị vào chuẩn (bàn phím), chuyển

dịch chúng (thành số nguyên, số thực, ký tự vv..) rồi lưu trữ nó vào bộ nhớ theo

các địa chỉ xác định.

Cú pháp : scanf(« chuỗi định dạng»,đối số 1, đối số 2, ...);

Khi sử dụng hàm phải khai báo tiền xử lý #include <stdio.h>

- scanf: tên hàm, phải viết bằng chữ thường.

- chuỗi định dạng: được đặt trong cặp nháy kép (" ") là hình ảnh dạng dữ

liệu nhập vào.

- đối số 1, đối số 2…: là danh sách các đối mục cách nhau bởi dấu phẩy,

mỗi đối mục sẽ tiếp nhận giá trị nhập vào.

Sau đây là các dấu mô tả định dạng:

%c : Ký tự đơn

%s : Chuỗi

%d : Số nguyên thập phân có dấu

%f : Số chấm động (ký hiệu thập phân)

%e : Số chấm động (ký hiệu có số mũ)

%g : Số chấm động (%f hay %g)

%x : Số nguyên thập phân không dấu

%u : Số nguyên hex không dấu

%o : Số nguyên bát phân không dấu

l: Tiền tố dùng kèm với %d, %u, %x, %o để chỉ số nguyên dài (ví dụ : %ld)

Ví dụ1: scanf("%d", &i);

Nhập vào 12abc, biến i chỉ nhận giá trị 12. Nhập 3.4 chỉ nhận giá trị 3.

Ví dụ 2: scanf("%d%d", &a, &b);

Nhập vào 2 số a, b phải cách nhau bằng khoảng trắng hoặc enter.

Ví dụ 3: scanf("%d/%d/%d", &ngay, &thang, &nam);

Nhập vào ngày, tháng, năm theo dạng ngay/thang/nam (20/12/2002)

2.7.3. Lệnh xuất.

Cú pháp : prinf(“chuỗi định dạng”, đối số 1, đối số 2, ...);

Khi sử dụng hàm phải khai báo tiền xử lý #include <stdio.h>

- printf: tên hàm, phải viết bằng chữ thường.

- đối số 1, đối số 2…: là các mục dữ kiện cần in ra màn hình. Các đối số

này có thể là biến, hằng hoặc biểu thức phải được định trị trước khi in ra.

- chuỗi định dạng: được đặt trong cặp nháy kép (" "), gồm 3 loại:

+ Đối với chuỗi kí tự ghi như thế nào in ra giống như vậy.

+ Đối với những kí tự chuyển đổi dạng thức cho phép kết xuất giá trị của

các đối mục ra màn hình tạm gọi là mã định dạng. (Ta đã có bảng mã định dạng

ở mục 2)

* Các ký tự điều khiển và ký tự đặc biệt :

\n : Nhảy xuống dòng kế tiếp canh về cột đầu tiên.

\t : Canh cột tab ngang.

\r : Nhảy về đầu hàng, không xuống hàng.

\a : Tiếng kêu bip.

\\ : In ra dấu \

\" : In ra dấu "

\' : In ra dấu '

%%: In ra dấu %

Ví dụ 1 : printf("\" Nang suat tang : %d % \" ",30);

Kết quả in ra màn hình :

"Nang suat tang : 30%"

Ví dụ 2 : float x=25.5, y=-47.335

printf("%f\n%*.2f",x,y);

Kết quả in ra màn hình :

25.500000

-47.34

2.8. Bài tập thực hành

1. Viết chương trình đổi một số nguyên hệ 10 sang hệ 2.

2. Viết chương trình đổi một số nguyên hệ 10 sang hệ 16.

3. Viết chương trình đọc vào 2 số nguyên và in ra kết quả của phép (+),

phép trừ (-), phép nhân (*), phép chia (/). Nhận xét kết quả chia 2 số nguyên.

4. Viết chương trình nhập vào bán kính hình cầu, tính và in ra diện tích,

thể tích của hình cầu đó. Hướng dẫn: S = 4πR2 và V = (4/3)πR3

5. Viết chương trình nhập vào một số a bất kỳ và in ra giá trị bình phương

(a2), lập phương (a3) của a và giá trị a4

6. Viết chương trình đọc từ bàn phím 3 số nguyên biểu diễn ngày, tháng,

năm và xuất ra màn hình dưới dạng "ngay/thang/nam" (chỉ lấy 2 số cuối của

năm).

7. Viết chương trình nhập vào số giây từ 0 đến 86399, đổi số giây nhập

vào thành dạng "gio:phut:giay", mỗi thành phần là một số nguyên có 2 chữ số.

Ví dụ: 02:11:05

CHƯƠNG 3: CẤU TRÚC RẼ NHÁNH CÓ ĐIỀU KIỆN

Mã chương: MH18-03

Ý nghĩa:

Như là một ngôn ngữ mệnh lệnh, C phụ thuộc vào các mệnh đề (câu lệnh)

để làm hầu hết các việc. Hầu hết các mệnh đề lại là các mệnh đề biểu thức mà

một cách đơn giản chúng tạo nên việc đánh giá các biểu thức đó -- và trong quá

trình này, các biến nhận được các giá trị mới hoặc các giá trị này được trả ra.

Các mệnh đề dòng điều khiển cũng có hiệu lực cho việc thực thi có điều kiện

hay có lặp lại, mà chúng được cấu tạo với các từ khóa như là if, else, switch, do,

while và for. Các nhảy dòng cũng có thể thực hiện qua câu lệnh goto. Nhiều

phép toán khác nhau được cung cấp sẵn để thực thi trên các phép tính cơ sản về

số học, lô gíc, so sánh, kiểu bit, chỉ số của mảng, và phép gán giá trị. Các biểu

thức cũng gọi các hàm, bao gồm một số lượng lớn các hàm thư viện, để tiến

hành các thao tác chung.

Mục tiêu:- Trình bày ý nghĩa của lệnh và khối lệnh ;- Trình bày cú pháp, công dụng của lệnh if, lệnh switch ;- Giải một số bài toán sử dụng lệnh if, lệnh switch ;- Sử dụng được các cấu trúc lồng nhau.- Thực hiện các thao tác an toàn với máy tính.

3.1. Lệnh và khối lệnh

Mục tiêu: Trình bày ý nghĩa của lệnh và khối lệnh

3.1.1. Lệnh

Là một tác vụ, biểu thức, hàm, cấu trúc điều khiển…

Ví dụ 1:

x = x + 2;printf("Day la mot lenh\n");

3.1.2. Khối lệnh

Là một dãy các câu lệnh được bọc bởi cặp dấu { }

Ví dụ 2:

{ //dau khoi a = 5;b = 6;printf("Tong %d + %d = %d", a, b, a+b);} //cuoi khoi

3.2. Lệnh if

Mục tiêu:

- Trình bày cú pháp, công dụng của lệnh if- Giải một số bài toán sử dụng lệnh if- Sử dụng được các cấu trúc if lồng nhau.- Thực hiện các thao tác an toàn với máy tính.

Câu lệnh if cho phép lựa chọn một trong hai nhánh tùy thuộc vào giá trị của

biểu thức luận lý là đúng (true) hay sai (false) hoặc khác không hay bằng không.

3.2.1. Dạng 1 (if thiếu)

Quyết định sẽ thực hiện hay không một khối lệnh.

Cú pháp lệnh

if (biểu thức luận lý) khối lệnh;

Lưu ý: Từ khóa if phải viết bằng chữ thường, kết quả của biểu thức luận lý

phải là đúng (≠ 0) hoặc sai (= 0)

Lưu đồ

Biểu thức

luận lý

Khối lệnh

Vào

Ra

Đúng

Sai

Giải thích:

Nếu biểu thức luận lý đúng thì thực hiện khối lệnh và thoát và thoát khỏi if,

ngược lại không làm gì cả khỏi if.

Lưu ý: Nếu khối lệnh bao gồm từ 2 lệnh trở lên thì phải đặt trong dấu { }

3.2.2. Bài tập thực hành

1.Viết chương trình nhập vào số nguyên dương, in ra thông báo số chẵn

hay lẻ.

H ư ớng dẫ n : Nhập vào số nguyên dương x. Kiểm tra nếu x chia hết cho 2

thì x là số chẵn (hoặc chia cho 2 dư 0), nếu x không chia hết cho 2 (hoặc chia cho

2 dư 1) là số lẻ.

2.Viết chương trình nhập vào 4 số nguyên. Tìm và in ra số lớn nhất.

H ư ớng dẫn : Ta có 4 số nguyên a, b, c, d. Tìm 2 số nguyên lớn nhất x, y

của 2 cặp (a, b) và (c, d). Sau đó so sánh 2 số nguyên x, y để tìm ra số nguyên

lớn nhất.

3.2.3. Dạng 2 (if đủ)

Quyết định sẽ thực hiện 1 trong 2 khối lệnh cho trước.

Cú pháp lệnh

if (biểu thức luận lý) khối lệnh 1 else khối lệnh 2;

Lưu đồ

Biểu thức

luận lý

Khối lệnh 1

Vào

Ra

Đúng Sai

Khối lệnh 2

Giải thích:

Nếu biểu thức luận lý đúng thì hực hiện khối lệnh 1 và thoát khỏi if ngược lại

thực hiện khối lệnh 2 và thoát khỏi if.

3.2.4. Bài tập thực hành

1.Viết chương trình nhập vào số nguyên dương, in ra thông báo số chẵn

hay lẻ.

H ư ớng dẫ n : Nhập vào số nguyên dương x. Kiểm tra nếu x chia chẵn cho

hai thì x là số chẵn (hoặc chia cho 2 dư 0) ngược lại là số lẻ.

2.Viết chương trình nhập vào 4 số nguyên. Tìm và in ra số lớn nhất.

H ư ớng dẫn : Ta có 4 số nguyên a, b, c, d. Tìm 2 số nguyên lớn nhất x, y

của 2 cặp (a, b) và (c, d). Sau đó so sánh 2 số nguyên x, y để tìm ra số nguyên

lớn nhất.

3.2.5. Cấu trúc else if

Quyết định sẽ thực hiện 1 trong n khối lệnh cho trước.

Cú pháp lệnh:

if (biểu thức luận lý 1) khối lệnh 1;

else if (biểu thức luận lý 2)

khối lệnh 2; …

else if (biểu thức luận lý n-1)

khối lệnh n-1;

else

khối lệnh n;

Lưu đồ:

Giải thích:

Nếu biểu thức luận lý 1 đúng thì thực hiện khối lệnh 1 và thoát khỏi cấu

trúc if

Ngược lại Nếu biểu thức luận lý 2 đúng thì thực hiện khối lệnh 2 và thoát

khỏi cấu trúc if

…

Ngược lại Nếu biểu thức luận lý n-1 đúng thì thực hiện khối lệnh n-1 và

thoát khỏi cấu trúc if

Ngược lại thì thực hiện khối lệnh n.

3.2.6. Bài tập thực hành

1. Viết chương trình giải phương trình bậc 2: ax2 + bx + c = 0, với a, b, c

nhập vào từ bàn phím.

H ư ớng dẫ n : Nhập vào 3 biến a, b, c. Tính Delta = b*b - 4*a*c

Nếu Delta < 0 thì

Phương trình vô nghiệm

Ngược lại

Nếu Delta = 0 thì

x1 = x2 = - b/(2*a) Ngược lại

x1 = (- b - sqrt(Delta))/(2*a)

x2 = (- b + sqrt(Delta))/(2*a) Hết Nếu

Hết Nếu

2. Viết chương trình nhập vào giờ phút giây (hh:mm:ss). Cộng thêm số

giây nhập vào và in ra kết quả dưới dạng hh:mm:ss.

H ư ớng dẫn : Nhập vào giờ phút giây vào 3 biến gio, phut, giay và nhập và

giây công thêm vào biến them:

Nếu giay + them < 60 thì giay = giay + them

Ngược lại

giay = (giay + them) - 60 phut = phut + 1

Nếu phut >= 60 thì

phut = phut - 60 gio = gio + 1

Hết nếu

Hết nếu

3.2.7. Cấu trúc if lồng nhau

Quyết định sẽ thực hiện 1 trong n khối lệnh cho trước.

Cú pháp lệnh

Cú pháp là một trong 3 dạng trên, nhưng trong 1 hoặc nhiều khối lệnh

bên trong phải chứa ít nhất một trong 3 dạng trên gọi là cấu trúc if lồng nhau.

Thường cấu trúc if lồng nhau càng nhiều cấp độ phức tạp càng cao, chương

trình chạy càng chậm và trong lúc lập trình dễ bị nhầm lẫn.

Chú ý: Các lệnh if…else lồng nhau thì else sẽ luôn luôn kết hợp với if nào

chưa có else gần nhất. Vì vậy khi gặp những lệnh if không có else, Bạn phải đặt

chúng trong những khối lệnh rõ ràng để tránh bị hiểu sai câu lệnh.

Ví dụ: Viết chương trình nhập vào 2 số nguyên a và b . Nếu a > b thì hoán

đổi giá trị a và b , ngược lại không hoán đổi.In ra giá trị của a và b.

/*Chuong trinh nhap vao 2 so nguyen a va bNeu a>b thi hoan doi gia tri a va b,nguoc lai khong hoan

doiIn ra man hinh a va b*/#include<stdio.h>#include<conio.h>

void main(void){ int ia,ib,itam;//Khai bao cac bien //Nhap vao ia printf("a="); scanf("%d",&ia); //Nhap vao ib printf("b="); scanf("%d",&ib); if(ia>ib) { //Hoan vi a va b tam=ia; ia=ib; b=itam; } printf("a=%d ; b=%d\n",ia,ib); getch();

}

3.2.8. Bài tập thực hành

1. Viết chương trình giải phương trình bậc 1: ax + b = 0, với a, b nhập

vào từ bàn phím.

Hướng dẫn: Nhập vào 2 biến a, b

Nếu a=0 thì (xét hệ số b)

Nếu b=0 thì kết luận phương trình vô số nghiệm

Ngược lại thì kết luận phương trình vô nghiệm

Ngược lại (hệ số a#0), kết luận phương trình có 1 nghiệm x=-b/a

3.3. Lệnh switch()

Mục tiêu:

- Trình bày cú pháp, công dụng của lệnh switch ;- Giải một số bài toán sử dụng lệnh switch ;- Sử dụng được các cấu trúc switch lồng nhau.- Thực hiện các thao tác an toàn với máy tính.

Lệnh switch cũng giống cấu trúc else if, nhưng nó mềm dẻo hơn và linh

động hơn nhiều so với sử dụng if. Tuy nhiên, nó cũng có mặt hạn chế là kết quả

của biểu thức phải là giá trị hằng nguyên (có giá trị cụ thể). Một bài toán sử

dụng lệnh switch thì cũng có thể sử dụng if, nhưng ngược lại còn tùy thuộc vào

giải thuật của bài toán.

3.3.1. Cấu trúc switch…case (switch thiếu)

Chọn thực hiện 1 trong n lệnh cho trước.

Cú pháp lệnh

switch (biểu thức){case giá trị 1 : lệnh 1;break;case giá trị 2 : lệnh 2; break;

…case giá trị n : lệnh n; [break;]}

Lưu ý: từ khóa switch, case, break phải viết bằng chữ thường; biểu thức

phải là có kết quả là giá trị hằng nguyên (char, int, long,…); Lệnh 1, 2…n có thể

gồm nhiều lệnh, nhưng không cần đặt trong cặp dấu { }

Lưu đồ

Khi giá trị của biểu thức bằng giá trị i thì lệnh i sẽ được thực hiện. Nếu sau

lệnh i không có lệnh break thì sẽ tiếp tục thực hiện lệnh i + 1…Ngược lại thoát

khỏi cấu trúc switch.

Ví dụ: Viết chương trình nhập vào một tháng và cho biết tháng đó thuộc

quý mấy.

/* Chương trình nhập vào một tháng và in ra quý của tháng đó*/#include<conio.h>#include<stdio.h>void main(void){

int iThang; //Nhập vào tháng printf("Thang : "); scanf("%d",&iThang); //Kiểm tra tháng thuộc quý nào để nhập vào if(iThang>0 && iThang<=12) { switch(iThang) { case 1 : case 2 : case 3 : printf("Thang %d thuoc quy 1\n",iThang); break; case 4 : case 5 : case 6 : printf("Thang %d thuoc quy 2\n",iThang); break; case 7 : case 8 : case 9 : printf("Thang %d thuoc quy 3\n",iThang); break; case 10 : case 11 : case 12 : printf("Thang %d thuoc quy 4\n",iThang); break; } } else printf("Thang ban nhap vao khong hop le\n");

getch();}

3.3.2. Bài tập thực hành

1.Viết chương trình nhập vào tháng, in ra tháng đó có bao nhiêu ngày.

H ư ớng dẫ n : Nhập vào tháng

Nếu là tháng 1, 3, 5, 7, 8, 10, 12 thì có 30 ngày

Nếu là tháng 4, 6, 9, 11 thì có 31 ngày

Nếu là tháng 2 và là năm nhuận thì có 29 ngày ngược lại 28 ngày

(Năm nhuận là năm chia chẵn cho 4)

2. Viết chương trình xác định biến ký tự color rồi in ra thông báo

- RED, nếu color = 'R' hoặc color = 'r'

- GREEN, nếu color = 'G' hoặc color = 'g'

- BLUE, nếu color = 'B' hoặc color = 'b'

- BLACK, nếu color = 'K' hoặc color = 'l'

3.3.3. Cấu trúc switch…case…default (switch đủ)

Chọn thực hiện 1 trong n + 1 lệnh cho trước.

Cú pháp lệnh

switch (biểu thức)

{

case giá trị 1 : lệnh 1; break;

case giá trị 2 : lệnh 2; break;

…

case giá trị n : lệnh n; break;

default : lệnh; [break;]

}

Lưu ý:

- Từ khóa switch, case, break , default phải viết bằng chữ thường.- Biểu thức phải là có kết quả là giá trị nguyên (char, int, long,…)- Lệnh 1, 2 .. n có thể gồm nhiều lệnh, nhưng không cần đặt trong dấu {}

Lưu đồ

Ví dụ: Viết lại ví dụ trên sử dụng switch đủ

/* Chương trình nhập vào một tháng và in ra quý của tháng đó*/#include<conio.h>#include<stdio.h>void main(void){ int iThang; //Nhập vào tháng printf("Thang : "); scanf("%d",&iThang); //Kiểm tra tháng thuộc quý nào để nhập vào { switch(iThang) { case 1 : case 2 : case 3 : printf("Thang %d thuoc quy 1\n",iThang);

break; case 4 : case 5 : case 6 : printf("Thang %d thuoc quy 2\n",iThang); break; case 7 : case 8 : case 9 : printf("Thang %d thuoc quy 3\n",iThang); break; case 10 : case 11 : case 12 : printf("Thang %d thuoc quy 4\n",iThang); break; default : printf("Ban nhap vao thang khong hop le"); break; } } getch();}

3.3.4. Bài tập thực hành

1. Viết chương trình xác định biến ký tự color rồi in ra thông báo

- RED, nếu color = 'R' hoặc color = 'r'

- GREEN, nếu color = 'G' hoặc color = 'g'

- BLUE, nếu color = 'B' hoặc color = 'b'

- BLACK, nếu color có giá trị khác.

3.3.5. Cấu trúc switch lồng

Quyết định sẽ thực hiện 1 trong n khối lệnh cho trước.

Cú pháp lệnh:

Cú pháp là một trong 2 dạng trên, nhưng trong một nhiều lệnh bên trong

phải chứa ít nhất 1 trong 2 dạng trên. Switch lồng có cấp độ càng cao thì thì

chương trình càng phức tạp và chạy chậm và trong lúc lập trình sẽ dễ phát sinh

nhầm lẫn.

Lưu đồ:

Tương tự 2 dạng trên nhưng trong mỗi lệnh có thể có một hay nhiều cấu

trúc switch ở hai dạng trên.

Ví dụ : Viết chương trình menu 2 cấp

/* Chương trình menu 2 cấp*/#include<conio.h>#include<stdio.h>void main(void){ int iMenu,iSunMenu; //In menu printf(-----------------------------\n); printf( MAIN MENU \n); printf(------------------------------\n); printf("1.File\n"); printf("2.Edit\n"); printf("3.Search\n");

//Lua chon chuc nang printf("Moi ban chon chuc nang : "); scanf(("%d",&iMenu);

//Kiem tra chuc nang nhap vao switch(iMenu) { case 1 : printf("Ban da chon chuc nang File\n"); printf(-----------------------------\n); printf( MENU FILE \n); printf(------------------------------\n); printf("1.New\n"); printf("2.Open\n"); //Lua chon chuc nang printf("Moi ban chon chuc nang : "); scanf(("%d",&iSubMenu); //Kiem tra chuc nang da nhap vao switch(iSubMenu) { case 1 : printf("Ban da chon chuc nang New\n"); break; case 2 : printf("Ban da chon chuc nang Open\n"); break; default : printf("Chuc nang ban chon khong co\n"); break; }

break; case 2 : printf("Ban da chon chuc nang Edit\n"); break; case 3 : printf("Ban da chon chuc nang Search\n"); break; default : printf("Chuc nang ban chon khong co\n"); break; } getch();}

3.3.6. Bài tập thực hành

1.Viết chương trình trò chơi One-Two-Three ra cái gì ra cái này theo điều

kiện:

- Búa (B) thắng Kéo, thua Giấy.

- Kéo (K) thắng Giấy, thua Búa.

- Giấy (G) thắng Búa, thua Kéo.

H ư ớng dẫn : Dùng lệnh switch lồng nhau

CHƯƠNG 4: CẤU TRÚC VÒNG LẶP

Mã chương/ bài:MH18-04

Mục tiêu:

- Trình bày ý nghĩa của vòng lặp ;- Trình bày cú pháp, công dụng của lệnh for, while, do…while;- Trình bày ý nghĩa và cách sử dụng lệnh break, continue;- Giải một số bài toán sử dụng lệnh for, while, do…while ;- Sử dụng được các vòng lặp lồng nhau.- Thực hiện các thao tác an toàn với máy tính.

4.1. Lệnh for

Mục tiêu: Hiểu cú pháp và có thể vận dụng vòng lặp for để giải quyết bài

toán.

Cú pháp : for ( biểu thức 1; biểu thức 2; biểu thức 3)

Lệnh hoặc khối lệnh ;

Giải thích :

+ Biểu thức 1: khởi tạo giá trị ban đầu cho biến điều khiển.

+ Biểu thức 2: là quan hệ logic thể hiện điều kiện tiếp tục vòng lặp.

+ Biểu thức 3: phép gán dùng thay đổi giá trị biến điều khiển.

Lưu ý :

+ Từ khóa for phải viết bằng chữ thường

+ Nếu là khối lệnh thì phải đặt trong dấu { }

+ Biểu thức 1, 2, 3 phải phân cách bằng dấu chấm phẩy (;)

+ Nếu biểu thức 2 không có, vòng for được xem là luôn luôn đúng.

Muốn thoát khỏi vòng lặp for phải dùng một trong 3 lệnh break, goto hoặc

return.

+ Với mỗi biểu thức có thể viết thành một dãy biểu thức con phân cách

nhau bởi dấu phẩy. Khi đó các biểu thức con được xác định từ trái sang phải.

Tính đúng sai của dãy biểu thức con trong biểu thức thứ 2 được xác định bởi

biểu thức con cuối cùng.

+ Trong thân for (khối lệnh) có thể chứa một hoặc nhiều cấu trúc điều

khiển khác.

+ Khi gặp lệnh break, cấu trúc lặp sâu nhất sẽ thoát ra.

+ Trong thân for có thể dùng lệnh goto để thoát khỏi vòng lặp đến vị trí

mong muốn.

+ Trong thân for có thể sử dụng return để trở về một hàm nào đó.

+ Trong thân for có thể sử dụng lệnh continue để chuyển đến đầu vòng

lặp (bỏ qua các câu lệnh còn lại trong thân).

Ví dụ : Nhập n và tính tổng S = 1 + 2 + …..+ n

#include <stdio.h> #include <conio.h> void main() { int i, n, s = 0; printf("Nhap vao so n: "); scanf("%d", &n); i = 0; for(i = 0; i<=n; i++) s = s + i; //hoac s += i; printf("Tong: %d", s); getch(); }

Bài tập : Dùng vòng lặp for để :1. Viết chương trình tính tổng bình phương các số lẻ từ 1 đến N. (N nhập

vào từ bàn phím) .

2. Viết chương trình nhập vào N rồi tính giai thừa của N. (N nhập vào từ

bàn phím).

3. Hãy làm theo yêu cầu sau:

-Viết chương trình kiểm tra n có phải là số nguyên tố hay không, với số n

được nhập vào từ bàn phím

-Viết chương trình nhập vào số n và in ra các số nguyên tố có từ 1-> n, đếm

có bao nhiêu số nguyên tố như vậy.

4. Tính các tổng sau:

S=1+2+3+…+n

S= 12+22+3+2+…+n2

S=1/1+1/2+1/3+…+1/n

5. Viết chương trình in ra các số từ 1 đến 100 theo dạng sau:

1 2... .............10

11 12 13...............20

...................................

92 93............ 100

Hướng dẫn3.Thuật toán:

- Khai báo biến n, i- Nhập số n- Thuật toán kiểm tra n có phải là số nguyên tố không:

o Cho i chạy từ 2 đến n Nếu n%i = 0 thì thoát;

o Nếu i = n thì in ra màn hình n là số nguyên tốo Ngược lại, n không phải là số nguyên tố

Thuật toán:- Khai báo biến n, i, j- Nhập số n- Tìm các số nguyên tố có được từ 1->n:

o Khởi tạo biến đếm count=0o Cho i chạy từ 2 đến n

Cho j chạy từ 2 đến i Nếu i%j = 0 thì thoát

Nếu j=i thì: i là số nguyên tố count=count+1;

- In giá trị count và các số nguyên tố tìm được ra màn hìnhChương trình:

4.Thuật toán:

- Khai báo biến S, i, n- Nhập n từ bàn phím- Tính tổng S:

o S=0o Cho i chạy từ 1 đến n

S=S+i- Xuất S ra màn hình

Thuật toán:- Khai báo biến S, i, n- Nhập n từ bàn phím- Tính tổng S:

o S=0o Cho i chạy từ 1 đến n

S=S+i*i hoặc S=S+pow(i,2)- Xuất S ra màn hình

Thuật toán:- Khai báo biến S, i, n- Nhập n từ bàn phím- Tính tổng S:

o S=0o Cho i chạy từ 1 đến n

S=S+1/i- Xuất S ra màn hình

5:Thuật toán:

- Khai báo biến i- Tạo bảng số:

o Cho i chạy từ 1 đến 100 làm Nếu i%10= =1 thì in xuống dòng và i ra màn hình Ngược lại, in giá trị i ra màn hình

4.2. Lệnh break

Mục tiêu: Hiểu và biết cách sử dụng lệnh break trong chương trình.

Thông thường lệnh break dùng để thoát khỏi vòng lặp không xác định điều

kiện dừng hoặc người dùng muốn dừng vòng lặp theo điều kiện do người dùng

chỉ định. Việc dùng lệnh break để thoát khỏi vòng lặp thường sử dụng phối hợp

với lệnh if. Lệnh break dùng trong for, while, do…while, switch. Lệnh break

thoát khỏi vòng lặp chứa nó.

Ví dụ: Viết chương trình đọc từ bàn phím một số nguyên n (1≤n≤10) rồi

đưa ra tiếng Anh của số đó. Chẳng hạn, nếu gõ vào n = 4 thì in ra Four.

#include<stdio.h>#include<conio.h>#include<string.h>main(){

clrscr();//khai bao bienint so;char *kq;//nhap tuoiprintf("nhap so bat ky nam trong khoang [1,10]: ");scanf("%d",&so);///chuyen so vua nhap sang tieng anhswitch(so){

case 1: kq="One";break;case 2: kq="Two";break;case 3: kq="Three";break;case 4: kq="Four";break;case 5: kq="Five";break;case 6: kq="Six";break;case 7: kq="Seven";break;case 8: kq="Eight";break;case 9: kq="Nine";break;case 10: kq="Ten";break;

}printf("Trong tieng Anh\n");printf("%d : %s",so,kq);getch();

}

Sử dụng lệnh break trong switch để nhảy bỏ các câu lệnh kế tiếp còn lại.

4.3. Lệnh continue

Mục tiêu: Hiểu và biết cách sử dụng lệnh break trong chương trình.

Được dùng trong vòng lặp for, while, do…while. Khi lệnh continue thi

hành thì quyền điều khiển sẽ trao qua cho biểu thức điều kiện của vòng lặp gần

nhất. Nghĩa là lộn ngược lên đầu vòng lặp, tất cả những lệnh đi sau trong vòng

lặp chứa continue sẽ bị bỏ qua không thi hành.

4.4. Lệnh while

Mục tiêu: Hiểu và biết cách sử dụng vòng lặp while khi giải quyết bài

toán.

Cú pháp : while (biểu thức)

Khối lệnh;

Giải thích :

+ Biểu thức: có thể là một biểu thức hoặc nhiều biểu thức con. Nếu là nhiều

biểu thức con thì cách nhau bởi dấu phẩy (,) và tính đúng sai của biểu thức được

quyết định bởi biểu thức con cuối cùng.

+ Trong thân while (khối lệnh) có thể chứa một hoặc nhiều cấu trúc điều

khiển khác.

+ Trong thân while có thể sử dụng lệnh continue để chuyển đến đầu vòng

lặp (bỏ qua các câu lệnh còn lại trong thân).

+ Muốn thoát khỏi vòng lặp while tùy ý có thể dùng các lệnh break, goto,

return như lệnh for.

Chú ý:

Từ khóa while phải viết bằng chữ thường

Nếu khối lệnh bao gồm từ 2 lệnh trở lên thì phải đặt trong dấu { }

Ví dụ: Viết chương trình nhập vào một số n và in ra tổng các số đó

#include <stdio.h>main(){

int n,s;printf("\n Chuong trinh tinh tong cac so tu nhien tu

1 den");scanf("%d",&n);s=0;while(n>0)

{s=s+n;n=n-1;

}printf(“\nTong tim duoc la: %d”,s);

getch();}

Bài tập: Dùng vòng lặp while để:1. Viết chương trình tính tổng bình phương các số lẻ từ 1 đến N.

2. Viết chương trình nhập vào N rồi tính giai thừa của N.

3. Hãy làm theo yêu cầu sau:

-Viết chương trình kiểm tra n có phải là số nguyên tố hay không, với số n

được nhập vào từ bàn phím

-Viết chương trình nhập vào số n và in ra các số nguyên tố có từ 1-> n, đếm

có bao nhiêu số nguyên tố như vậy.

4. Tính các tổng sau:

S=1+2+3+…+n

S= 12+22+32+…+n2

S=1/1+1/2+1/3+…+1/n

5. Viết chương trình in ra các số từ 1 đến 100 theo dạng sau:

1 2... .............10

11 12 13...............20

...................................

92 93............ 100

4.5. Lệnh do..while

Mục tiêu: Hiểu và biết cách sử dụng vòng lặp do..while khi giải quyết bài

toán.

Cú pháp:

do

khối lệnh;

while (biểu thức);

Giải thích:

+ Biểu thức: có thể là một biểu thức hoặc nhiều biểu thức con. Nếu là nhiều

biểu thức con thì cách nhau bởi dấu phẩy (,) và tính đúng sai của biểu thức được

quyết định bởi biểu thức con cuối cùng.

+ Trong thân do…while (khối lệnh) có thể chứa một hoặc nhiều cấu trúc

điều khiển khác.

+ Trong thân do…while có thể sử dụng lệnh continue để chuyển đến đầu

vòng lặp (bỏ qua các câu lệnh còn lại trong thân).

+ Muốn thoát khỏi vòng lặp do…while tùy ý có thể dùng các lệnh break,

goto, return.

Chú ý:

Từ khóa do, while phải viết bằng chữ thường

Nếu khối lệnh bao gồm từ 2 lệnh trở lên thì phải đặt trong dấu { }

Ví dụ : Viết chương trình nhập vào một số n và in ra tổng các số đó (sinh

viên tự làm)

Bài tập: Dùng vòng lặp do..while để:1. Viết chương trình tính tổng bình phương các số lẻ từ 1 đến N.

2. Viết chương trình nhập vào N rồi tính giai thừa của N.

3. Hãy làm theo yêu cầu sau:

-Viết chương trình kiểm tra n có phải là số nguyên tố hay không, với số n

được nhập vào từ bàn phím

-Viết chương trình nhập vào số n và in ra các số nguyên tố có từ 1-> n, đếm

có bao nhiêu số nguyên tố như vậy.

4. Tính các tổng sau:

S=1+2+3+…+n

S= 12+22+32+…+n2

S=1/1+1/2+1/3+…+1/n

5. Viết chương trình in ra các số từ 1 đến 100 theo dạng sau:

1 2... .............10

11 12 13...............20

...................................

92 93............ 100

4.6. Vòng lặp lồng nhau

Mục tiêu: Biết cách kết hợp để các vòng lặp lồng nhau khi giải quyết bài

toán có tính phức tạp.

Các lệnh lặp for, while, do…while có thể lồng vào chính nó, hoặc lồng vào

lẫn nhau. Nếu không cần thiết không nên lồng vào nhiều cấp dễ gây nhầm lẫn

khi lập trình cũng như kiểm soát chương trình.

Ví dụ : Vẽ hình chữ nhật đặc bằng các dấu '*'

#include <stdio.h> #include <conio.h> void main(void) { int i, ij, idai, irong; printf("Nhap vao chieu dai: "); scanf("%d", &idai); printf("Nhap vao chieu rong: "); scanf("%d", &irong); for (i = 1; i <= irong; i++) { for (ij = 1; ij <= idai; ij++)

//in mot hang voi chieu dai dau * printf("*"); printf("\n");

}getch();}

Bài tập : Sử dụng vòng lặp lồng nhau để :1. Viết chương trình in các số nguyên tố từ 1 đến n.(n được nhập từ bàn

phím)

2. Viết chương trình tính :

S = 1 + 2! + 3! +...+n!

4.7. So sánh sự khác nhau của các vòng lặp.

Mục tiêu: Hiểu và biết ở trường hợp nào thì dùng vòng lặp nào để giải

quyết các bài toán.

- Vòng lặp for thường sử dụng khi biết được số lần lặp xác định.

- Vòng lặp thường while, do…while sử dụng khi không biết rõ số lần lặp.

- Khi gọi vòng lặp while, do…while, nếu biểu thức sai vòng lặp while sẽ

không được thực hiện lần nào nhưng vòng lặp do…while thực hiện được 1 lần

Số lần thực hiện ít nhất của while là 0 và của do…while là 1.

4.8. Bài tập thực hành

1. Viết chương trình in ra bảng mã ASCII

2. Viết chương trình nhập vào một số nguyên rồi in ra tất cả các ước số của

số đó.

3. Viết chương trình vẽ một tam giác cân bằng các dấu *

4. Viết chương trình tính tổng nghịch đảo của N số nguyên đầu tiên theo

công thức : S = 1 + 1/2 + 1/3 + … + 1/N

5. Viết chương trình tìm USCLN, BSCNN của 2 số.

6. Viết chương trình vẽ một tam giác cân rỗng bằng các dấu *.

7. Viết chương trình vẽ hình chữ nhật rỗng bằng các dấu *.

8. Viết chương trình nhập vào một số và kiểm tra xem số đó có phải là số

nguyên tố hay không?

9. Viết chương trình tính xn với x, n được nhập vào từ bàn phím.

10. Viết chương trình lặp lại nhiều lần công việc nhập một ký tự và in ra

mã ASCII của ký tự đó, khi nào nhập số 0 thì dừng.

CHƯƠNG 5: HÀM

Mã chương: MH18-05

Ý nghĩa:Chương trình viết bằng ngôn ngữ C gồm 1 dãy các hàm trong đó có 1 hàm

chính là main và chương trình bắt đầu từ main.

Mục tiêu:- Trình bày khái niệm và cách khai báo về hàm ;- Trình bày được cách truyền tham số, tham biến, tham trị ;- Sử dụng biến cục bộ, toàn cục trong hàm ;- Sử dụng tiền xử lý #define.- Thực hiện các thao tác an toàn với máy tính.

5.1. Các ví dụ về hàm

Mục tiêu:

- Trình bày khái niệm và cách khai báo về hàm ;- Thực hiện các thao tác an toàn với máy tính.

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

Trong những chương trình lớn, có thể có những đoạn chương trình viết

lặp đi lặp lại nhiều lần, để tránh rườm rà và mất thời gian khi viết chương

trình; người ta thường phân chia chương trình thành nhiều module, mỗi

module giải quyết một công việc nào đó. Các module như vậy gọi là các

chương trình con.

Một tiện lợi khác của việc sử dụng chương trình con là ta có thể dễ dàng

kiểm tra xác định tính đúng đắn của nó trước khi ráp nối vào chương trình chính

và do đó việc xác định sai sót để tiến hành hiệu đính trong chương trình chính sẽ

thuận lợi hơ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 và hàm tự định nghĩa. Trong chương này, ta

chú trọng đến cách định nghĩa hàm và cách sử dụng các hàm đó.

Một hàm khi được định nghĩa thì có thể sử dụng bất cứ đâu trong chương

trình. Trong C, một chương trình bắt đầu thực thi bằng hàm main.

Ví dụ 1: Ta có hàm max để tìm số lớn giữa 2 số nguyên a, b như sau:

int max(int a, int b){

return (a>b) ? a:b;}

Ví dụ 2: Ta có chương trình chính (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ố

#include <stdio.h>#include <conio.h>int max(int a, int b){

return (a>b) ? a:b;}

void main(){

int a, b, c;printf("\n Nhap vao 3 so a, b,c ");scanf("%d%d%d",&a,&b,&c);printf("\n So lon la %d",max(a, max(b,c)));getch();

}

Hàm thư việ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>

Một số thư viện:

alloc.h assert.h bcd.h bios.h complex.h

conio.h ctype.h dir.h dirent.h dos.h

errno.h fcntl.h float.h fstream.h grneric.h

graphics.h io.h iomanip.h iostream.h limits.h

locale.h malloc.h math.h mem.h process.h

setjmp.h share.h signal.h stdarg.h stddef.h

stdio.h stdiostr.h stdlib.h stream.h string.h

strstrea.h sys\stat.h sys\timeb.h sys\types.h time.h

values.h

Ý nghĩa của một số thư viện thường 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 theo đúng cú pháp (xem trong phần trợ giúp của Turbo C).

Hàm người 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.

5.1.2. Các ví dụ về hàm

Ví d ụ 1 :

12345678910111213141516171819202122

#include <stdio.h>#include <conio.h>

// khai bao prototype void line();

// ham in 1 dong dau void line(){

int i;for(i = 0; i < 19; i++)

printf("*");printf("\n");

}

void main(void){

line();printf("* Minh hoa ve ham *");line();getch();

}

Giải thích chương trình

Dòng 8 đến dòng 14: định nghĩa hàm line, hàm này không trả về giá trị,

thực hiện công việc in ra 19 dấu sao.

Dòng 5: khai báo prototype, sau tên hàm phải có dấu chấm phẩy

Trong hàm line có sử dụng biến i, biến i là biến cục bộ chỉ sử dụng được

trong phạm vi hàm line. Dòng 18 và 20: gọi thực hiện hàm line.

* Trình tự thực hiện chương trình

Không có dấu chấm phẩy sau tên hàm, phải có cặp dấu ngoặc ( ) sau tên

hàm nếu hàm không có tham số truyền vào. Phải có dấu chấm phẩy sau tên hàm

khai báo prototype. Nên khai báo prototype cho dù hàm được gọi nằm trước hay

sau câu lệnh gọi nó.

Ví d ụ 2 :

1234567891011121314151617181920

#include <stdio.h>#include <conio.h>

// khai bao prototype int power(int, int);

// ham tinh so muint power(int ix, int in){

int i, ip = 1;for(i = 1; i <= in; i++)

ip *= ix;return ip;

}

void main(void){

printf("2 mu 2 = %d.\n", power(2, 2));printf("2 mu 3 = %d.\n", power(2, 3));getch();

}

Kết quả in ra màn hình

2 mu 2 = 4.

2 mu 3 = 8.

Giải thích chương trình

Hàm power có hai tham số truyền vào là ix, in có kiểu int và kiểu trả về

cũng có kiểu int. Dòng 13: return ip: trả về giá trị sau khi tính toán

Dòng 18: đối mục 2 và 3 có kiểu trả về là int sau khi thực hiện gọi power.

Hai tham số ix, in của hàm power là dạng truyền tham trị.

* Trình tự thực hiện chương trình

trả về giá trị kiểu int để xuất ra màn hình

Quy tắc đặt tên hàm giống tên biến, hằng… Mỗi đối số cách nhau = dấu

phẩy kèm theo kiểu dữ liệu tương ứng.

Ví dụ 3:

123456789101112131415161718

#include <stdio.h>#include <conio.h>// khai bao prototype void time(int & , int &);// ham doi phut thanh gio:phut void time(int &ig, int &ip){

ig = ip / 60;ip %= 60;

}void main(void){ int igio, iphut;

printf("Nhap vao so phut : ");scanf("%d", &iphut); time(igio, iphut);printf("%02d:%02d\n", igio, iphut); getch();

}

Kết quả in ra màn hình

Nhap vao so phut: 185

03:05

Giải thích chương trình

Hàm time có hai tham số truyền vào là ix, in có kiểu int. 2 tham số này có

toán tử địa chỉ & đi trước cho biết 2 tham số này là dạng truyền tham biến.

5.2. THAM SỐ DẠNG THAM BIẾN VÀ THAM TRỊ

Mục tiêu:

- Trình bày được cách truyền tham số, tham biến, tham trị ;- Thực hiện các thao tác an toàn với máy tính.

5.2.1. Tham số dạng tham trị

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ử ta muốn in ra nhiều dòng, mỗi dòng 50 ký tự nào đó. Để

đơn giản ta viết một hàm, nhiệm vụ của hàm này là in ra trên một dòng 50 ký tự

nào đó. Hàm này có tên là InKT.

#include <stdio.h>#include <conio.h>void InKT(char ch){

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

}int main(){

char c = ‘A’;InKT(‘*’); /* In ra 50 dau * */ InKT(‘+’);InKT(c);return 0;

}

Chú ý:

- Trong hàm InKT ở trên, biến ch gọi là tham số hình thức được truyền

bằng giá trị (gọi là tham trị của hàm). Các tham trị của hàm coi như là một

biến cục bộ trong hàm và chúng được sử dụng như là dữ 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 giá trị là bản sao giá trị của tham số thực. Do đó, mặc dù tham trị cũng là

biến, nhưng 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 ảnh hưởng đến chương trình chính, nghĩa là không làm ảnh

hưởng đến tham số thực tương ứng.

Ví dụ 2: Ta xét chương trình sau đây:

#include <stdio.h>#include <conio.h>int hoanvi(int a, int b){

int t;t=a; /*Đoạn này hoán vị giá trị của 2 biến a, b*/a=b;b=t;printf("\Ben trong ham a=%d , b=%d",a,b);return 0;

}void main(){

int a, b;clrscr();printf("\n Nhap vao 2 so nguyen a, b:");scanf("%d%d",&a,&b);printf("\n Truoc khi goi ham hoan vi a=%d, b=%d", a,

b);hoanvi(a,b);printf("\n Sau khi goi ham hoan vi a=%d ,b=%d",a,b);getch();

}Kết quả thực hiện chương trình:

Giải thích:

- Nhập vào 2 số 6 và 5 (a=6, b=5)

- Trước khi gọi hàm hoán vị thì a=6, b=5- Bên trong hàm hoán vị a=5, b=6- Khi ra khỏi hàm hoán vị thì a=6, b=5

5.2.2. Bài tập thực hành về tham trị

1. Viết chương trình giải phương trình bậc nhất ax+b=0.

Hướng dẫn:

- Xây dựng hàm giải phương trình bậc nhất: void giaiptb1(int a, int b)- Truyền tham trị cho hàm giaiptb1(int a, int b)- Gọi hàm giaiptb1(int a, int b) vừa xây dựng thực hiện trong chương trình

chính2. Viết chương trình tính tổng các số nguyên chẵn từ 1 đến n.

Hướng dẫn:

- Xây dựng hàm tính tổng các số nguyên chẵn từ 1 đến n: int tinhtongchan (int n)- Truyền tham trị cho hàm int tinhtongchan (int n)- Gọi hàm tinhtongchan (int n) vừa xây dựng thực hiện trong chương trình

chính5.2.3. Tham số dạng tham biến

Trong đoạn chương trình trên, nếu ta muốn sau khi kết thúc chương trình

con giá trị của a, b thay đổi thì ta phải đặt tham số hình thức là các con trỏ,

còn tham số thực tế là địa chỉ của các biến.

Lúc này mọi sự thay đổi trên vùng nhớ được quản lý bởi con trỏ là các

tham số hình thức của hàm thì sẽ ảnh hưởng đến vùng nhớ đang được quản lý

bởi tham số thực tế tương ứng (cần để ý rằng vùng nhớ này chính là các biến ta

cần thay đổi giá trị). Người ta thường áp dụng cách này đối với các dữ liệu đầu

ra của hàm.

Ví dụ: Xét chương trình sau đây:

#include <stdio.h>#include <conio.h>long hoanvi(long *a, long *b)/* Khai báo tham số hình thức *a, *b là các con trỏ kiểu

long */

{long t;t=*a; /*gán nội dung của x cho t*/*a=*b; /*Gán nội dung của b cho a*/*b=t; /*Gán nội dung của t cho b*/printf("\n Ben trong ham a=%ld , b=%ld",*a,*b);/*In ra nội dung của a, b*/return 0;

}

void main(){

long a, b;clrscr();printf("\n Nhap vao 2 so nguyen a, b:");scanf("%ld%ld",&a,&b);

printf("\n Truoc khi goi ham hoan vi a=%ld, b=%ld", a,b);

hoanvi(&a,&b); /* Phải là địa chỉ của a và b */printf("\n Sau khi goi ham hoan vi a=%ld, b=%ld",

a,b);getch();

}Kết quả thực hiện chương trình sau.

Giải thích:

- Nhập vào 2 số 5, 6 (a=5, b=6)- Trước khi gọi hàm hoanvi thì a=5, b=6- Trong hàm hoanvi (khi đã hoán vị) thì a=6, b=5- Khi ra khỏi hàm hoán vị thì a=6, b=6

5.2.4. Bài tập thực hành

1. Viết chương trình giải phương trình bậc nhất ax+b=0 (a#0).

Hướng dẫn:

- Xây dựng hàm giải phương trình bậc nhất: float giaiptb1(int a, int b, float *x)

- Truyền tham trị cho hàm giaiptb1(int a, int b, float *x)- Gọi hàm giaiptb1(int a, int b, float *x) vừa xây dựng thực hiện trong

chương trình chính

2. Viết chương trình tính tổng các số nguyên chẵn từ 1 đến n.

Hướng dẫn:

- Xây dựng hàm tính tổng các số nguyên chẵn từ 1 đến n:int tinhtongchan (int n, int *S)

- Truyền tham biến cho hàm int tinhtongchan (int n, int *S)- Gọi hàm int tinhtongchan (int n, int *S) vừa xây dựng thực hiện trong

chương trình chính5.3. SỬ DỤNG BIẾN TOÀN CỤC

Mục tiêu: Sử dụng biến cục bộ, toàn cục trong hàm 

5.3.1. Sử dụng biến toàn cục

12345678910111213141516171819202122232425262728293031

#include <stdio.h>#include <conio.h>

// khai bao prototype void oddeven( );void negative();

//khai bao bien toan cuc int inum;

void main(void){

printf("Nhap vao 1 so nguyen : ");scanf("%d", &inum);oddeven(); negative(); getch();

}

// ham kiem tra chan le void oddeven(){

if (inum % 2)printf("%d la so le.\n", inum);

elseprintf("%d la so chan.\n", inum);

}//ham kiem tra so am void negative(){

if (inum < 0)printf("%d la so am.\n", inum);

elseprintf("%d la so duong.\n", inum);

}

Kết quả in ra màn hìnhNhap vao 1 so nguyen: 3

3 la so le.

3 la so duong.

Giải thích chương trình

Chương trình trên gồm 2 hàm oddeven và negative, 2 hàm này bạn thấy

không có tham số để truyền biến inum vào xử lý nhưng vẫn cho kết quả đúng.

Do chương trình sử dụng biến inum toàn cục (dòng.9) nên biến này có ảnh

hưởng đến toàn bộ chương trình mỗi khi gọi và sử dụng nó. Xét tình huống sau:

Giả sử trong hàm negative ta khai báo biến inum có kiểu int như sau:

void negative(){

int inum;….

}

Khi đó chương trình sẽ cho kết quả sai! Do các câu lệnh trong hàm

negative sử dụng biến inum sẽ sử dụng biến inum khai báo trong hàm negative

và lúc này biến inum toàn cục không có tác dụng đối với các câu lệnh trong hàm

này. Biến inum khai báo trong hàm negative chỉ có ảnh hưởng trong phạm vi

hàm và chu trình sống của nó bắt đầu từ lúc gọi hàm đến khi thực hiện xong.

Cẩn thận khi đặt tên biến, xác định rõ phạm vi của biến khi sử dụng để có

thể dễ dàng kiểm soát chương trình.

Ví dụ 6:

#include <stdio.h>#include <conio.h>

#define PI 3.14

// khai bao prototype float area();

//khai bao bien toan cuc float frad;

void main(void){

printf("Nhap vao ban kinh hinh cau : ");scanf("%f", &frad);

printf("Dien tich hinh cau: %10.3f.\n", area());

getch();}

// ham tinh dien tich hinh cau float area(){

return (4*PI*frad*frad);

}

Kết quả in ra màn hình

Nhap vao ban kinh hinh cau: 3.2

Dien tich hinh cau: 128.614

5.3.2. Bài tập thực hành

Bài 1: Viết hàm kiểm tra số nguyên n có phải là số nguyên tố hay không?

Bài 2: Viết hàm kiểm tra số nguyên n có phải là số chính phương hay

không? (25=52, 16=42, 9=32; các số 25, 16, 9 là những số chính phương)

Bài 3: Viết hàm tính n! (n là số nguyên nhập vào từ bàn phím)

Bài 4: Viết thủ tục tìm UCLN và BCNN của hai số nhập vào từ bàn phím

Bài 5: Viết hàm, thủ tục tìm số lớn nhất trong hai số. Áp dụng hàm này

vào việc tìm số lớn nhất trong ba số nhập vào từ bàn phím

Hướng dẫnBài 1:

Thuật toán:

Viết hàm (function) ktra_ngto(int x): kiểm tra x có phải là số nguyên tố

hay không

Khai báo biến i, ktra

Cho i chạy từ 2 đến x

Nếu x mod i = 0 thì thoát

Nếu x=i thì ktra=1

Ngược lại, ktra=0

Hàm ktra_ngto trả về giá trị ktra

Chương trình chính:

Khai báo biến n, kq

Nhập số n

Gọi hàm: kq = ktra_ngto(n)

Nếu kq = = 1 thì n là số nguyên tố

Ngược lại, n không phải là số nguyên tố

Bài 2:

Thuật toán:

Viết hàm (function) ktra_chinhphuong(int x): kiểm tra x có phải là số

chính phương hay không

Khai báo biến i, ktra

Cho i chạy từ 1 đến x (nếu dùng sqrt(x) thì không cần lệnh thoát)

Nếu i*i = x thì

ktra = 1

Thoát

Nếu ktra= =1 thì x là số chính phương

Ngược lại, x không phải là số chính phương

Chương trình chính:

Khai báo biến n, kq

Nhập số n

Gọi hàm: kq = ktra_chinhphuong(n)

Bài 3:

Thuật toán:

Viết hàm (function) Giaithua(int n):giai thừa của n

Khai báo biến I, GT

Cho i chạy từ 1 đến n

GT=1

GT=GT*i

Trả về kết quả tìm được cho hàm Giaithua

Chương trình chính:

Khai báo biến n

Nhập số n

Gọi hàm: kq = Giaithua(n)

Bài 4:

Thuật toán:

Viết hàm (function) USCLN(a:integer, b:integer): integer :tìm ước số

chung lớn nhất của hai số a và b

Lấy trị tuyệt đối hai số a và b

Chừng nào (a<>0 và b<>0) làm

Nếu a>b thì a=a-b

Ngược lại, b=b-a

Nếu a = 0 thì b là USCLN

Ngược lại, a là USCLN

Viết hàm (function) BSCNN(a:integer, b:integer):integer tìm bội số chung

nhỏ nhất của hai số a và b

BSCNN= (a*b)/USCLN(a,b)

Chương trình chính:

Khai báo biến a, b, US, BS

Nhập hai số a,b

Gọi hàm:

US = USCLN(a, b)

BS = BSCNN(a, b)

Xuất BS, US ra màn hình

Bài 5:

Thuật toán:

Viết hàm (function) solonnhat(a:integer, b:integer):integer tìm số lớn nhất

trong hai số a và b

Khai báo biến max

Gán max = a

Nếu max<b thì max=b

Hàm solonnhat(a,b) trả về giá trị max

Chương trình chính:

Khai báo biến a, b, c, max

Nhập hai số a, b, c

Gọi hàm:

max = solonnhat(a, b)

max = solonnhat(max, c)

Xuất max ra màn hình

5.4. Dùng dẫn hướng #define

Mục tiêu:Sử dụng tiền xử lý #define.

Sau đây là một vài ví dụ dùng dẫn hướng #define để định nghĩa hàm đơn

giản

#define AREA_CIRCLE (frad) (4*PI*frad*frad) //tinh dien tich hinh cau

#define SUM (x, y) (x + y) //cong 2 so

#define SQR (x) (x*x) //tinh x binh phuong

#define MAX(x, y) (x > y) ? x : y //tim so lon nhat giua x va y

#define ERROR (s) printf("%s.\n", s) //in thong bao voi chuoi s

Ví d ụ 7 : Trong ví dụ 6 xóa từ dòng 20 đến dòng 24, xóa dòng 6, 7;

thêm dòng AREA_CIRCLE (frad) (4*PI+frad*frad) vào sau dòng 5.

Sửa dòng printf("Dien tich hinh cau: %10.3f.\n", area()); thành

printf("Dien tich hinh cau: %10.3f.\n", AREA_CIRCLE(frad));

Chạy lại chương trình, quan sát và nhận xét kết quả.

Ví dụ 8:

123456789

#include <stdio.h>#include <conio.h>#define MAX(x, y) (x > y) ? x : y void main(void){

float a = 4.5, b = 6.1;printf("So lon nhat la: %5.2f.\n", MAX(a, b));getch();

}

Kết quả in ra màn hình

So lon nhat la: 6.10

Thêm vào dòng 8 giá trị c = 10

Sửa lại dòng 9: MAX(a, b) thành MAX(MAX(a, b), c)

Chạy lại chương trình, quan sát và nhận xét kết quả

CHƯƠNG 6: MẢNG VÀ CHUỖI

Mã chương/ bài:MH18-06Ý nghĩa:

Trong C, mảng được dùng để biểu thị một cấu trúc của một dãy nhiều giá

trị có cùng một kiểu được xếp thứ tự. 

Mục tiêu: - Trình bày được ý nghĩa, cách khai báo mảng, chuỗi; - Nhập xuất mảng, chuỗi;- Khởi tạo mảng chuỗi;- Trình bày một số kỹ thuật thao tác trên mảng, chuỗi;- Vận dụng được mảng làm tham số cho hàm;- Giải một số bài toán sử dụng kiểu mảng, chuỗi.- Thực hiện các thao tác an toàn với máy tính.

6.1. GIỚI THIỆU KIỂU DỮ LIỆU “KIỂU MẢNG” TRONG C

Mục tiêu: Trình bày được ý nghĩa, cách khai báo 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).

Ta có thể chia mảng làm hai loại: Mảng một chiều và mảng nhiều chiều.

Mảng là kiểu dữ liệu được sử dụng rất thường xuyên. Chẳng hạn người ta

cần quản lý một danh sách họ và tên của khoảng 100 sinh viên trong một lớp.

Nhận thấy rằng mỗi họ và tên để lưu trữ ta cần một biến kiểu chuỗi, như vậy

100 họ và tên thì cần khai báo 100 biến kiểu chuỗi. Nếu khai báo như thế này

thì đoạn khai báo cũng như các thao tác trên các họ tên sẽ rất dài dòng và rắc

rối. Vì thế, kiểu dữ liệu mảng giúp ích ta trong trường hợp này; chỉ cần khai

báo một biến, biến này có thể coi như là tương đương với 100 biến chuỗi ký

tự; đó là một mảng mà các phần tử của nó là chuỗi ký tự. Hay như để lưu trữ

các từ khóa của ngôn ngữ lập trình C, ta cũng dùng đến một mảng để lưu trữ

chúng.

6.2. MẢNG MỘT CHIỀU

Mục tiêu:

- Trình bày được ý nghĩa, cách khai báo mảng một chiều - Nhập xuất mảng một chiều- Khởi tạo mảng một chiều- Trình bày một số kỹ thuật thao tác trên mảng một chiều;- Vận dụng được mảng làm tham số cho hàm- Giải một số bài toán sử dụng kiểu mảng một chiều- Thực hiện các thao tác an toàn với máy tính.

Nếu xét dưới góc độ toán học, mảng một chiều giống như một vector. Mỗi

phần tử của mảng một chiều có giá trị không phải là một mảng khác.

6.2.1. Khai báo

6.2.1.1. Khai báo mảng với số phần tử xác định (khai báo tường

minh)

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 (hay nói khác đi kích thước của mảng là gì).

- Kiểu: mỗi phần tử của mảng có dữ liệu thuộc kiểu gì.- Ở đây, ta khai báo một biến mảng gồm có số phần tử phần tử, phần tử

thứ nhất là tên mảng [0], phần tử cuối cùng là tên mảng[số phần tử -1]Ví dụ:int a[10];/* Khai báo biến mảng tên a, phần tử thứ nhất là a[0], phần tử cuối cùng là a[9].*/Ta 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 phần tửHình 1: Hình ảnh mảng a trong bộ nhớ

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

không tường minh)

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.

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

Cú pháp:

<Kiểu> <Tên mảng> []= {Các giá trị cách nhau bởi dấu phẩy}

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 {}. Chúng ta có thể

sử dụng hàm sizeof() để lấy số phần tử của mảng như sau:

Số phần tử=sizeof(tên mảng)/ sizeof(kiểu) 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.6.2.2. 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ụ 1:int a[10];

Trong khai báo này, việc truy xuất các phần tử được chỉ ra trong hình 1. Chẳng hạn phần tử thứ 2 (có vị trí 1) là a[1]…

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.

Giả sử ta đã biết số phần tử của mảng là n; việc hiển thị 1 giá trị số nguyên

lên màn hình ta cần sử dụng hàm printf() với định dạng %d, tổng quát hóa lên

nếu muốn hiển thị lên màn hình giá trị của n số nguyên, ta cần gọi hàm printf()

đúng n lần. Như vậy trong trường hợp này ta sử dụng 1 vòng lặp để in ra giá trị

các phần tử.

Ta có đoạn chương trình sau:

#include <stdio.h>#include <conio.h>void main(){

int n,i,j,tam;int dayso[]={66,65,69,68,67,70};clrscr();n=sizeof(dayso)/sizeof(int); /*Lấy số phần tử*/printf("\n Noi dung cua mang ");for (i=0;i<n;i++)printf("%d ",dayso[i]);

}

Ví dụ 3: Đổi một số nguyên dương thập phân thành số nhị phân. Việc

chuyển đổi này được thực hiện bằng cách lấy số đó chia liên tiếp cho 2 cho tới

khi bằng 0 và lấy các số dư theo chiều ngược lại để tạo thành số nhị phân. Ta sẽ

dùng mảng một chiều để lưu lại các số dư đó. Chương trình cụ thể như sau:

#include<conio.h>#include<stdio.h>void main(){

unsigned int N;unsigned int Du;unsigned int NhiPhan[20],K=0,i;printf("Nhap vao so nguyen N= ");scanf("%d",&N);do{

Du=N % 2;NhiPhan[K]=Du; /* Lưu số dư vào mảng ở vị

trí K*/K++; /* Tăng K lên để lần kế lưu vào vị trí

kế*/N = N/2;

} while(N>0);printf("Dang nhi phan la: ");for(i=K-1;i>=0;i--)printf("%d",NhiPhan[i]);getch();

}

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. Đây là

một bài toán có ứng dụng rộng rãi trong nhiều lĩnh vực. Có rất nhiều giải thuật

sắp xếp. Một trong số đó được mô tả như sau:

Đầu tiên đưa phần tử thứ nhất so sánh với các phần tử còn lại, nếu nó lớn

hơn một phần tử đang so sánh thì đổi chỗ hai phần tử cho nhau. Sau đó tiếp tục

so sánh phần tử thứ hai với các phần tử từ thứ ba trở đi ... cứ tiếp tục như vậy

cho đến phần tử thứ n-1.

Chương trình sẽ được chia thành các hàm Nhap (Nhập các số), SapXep

(Sắp xếp) và InMang (In các số); các tham số hình thức của các hàm này là 1

mảng không chỉ định rõ số phần tử tối đa, nhưng ta cần có thêm số phần tử thực

tế được sử dụng của mảng là bao nhiêu, đây là một giá trị nguyên.

#include<conio.h>#include<stdio.h>void Nhap(int a[],int N){

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

printf("Phan tu thu %d: ",i);scanf("%d",&a[i]);}

}void InMang(int a[], int N){

int i;for (i=0; i<N;i++)printf("%d ",a[i]);printf("\n");

}void SapXep(int a[], int N){

int t,i;for(i=0;i<N-1;i++)for(int j=i+1;j<N;j++)if (a[i]>a[j]){

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

}

void main(){

int b[20], N;printf("So phan tu thuc te cua mang N= ");

scanf("%d",&N);Nhap(b,N);printf("Mang vua nhap: "); InMang(b,N);SapXep(b,N); /* Gọi hàm sắp xếp*/printf("Mang sau khi sap xep: "); InMang(b,N);getch();

}Kết quả chạy chương trình có thể là:

6.2.3. Bài tập thực hành

Mục đích yêu cầu

Làm quen với kiểu dữ liệu có cấu trúc trong C, kiểu mảng. Thực hiện các

bài tập trong phần nội dung bằng cách kết hợp kiểu dữ liệu mảng, các kiểu dữ

liệu đã học và các phần đã học trong các bài tập trước.

Nội dung

1. Viết chương trình nhập vào một dãy n số thực a[0], a[1],..., a[n-1], sắp

xếp dãy số theo thứ tự từ lớn đến nhỏ. In dãy số sau khi sắp xếp.

2. Viết chương trình sắp xếp một mảng theo thứ tự tăng dần sau khi đã

loại bỏ các phần tử trùng nhau.

3. Viết chương trình nhập vào một mảng, hãy xuất ra màn hình:

- Phần tử lớn nhất của mảng.

- Phần tử nhỏ nhất của mảng.

- Tính tổng của các phần tử trong mảng .

4. Viết chương trình nhập vào một dãy các số theo thứ tự tăng, nếu nhập

sai quy cách thì yêu cầu nhập lại. In dãy số sau khi đã nhập xong. Nhập thêm

một số mới và chèn số đó vào dãy đã có sao cho dãy vẫn đảm bảo thứ tự tăng. In

lại dãy số để kiểm tra.

5. Viết chương trình nhập vào một mảng số tự nhiên. Hãy xuất ra màn

hình:

- Dòng 1 : gồm các số lẻ, tổng cộng có bao nhiêu số lẻ.

- Dòng 2 : gồm các số chẵn, tổng cộng có bao nhiêu số chẵn.

- Dòng 3 : gồm các số nguyên tố.

- Dòng 4 : gồm các số không phải là số nguyên tố.

6. Viết chương trình tính tổng bình phương của các số âm trong một mảng

các số nguyên.

7. Viết chương trình thực hiện việc đảo một mảng một chiều.

Ví dụ : 1 2 3 4 5 7 9 10 đảo thành 10 9 7 5 4 3 2 1 .

6.3. MẢNG NHIỀU CHIỀU

Mục tiêu:

- Trình bày được ý nghĩa, cách khai báo mảng hai chiều - Nhập xuất mảng hai chiều- Khởi tạo mảng hai chiều- Trình bày một số kỹ thuật thao tác trên mảng hai chiều;- Vận dụng được mảng làm tham số cho hàm- Giải một số bài toán sử dụng kiểu mảng hai chiều- Thực hiện các thao tác an toàn với máy tính.

Mảng nhiều chiều là mảng có từ hai chiều trở lên. Điều đó có nghĩa là mỗi

phần tử của mảng là một mảng khác.

Người ta thường sử dụng mảng nhiều chiều để lưu các ma trận, các tọa độ 2

chiều, 3 chiều…

Phần dưới đây là các vấn đề liên quan đến mảng 2 chiều; các mảng 3, 4,…

chiều thì tương tự (chỉ cần tổng quát hóa lên).

m[0][0] m[0][1] m[0][2] m[0][3] m[0][4] m[0][5] m[0][6] m[0][7] m[0][8]m[1][0] m[1][1] m[1][2] m[1][3] m[1][4] m[1][5] m[1][6] m[1][7] m[1][8]m[2][0] m[2][1] m[2][2] m[2][3] m[2][4] m[2][5] m[2][6] m[2][7] m[2][8]m[3][0] m[3][1] m[3][2] m[3][3] m[3][4] m[3][5] m[3][6] m[3][7] m[3][8]m[4][0] m[4][1] m[4][2] m[4][3] m[4][4] m[4][5] m[4][6] m[4][7] m[4][8]m[5][0] m[5][1] m[5][2] m[5][3] m[5][4] m[5][5] m[5][6] m[5][7] m[5][8]m[6][0] m[6][1] m[6][2] m[6][3] m[6][4] m[6][5] m[6][6] m[6][7] m[6][8]m[7][0] m[7][1] m[7][2] m[7][3] m[7][4] m[7][5] m[7][6] m[7][7] m[7][8]

6.3.1. Khai báo

6.3.1.1. Khai báo mảng 2 chiều tường minh

Cú pháp:

<Kiểu> <Tên mảng><[Số phần tử chiều 1]><[Số phần tử chiều 2]>

Ví dụ: Người ta cần lưu trữ thông tin của một ma trận gồm các số thực. Lúc

này ta có thể khai báo một mảng 2 chiều như sau:

float m[8][9]; /* Khai báo mảng 2 chiều có 8*9 phần tử là số thực*/

Trong trường hợp này, ta đã khai báo cho một ma trận có tối đa là 8 dòng,

mỗi dòng có tối đa là 9 cột. Hình ảnh của ma trận này được cho trong hình 2:

Dòng\Cột 0 1 2 3 4 5 6 7 801234567

6.3.1.2. Khai báo mảng hai chiều không tường minh

Để khai báo mảng 2 chiều không tường minh, ta vẫn phải chỉ ra số phần tử

của chiều thứ hai (chiều cuối cùng).

Cú pháp: <Kiểu> <Tên mảng> <[]><[Số phần tử chiều 2]>

Cách khai báo này cũng được áp dụng trong trường hợp vừa khai báo, vừa

gán trị hay đặt mảng 2 chiều là tham số hình thức của hàm.

6.3.2. Truy xuất từng phần tử của mảng hai chiều

Ta có thể truy xuất một phần tử của mảng hai chiều bằng cách viết ra tên

mảng theo sau là hai chỉ số đặt trong hai cặp dấu ngoặc vuông. Chẳng hạn ta

viết m[2][3].

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

là 1 biến có kiểu được chỉ ra trong khai báo biến mảng.

Ví dụ 1: 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.

Trong ví dụ này, ta sẽ sử dụng hàm để làm ngắn gọn hơn chương trình của

ta. Ta sẽ viết các hàm: nhập 1 ma trận từ bàn phím, hiển thị ma trận lên màn

hình, cộng 2 ma trận.

#include<conio.h>#include<stdio.h>void Nhap(int a[][10],int M,int N){

int i,j;for(i=0;i<M;i++)for(j=0; j<N; j++){

printf("Phan tu o dong %d cot %d: ",i,j);scanf("%d",&a[i][j]);

}}void InMaTran(int a[][10], int M, int N){

int i,j;for(i=0;i<M;i++){

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

}}/* 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++)

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

}int main(){

int a[10][10], b[10][10], M, N;int c[10][10];/* Ma tran tong*/printf("So dong M= "); scanf("%d",&M); printf("So cot M= "); scanf("%d",&N); printf("Nhap ma tran A\n");Nhap(a,M,N);printf("Nhap ma tran B\n"); Nhap(b,M,N);printf("Ma tran A: \n");InMaTran(a,M,N);printf("Ma tran B: \n");

InMaTran(b,M,N);CongMaTran(a,b,M,N,c);printf("Ma tran tong C:\n");InMaTran(c,M,N);getch();return 0;

}

Ví dụ 2: Nhập vào một ma trận 2 chiều gồm các số thực, in ra tổng của các

phần tử trên đường chéo chính của ma trận này.

Ta nhận thấy rằng giả sử ma trận a có M dòng, N cột thì các phần tử của

đường chéo chính là các phần tử có dạng: a[i][i] với i ∈ [0…min(M,N)-1].

#include<conio.h>#include<stdio.h>int main(){

float a[10][10], T=0; int M, N, i,j, Min; clrscr();printf("Ma tran co bao nhieu dong? ");scanf("%d",&M);printf("Ma tran co bao nhieu cot? ");scanf("%d",&N);for(i=0;i<M;i++)for(j=0; j<N; j++){

printf("Phan tu o dong %d cot %d: ",i,j);scanf("%f",&a[i][j]);

}printf("Ma tran vua nhap: \n");for(i=0;i<M;i++){

for(j=0; j< N; j++)printf("%.2f ",a[i][j]);printf("\n");

}Min=(M>N) ? N: M; /* Tìm giá trị nhỏ nhất của M & N*/for(i=0;i<Min;i++) T=T+a[i][i];printf("Tong cac phan tu o duong cheo chinh la: %f",

T);getch();return 0;

}6.3.3. Bài tập thực hành

1. Viết chương trình nhập vào một ma trận (mảng hai chiều) các số

nguyên, gồm m hàng, n cột. In ma trận đó lên màn hình. Nhập một số nguyên

khác vào và xét xem có phần tử nào của ma trận trùng với số này không ? Ở vị

trí nào ? Có bao nhiêu phần tử ?

2. Viết chương trình để chuyển đổi vị trí từ dòng thành cột của một ma

trận (ma trận chuyển vị) vuông 4 hàng 4 cột. Sau đó viết cho ma trận tổng quát

cấp m*n.

Ví dụ:

1 2 3 4 1 2 9 12 5 5 8 2 5 4 59 4 2 0 3 5 2 81 5 8 6 4 8 0 6

2. Viết chương trình nhập vào hai ma trận A có cấp m, k và B có cấp k, n.

In hai ma trận lên màn hình. Tích hai ma trận A và B là ma trận C được tính bởi

công thức:

cij= ai1*b1j + ai2 *b2j + ai3 *b3j + ... + aik *bkj (i=0,1,2,...m-1;j=0,1,2...n-1) Tính

ma trận tích C và in kết quả lên màn hình.

3. Xét ma trận A vuông cấp n, các phần tử a[i, i] ( i= 1 ... n ) được gọi là

đường chéo chính của ma trận vuông A. Ma trận vuông A được gọi là ma trận

tam giác nếu tất cả các phần tử dưới đường chéo chính đều bằng 0. Định thức

của ma trận tam giác bằng tích các phần tử trên đường chéo chính.

Ta có thể chuyển một ma trận vuông bất kỳ về ma trận tam giác bằng thuật

toán:

- Xét cột i (i =0,1...n-2)

- Trong cột i xét các phần tử a[k,i] ( k=i+1...n-1)

+ Nếu a[k,i]=0 thì tăng k lên xét phần tử khác

+ Nếu a[k,i] <> 0 thì làm như sau:

Nhân toàn bộ hàng k với - a[i,i]/a[k,i]

Lấy hàng i cộng vào hàng k sau khi thực hiện phép nhân trên.

Đổi chỗ hai hàng i và k cho nhau

Nhân toàn bộ hàng k với -1 sau khi đã đổi chỗ với hàng i

Tăng k lên xét phần tử khác.

Viết chương trình tính định thức cấp n thông qua các bước nhập ma trận, in

ma trận, đưa ma trận về dạng tam giác, in ma trận tam giác, in kết quả tính định

thức.

4. Viết chương trình thực hiện việc trộn hai dãy có thứ tự thành một dãy

có thứ tự. Yêu cầu không được trộn chung rồi mới sắp thứ tự. Khi trộn phải

tận dụng được tính chất đã sắp của hai dãy con.

5. Viết chương trình nhập vào hai ma trận A và B có cấp m, n. In hai ma

trận lên màn hình. Tổng hai ma trận A và B là ma trận C được tính bởi công

thức:

cij= aij +bij ( i=0,1,2,...m-1; j=0,1,2...n-1)

Tính ma trận tổng C và in kết quả lên màn hình

6.4. CHUỖI

Mục tiêu:

- Trình bày được ý nghĩa, cách khai báo chuỗi; - Nhập xuất chuỗi;- Khởi tạo mảng chuỗi;- Trình bày một số kỹ thuật thao tác trên chuỗi;- Giải một số bài toán sử dụng kiểu chuỗi.- Thực hiện các thao tác an toàn với máy tính.

6.4.1. KHÁI NIỆM

Chuỗi ký tự là một dãy gồm các ký tự hoặc một mảng các ký tự được kết

thúc bằng ký tự ‘\0’ (còn được gọi là ký tự NULL trong bảng mã Ascii).

Các hằng chuỗi ký tự được đặt trong cặp dấu nháy kép “”.

6.4.2. KHAI BÁO

6.4.2.1. Khai báo theo mảng

Cú pháp: char <Biến> [Chiều dài tối đa] Ví dụ: Trong chương trình, ta có khai báo: char Ten[12];

Trong khai báo này, bộ nhớ sẽ cung cấp 12+1 bytes để lưu trữ nội dung

của chuỗi ký tự Ten; byte cuối cùng lưu trữ ký tự ‘\0’ để chấm dứt chuỗi.

Ghi chú:

- Chiều dài tối đa của biến chuỗi là một hằng nguyên nằm trong khoảng từ 1 ến 255 bytes.

- Chiều dài tối đa không nên khai báo thừa để tránh lãng phí bộ nhớ, nhưng cũng không nên khai báo thiếu.

6.4.2.2. Khai báo theo con trỏ

Cú pháp: char *<Biến>

Ví dụ: Trong chương trình, ta có khai báo:

char *Ten;

Trong khai báo này, bộ nhớ sẽ dành 2 byte để lưu trữ địa chỉ của biến

con trỏ Ten đang chỉ đến, chưa cung cấp nơi để lưu trữ dữ liệu. Muốn có chỗ

để lưu trữ dữ liệu, ta phải gọi đến hàm malloc() hoặc calloc() có trong

“alloc.h”, sau đó mới gán dữ liệu cho biến.

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

Cú pháp: char <Biến>[]=<”Hằng chuỗi”>

Ví dụ:#include<stdio.h>#include<conio.h>int main(){

char Chuoi[]="Mau nang hay la mau mat em” ; printf("Vua khai bao vua gan trị : %s”,Chuoi) ;

getch();return 0;

}

* Ghi chú: Chuỗi được khai báo là một mảng các ký tự nên các thao tác

trên mảng có thể áp dụng đối với chuỗi ký tự.

6.4.3. CÁC THAO TÁC TRÊN CHUỖI KÝ TỰ

6.4.3.1. Nhập xuất chuỗi

Nhập chuỗi từ bàn phím

Để nhập một chuỗi ký tự từ bàn phím, ta sử dụng hàm gets()

Cú pháp: gets(<Biến chuỗi>)

Ví dụ: char Ten[20];

gets(Ten);

Ta cũng có thể sử dụng hàm scanf() để nhập dữ liệu cho biến chuỗi, tuy

nhiên lúc này ta chỉ có thể nhập được một chuỗi không có dấu khoảng trắng.

Ngoài ra, hàm cgets() (trong conio.h) cũng được sử dụng để nhập chuỗi.

Xuất chuỗi lên màn hình

Để xuất một chuỗi (biểu thức chuỗi) lên màn hình, ta sử dụng hàm puts().

Cú pháp: puts(<Biểu thức chuỗi>)

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.

#include<conio.h>#include<stdio.h>#include<string.h>int main(){

char Ten[12];printf("Nhap chuoi: ");gets(Ten);printf("Chuoi vua nhap: ");puts(Ten);getch();return 0;

}

Ngoài ra, ta có thể sử dụng hàm printf(), cputs() (trong conio.h) để

hiển thị chuỗi lên màn hình.

6.4.3.2. Một số hàm xử lý chuỗi (trong string.h)

Cộng chuỗi - Hàm strcat()

Cú pháp: char *strcat(char *des, const char *source)

Hàm này có tác dụng ghép chuỗi nguồn vào chuỗi đích.

Ví dụ: Nhập vào họ lót và tên của một người, sau đó in cả họ và tên của

họ lên màn hình.

#include<conio.h>

#include<stdio.h>#include<string.h>void main(){

char HoLot[30], Ten[12];printf("Nhap Ho Lot: ");gets(HoLot); printf("Nhap Ten: ");gets(Ten); strcat(HoLot,Ten); /* Ghep Ten vao HoLot*/ printf("Ho ten la: ");puts(HoLot);getch();

}

Xác định độ dài chuỗi - Hàm strlen()

Cú pháp: int strlen(const char* s)

Ví dụ: Sử dụng hàm strlen xác định độ dài một chuỗi nhập từ bàn phím.

#include<conio.h>#include<stdio.h>#include<string.h>void main(){

char Chuoi[255];int Dodai;printf("Nhap chuoi: ");gets(Chuoi); Dodai = strlen(Chuoi)printf("Chuoi vua nhap: ");puts(Chuoi);printf(“Co do dai %d”,Dodai);getch();

}

Đổi một ký tự thường thành ký tự hoa - Hàm toupper()

Hàm toupper() (trong ctype.h) được dùng để chuyển đổi một ký tự

thường thành ký tự hoa.

Cú pháp: char toupper(char c)

Đổi chuỗi chữ thường thành chuỗi chữ hoa, hàm strupr()

Hàm struppr() được dùng để chuyển đổi chuỗi chữ thường thành chuỗi chữ

hoa, kết quả trả về của hàm là một con trỏ chỉ đến địa chỉ chuỗi được chuyển

đổi.

Cú pháp: char *strupr(char *s)

Ví dụ: Viết chương trình nhập vào một chuỗi ký tự từ bàn phím. Sau đó sử

dụng hàm strupr() để chuyển đổi chúng thành chuỗi chữ hoa.

#include<conio.h>#include<stdio.h>#include<string.h>int main(){

char Chuoi[255],*s;printf("Nhap chuoi: ");gets(Chuoi);s=strupr(Chuoi) ;printf(“Chuoi chu hoa: ”);puts(s);getch();return 0;

}

Đổi chuỗi chữ hoa thành chuỗi chữ thường, hàm strlwr()

Muốn chuyển đổi chuỗi chữ hoa thành chuỗi toàn chữ thường, ta sử dụng

hàm strlwr(), các tham số của hàm tương tự như hàm strupr()

Cú pháp: char *strlwr(char *s)

Sao chép chuỗi, hàm strcpy()

Hàm này được dùng để sao chép toàn bộ nội dung của chuỗi nguồn vào chuỗi đích.

Cú pháp: char *strcpy(char *Des, const char *Source)

Ví dụ: Viết chương trình cho phép chép toàn bộ chuỗi nguồn vào chuỗi

đích.

#include<conio.h>#include<stdio.h>#include<string.h>int main(){ char Chuoi[255],s[255]; printf("Nhap chuoi: ");gets(Chuoi); strcpy(s,Chuoi); printf(“Chuoi dich: ”);puts(s); getch(); return 0;}

Sao chép một phần chuỗi, hàm strncpy()

Hàm này cho phép chép n ký tự đầu tiên của chuỗi nguồn sang chuỗi đích.

Cú pháp: char *strncpy(char *Des, const char *Source, size_t n)

Trích một phần chuỗi, hàm strchr()

Để trích một chuỗi con của một chuỗi ký tự bắt đầu từ một ký tự được chỉ

định trong chuỗi cho đến hết chuỗi, ta sử dụng hàm strchr().

Cú pháp : char *strchr(const char *str, int

Ghi chú:

- Nếu ký tự đã chỉ định không có trong chuỗi, kết quả trả về là NULL.- Kết quả trả về của hàm là một con trỏ, con trỏ này chỉ đến ký tự c được

tìm thấy đầu tiên trong chuỗi str. Tìm kiếm nội dung chuỗi, hàm strstr()

Hàm strstr() được sử dụng để tìm kiếm sự xuất hiện đầu tiên của chuỗi s2

trong chuỗi s1.

Cú pháp: char*strstr(const char *s1, const char *s2)

Kết quả trả về của hàm là một con trỏ chỉ đến phần tử đầu tiên của chuỗi s1

có chứa chuỗi s2 hoặc giá trị NULL nếu chuỗi s2 không có trong chuỗi s1.

Ví dụ: Viết chương trình sử dụng hàm strstr() để lấy ra một phần của

chuỗi gốc bắt đầu từ chuỗi “hoc”.

#include<conio.h>#include<stdio.h>#include<string.h>int main(){

char Chuoi[255],*s;printf("Nhap chuoi: ");gets(Chuoi);s=strstr(Chuoi,”hoc”);printf(“Chuoi trich ra: ”);puts(s);getch();return 0;

}

So sánh chuỗi, hàm strcmp()

Để so sánh hai chuỗi theo từng ký tự trong bảng mã Ascii, ta có thể sử

dụng hàm strcmp().

Cú pháp: int strcmp(const char *s1, const char *s2)

Hai chuỗi s1 và s2 được so sánh với nhau, kết quả trả về là một số nguyên

(số này có được bằng cách lấy ký tự của s1 trừ ký tự của s2 tại vị trí đầu tiên xảy

ra sự khác nhau).

- Nếu kết quả là số âm, chuỗi s1 nhỏ hơn chuỗi s2.- Nếu kết quả là 0, hai chuỗi bằng nhau.- Nếu kết quả là số dương, chuỗi s1 lớn hơn chuỗi s2.

So sánh chuỗi, hàm stricmp()

Hàm này thực hiện việc so sánh trong n ký tự đầu tiên của 2 chuỗi s1 và s2,

giữa chữ thường và chữ hoa không phân biệt.

Cú pháp: int stricmp(const char *s1, const char *s2)

Kết quả trả về tương tự như kết quả trả về của hàm strcmp()

Khởi tạo chuỗi, hàm memset()

Hàm này được sử dụng để đặt n ký tự đầu tiên của chuỗi là ký tự c.

Cú pháp: memset(char *Des, int c, size_t n)

Đổi từ chuỗi ra số, hàm atoi(), atof(), atol() (trong stdlib.h)

Để chuyển đổi chuỗi ra số, ta sử dụng các hàm trên.

Cú pháp : int atoi(const char *s) : chuyển chuỗi thành số nguyên

long atol(const char *s) : chuyển chuỗi thành số nguyên dài float atof(const

char *s) : chuyển chuỗi thành số thực

Nếu chuyển đổi không thành công, kết quả trả về của các hàm là 0.

Ngoài ra, thư viện string.h còn hỗ trợ các hàm xử lý chuỗi khác, ta có thể

đọc thêm trong phần trợ giúp.

6.4.4. Bài tập thực hành

Mục đích yêu cầu

Đi sâu vào kiểu dữ liệu chuỗi và các phép toán trên chuỗi.

Nội dung

1. Viết chương trình nhập một chuỗi ký tự từ bàn phím, xuất ra màn hình

mã Ascii của từng ký tự có trong chuỗi.

2. Viết chương trình nhập một chuỗi ký tự từ bàn phím, xuất ra màn

hình chuỗi đảo ngược của chuỗi đó. Ví dụ đảo của “abcd egh” là “hge dcba”.

3. Viết chương trình nhập một chuỗi ký tự và kiểm tra xem chuổi

đó có đối xứng không.

Ví dụ : Chuỗi ABCDEDCBA là chuỗi đối xứng.

4. Nhập vào một chuỗi bất kỳ, hãy đếm số lần xuất hiện của mỗi loại ký tự.

5. Viết chương trình nhập vào một chuỗi.

- In ra màn hình từ bên trái nhất và phần còn lại của chuỗi. Ví dụ: “Nguyễn

Văn Minh” in ra thành: Nguyễn Văn Minh

- In ra màn hình từ bên phải nhất và phần còn lại của chuỗi. Ví dụ:

“Nguyễn Văn Minh” in ra thành: Minh Nguyễn Văn

6. Viết chương trình nhập vào một chuỗi rồi xuất chuỗi đó ra màn hình

dưới dạng mỗi từ một dòng.

Ví dụ: “Nguyễn Văn Minh”

In ra :

Nguyễn

Văn

Minh

7. Viết chương trình nhập vào một chuỗi, in ra chuỗi đảo ngược của nó

theo từng từ.

Ví dụ : chuỗi “Nguyễn Văn Minh” đảo thành “Minh Văn Nguyễn”

8. Viết chương trình đổi số tiền từ số thành chữ.

9. Viết chương trình nhập vào họ và tên của một người, cắt bỏ các khoảng

trống không cần thiết (nếu có), tách tên ra khỏi họ và tên, in tên lên màn hình.

Chú ý đến trường hợp cả họ và tên chỉ có một từ.

10. Viết chương trình nhập vào họ và tên của một người, cắt bỏ các

khoảng trắng bên phải, trái và các khoảng trắng không có nghĩa trong chuỗi. In

ra màn hình toàn bộ họ tên người đó dưới dạng chữ hoa, chữ thường.

11. Viết chương trình nhập vào một danh sách họ và tên của n người

theo kiểu chữ thường, đổi các chữ cái đầu của họ, tên và chữ lót của mỗi người

thành chữ hoa. In kết quả lên màn hình.

12. Viết chương trình nhập vào một danh sách họ và tên của n người,

tách tên từng người ra khỏi họ và tên rồi sắp xếp danh sách tên theo thứ tự từ

điển. In danh sách họ và tên sau khi đã sắp xếp.

TÀI LIỆU THAM KHẢO

[1]. Tiến Sĩ Lê Mạnh Thạnh, Giáo trình môn lập trình C, Nhà xuất bản giáo dục, năm 2000.

[2]. Nguyễn Linh Giang, Nguyễn Xuân Thực, Lê Văn Thái, Giáo trình kỹ thuật lập trình C, Nhà xuất bản giáo dục, Năm 2005

[3]. GS. Phạm Văn Ất chủ biên, ThS. Nguyễn Hiếu Cường, ThS.Đỗ Văn Tuấn, Lê Trường Thông, Giáo trình kỹ thuật lập trình C, Nhà xuất bản Hồng Đức, Năm 2009

[4]. GS. Phạm Văn Ất, Kỹ Thuật Lập Trình C - Cơ Sở Và Nâng Cao, Nhà xuất bản giao thông vận tải, Năm 2006

[5]. HanoiAptech Computer Education Center , Giáo trình lập trình C căn bản

[6]. Đại học Cần Thơ , Giáo trình lập trình C căn bản

DANH SÁCH BAN BIÊN SOẠN GIÁO TRÌNH DẠY NGHỀ TRÌNH ĐỘ CAO ĐẲNG

Tên giáo trình: Lập trình CTên nghề: Quản trị mạng

1. Bà Trần Thị Hà Khuê Chủ nhiệm 2. Bà Võ Thị Ngọc Tú Thành viên3. Ông Dương Hiển Tú Thành viên

DANH SÁCH HỘI ĐỒNG NGHIỆM THUGIÁO TRÌNH DẠY NGHỀ TRÌNH ĐỘ TRUNG CẤP, CAO ĐẲNG

1. Ông (bà)...... Chủ tịch2. Ông (bà)...... Phó chủ tịch3. Ông (bà)...... Thư ký 4. Ông (bà)...... Thành viên 5. Ông(bà)...... Thành viên 6. Ông(bà)...... Thành viên 7. Ông(bà)..... Thành viên 8. Ông(bà)...... Thành viên 9. Ông(bà)...... Thành viên