GIÁO TRÌNH THỰC HÀNH KỸ THUẬT LẬP TRÌNH C (MÃ HỌC PHẦN: CMP3017)

Tổng quan về giáo trình

Tài liệu "Hướng Dẫn Học Lập Trình C: Bài Tập và Kiến Thức Cơ Bản" được biên soạn phục vụ cho học phần Thực hành Kỹ thuật Lập trình (mã học phần: CMP3017) tại Trường Đại học Công nghệ TP.HCM (HUTECH). Trong chương trình đào tạo khối ngành Công nghệ Thông tin, đây là học phần cơ sở đầu tiên giúp người học làm quen với kỹ thuật lập trình trên máy tính, đặt nền móng tiếp thu cho hầu hết các học phần chuyên ngành kế tiếp.

Mục tiêu đào tạo của giáo trình hướng tới việc trang bị cho sinh viên các chuẩn đầu ra cụ thể:

  • Nắm vững tổng quan về ngôn ngữ lập trình C, bao gồm cú pháp, các kiểu dữ liệu chuẩn, hệ thống toán tử và các hàm thư viện chuẩn.
  • Thành thạo kỹ thuật phân rã bài toán, thiết kế và sử dụng hàm (chương trình con), phân biệt cơ chế truyền tham trị và truyền tham biến.
  • Xử lý các bài toán trên cấu trúc mảng một chiều (tìm kiếm, sắp xếp, thống kê, kiểm tra điều kiện logic).
  • Tự xây dựng và xử lý các kiểu dữ liệu có cấu trúc (struct) để giải quyết các bài toán quản lý dữ liệu phức hợp.

Cấu trúc giáo trình được thiết kế theo phương pháp thực hành trực tiếp gồm 6 bài học theo tiến trình tuần tự từ căn bản đến nâng cao. Mỗi bài học bắt đầu bằng phần tóm tắt lý thuyết, quy tắc cú pháp, bảng tra cứu kiểu dữ liệu/toán tử, sau đó đi vào hệ thống bài tập thực hành mẫu có hướng dẫn giải thuật chi tiết và các bài tập rèn luyện mở rộng.

Nội dung kiến thức cốt lõi

Các chương và chủ đề chính

Nội dung giáo trình được phân bổ thành 6 bài học thực hành trọng tâm:

+-------------------------------------------------------------------------+
|                  NỘI DUNG CHƯƠNG TRÌNH THỰC HÀNH C                      |
+-------------------------------------------------------------------------+
| Bài 1: Làm quen với ngôn ngữ lập trình C (Cú pháp, I/O, Kiểu dữ liệu)    |
| Bài 2: Cấu trúc điều khiển rẽ nhánh (Câu lệnh IF và SWITCH)             |
| Bài 3: Cấu trúc điều khiển lặp (Vòng lặp FOR, WHILE, DO...WHILE)        |
| Bài 4: Chương trình con (Hàm, Nguyên mẫu hàm, Tham số, Tham biến)       |
| Bài 5: Kiểu dữ liệu mảng (Mảng một chiều số nguyên và số thực)          |
| Bài 6: Kiểu dữ liệu có cấu trúc (Struct, Typedef, Quản lý bản ghi)      |
+-------------------------------------------------------------------------+

  1. Bài 1: Làm quen với ngôn ngữ lập trình C

    • Giới thiệu cấu trúc khung của một chương trình nguồn C, hàm thực thi chính int main(), các khối lệnh định giới bằng cặp ngoặc nhọn {} và quy tắc kết thúc câu lệnh bằng dấu chấm phẩy ;.
    • Cú pháp ghi chú đơn dòng (//) và ghi chú nhiều dòng (/* ... */).
    • Cú pháp và cách sử dụng các lệnh nhập/xuất chuẩn: printf() và scanf().
    • Bảng phân loại kích thước bộ nhớ và định dạng hiển thị của các kiểu dữ liệu:
      • Kiểu số thực (liên tục): float (4 bytes, %f), double (8 bytes, %f), long double (10 bytes, %lf).
      • Kiểu số nguyên/ký tự (rời rạc): char (1 byte, %c), unsigned char (1 byte, %d), int (2 bytes, %d), unsigned int (2 bytes, %u), long (4 bytes, %ld), unsigned long (4 bytes, %lu).
    • Các phép toán số học (+, -, *, /, %), toán tử quan hệ (>, >=, <, <=, ==, !=), toán tử logic (!, &&, ||) và toán tử tăng giảm (++, --).
    • Hướng dẫn thao tác trên môi trường soạn thảo/biên dịch: C-Free (phím tắt F5 để chạy) và Dev-C++ (phím tắt F11 để biên dịch và chạy).

  2. Bài 2: Cấu khiển cấu trúc IF và SWITCH

    • Cú pháp câu lệnh điều kiện đơn if (biểu_thức_điều_kiện) câu_lệnh; và rẽ nhánh kép if (...) ... else ....
    • Cú pháp câu lệnh lựa chọn nhiều trường hợp switch (biểu_thức) { case giá_trị: ... break; default: ... }.
    • Ứng dụng giải quyết các bài toán: Giải và biện luận phương trình bậc nhất $ax + b = 0$, phương trình bậc hai $ax^2 + bx + c = 0$ (tính biệt thức $\Delta = b^2 - 4ac$ và nghiệm qua hàm căn bậc hai sqrt() thuộc thư viện <math.h>), kiểm tra ba cạnh tam giác, đọc số nguyên hai chữ số, tính số ngày trong tháng (bao gồm thuật toán kiểm tra năm nhuận) và tính cước taxi lũy tiến theo quãng đường.

  3. Bài 3: Cấu khiển - Cấu trúc lặp

    • Vòng lặp xác định for (khởi_gán; điều_kiện; bước_nhảy).
    • Vòng lặp tiền điều kiện while (điều_kiện) và vòng lặp hậu điều kiện do { ... } while (điều_kiện); (đảm bảo thân vòng lặp thực thi ít nhất một lần).
    • Kỹ thuật bẫy lỗi dữ liệu nhập đầu vào kết hợp cấu trúc lặp do...while.
    • Ứng dụng giải quyết các bài toán số học: Tách từng chữ số của một số nguyên bằng phép chia nguyên / và chia dư %, tính tổng chuỗi số, kiểm tra và đếm số nguyên tố, kiểm tra số hoàn thiện, in bảng cửu chương và in ma trận ký tự hình học lồng nhau bằng 2 vòng lặp for.

  4. Bài 4: Chương trình con (Hàm)

    • Khái niệm hàm như một khối lệnh độc lập thực hiện một chức năng cụ thể nhằm chia nhỏ bài toán lớn và tái sử dụng mã nguồn.
    • Cấu trúc khai báo nguyên mẫu hàm (function prototype): <Kiểu_dữ_liệu> Tên_hàm([danh_sách_tham_số]);.
    • Phân loại hàm: Hàm không trả về giá trị (sử dụng từ khóa void cho các tác vụ nhập, xuất, sắp xếp, hiển thị menu) và hàm có giá trị trả về (int, float,...) sử dụng lệnh return.
    • Phân biệt hai cơ chế truyền tham số: Truyền tham trị (call by value - giá trị tham số thực không đổi sau khi thực thi hàm) và truyền tham biến (call by reference - sử dụng ký tự & trước tên tham số để lưu trữ và thay đổi giá trị của đối số ngoài hàm).
    • Thiết kế hệ thống bảng chọn (Menu) điều khiển chương trình kết hợp cấu trúc do...while và switch...case.

  5. Bài 5: Mảng một chiều

    • Định nghĩa mảng một chiều: Vùng nhớ liên tục lưu trữ tập hợp các phần tử có cùng tên và cùng kiểu dữ liệu, truy xuất qua chỉ số từ 0 đến n - 1.
    • Cú pháp khai báo: <Kiểu_dữ_liệu> <Tên_mảng>[<Kích_thước>]; (ví dụ: int a[100];, float b[50];).
    • Xây dựng các hàm chuẩn cho mảng: Nhập số lượng phần tử NhapSL(int &n), nhập giá trị mảng NhapMang(), xuất giá trị mảng XuatMang().
    • Kỹ thuật thuật toán trên mảng: Lọc phần tử chia hết cho 3, tính tổng mảng, tính trung bình cộng toàn mảng hoặc phần tử dương, đếm và liệt kê các số nguyên tố trong mảng, tìm phần tử lớn nhất/nhỏ nhất, kiểm tra chống trùng lặp khi nhập và thuật toán sắp xếp mảng.

  6. Bài 6: Kiểu dữ liệu có cấu trúc (Struct)

    • Khái niệm cấu trúc (struct): Kiểu dữ liệu phức hợp tự định nghĩa gom nhóm nhiều trường dữ liệu thành phần có kiểu dữ liệu khác nhau.
    • Cú pháp khai báo struct và định danh kiểu bằng typedef struct <Tên_cấu_trúc> <Tên_mới>;. Truy xuất trường dữ liệu qua toán tử dấu chấm ..
    • Ứng dụng thực hành 1: Cấu trúc phân số PHANSO gồm hai trường nguyên tu và mau. Cài đặt các hàm nhập phân số (kiểm tra mẫu số khác 0 và chuẩn hóa dấu), xuất phân số dạng tu/mau, tìm ước chung lớn nhất UCLN(), rút gọn phân số RutGon(), cộng hai phân số Cong() và so sánh hai phân số SoSanh().
    • Ứng dụng thực hành 2: Cấu trúc quản lý sinh viên sinhvien (alias sv) gồm các trường: ten[11], mssv[11], lop[8], gioitinh, ntns, toan, ly, tin, DTB. Xây dựng mảng cấu trúc sinh viên, các hàm nhập/xuất danh sách sinh viên nhapdssv(), xuatdssv(), tìm kiếm sinh viên theo tên bằng hàm so sánh chuỗi strcmp(), đếm sinh viên có điểm trung bình lớn hơn 5 (DemsvDTB>5()), lọc danh sách sinh viên theo mã ngành (ví dụ ngành Tin học 'TH') và danh sách sinh viên nữ.

Kiến thức nền tảng được xây dựng

Giáo trình tập trung củng cố ba khối kiến thức nền tảng:

  • Nguyên lý kiểu dữ liệu và tổ chức ô nhớ: Cung cấp thông số kỹ thuật rõ ràng về số byte cấp phát cho từng kiểu dữ liệu cơ bản trong hệ thống và cú pháp đặc tả tương ứng trong thư viện vào/ra chuẩn.
  • Tư duy điều khiển luồng (Control Flow): Xây dựng nền tảng tư duy logic tuần tự, rẽ nhánh có điều kiện và lặp lại dựa trên điều kiện dừng, giúp sinh viên chuyển đổi mô hình bài toán toán học sang giải thuật lập trình.
  • Kỹ thuật module hóa (Modular Programming): Hướng dẫn phương pháp chia nhỏ chương trình thành các hàm chức năng độc lập, quản lý phạm vi biến (toàn cục, cục bộ), kiểm soát luồng dữ liệu vào/ra thông qua tham trị và tham biến.

Kỹ năng phát triển

Thông qua hệ thống bài tập, người học hình thành các nhóm kỹ năng cụ thể:

  • Kỹ năng lập trình kỹ thuật: Thành thạo thao tác viết mã nguồn trên các IDE C-Free/Dev-C++, dịch mã, nhận biết và xử lý các lỗi cú pháp (syntax errors) cũng như lỗi logic thời gian chạy (runtime errors).
  • Kỹ năng xử lý dữ liệu: Nắm vững các kỹ thuật kiểm tra tính hợp lệ của dữ liệu đầu vào (data validation), thao tác với chuỗi ký tự qua thư viện <string.h> (như hàm strcmp()), quản lý bộ đệm bàn phím bằng fflush(stdin) và flushall().
  • Kỹ năng thiết kế giải thuật cơ bản: Vận dụng được các giải thuật toán học phổ thông vào mã lệnh như thuật toán Euclid tìm ước chung lớn nhất, thuật toán kiểm tra số nguyên tố, thuật toán tính số ngày trong tháng, tìm giá trị cực đại/cực tiểu và thuật toán duyệt - thống kê trên mảng.

Phương pháp giảng dạy và học tập

+-------------------------------------------------------------------------+
|                  QUY TRÌNH HỌC TẬP VÀ ĐÁNH GIÁ MÔN HỌC                  |
+-------------------------------------------------------------------------+
|  GIAI ĐOẠN 1: CHUẨN BỊ (Tự học ở nhà)                                   |
|  - Nghiên cứu trước tài liệu lý thuyết từng bài                         |
|  - Gạch chân các khái niệm chưa rõ, chuẩn bị câu hỏi                     |
+-------------------------------------------------------------------------+
|  GIAI ĐOẠN 2: THỰC HÀNH TẠI PHÒNG MÁY (Có giảng viên hướng dẫn)          |
|  - Quan sát code mẫu, biên dịch và chạy thử nghiệm (F5/F11)             |
|  - Cài đặt các hàm và bài tập từ mức cơ bản đến nâng cao                 |
+-------------------------------------------------------------------------+
|  GIAI ĐOẠN 3: CỦNG CỐ VÀ RÈN LUYỆN (Sau buổi học)                       |
|  - Viết lại toàn bộ bài thực hành mà không nhìn code mẫu                |
|  - Hoàn thiện các bài tập mở rộng và nộp bài đánh giá hàng tuần         |
+-------------------------------------------------------------------------+

Phương pháp sư phạm tiếp cận

Giáo trình áp dụng mô hình tiếp cận thực hành - quy nạp (hands-on approach). Thay vì giảng giải lý thuyết trừu tượng kéo dài, mỗi chuyên đề được bố cục ngắn gọn:

  1. Nêu rõ mục tiêu cần đạt sau bài học.
  2. Tóm tắt cú pháp, ý nghĩa và ví dụ mẫu tối giản.
  3. Cung cấp bài tập thực hành kèm khung mã nguồn gợi ý và hướng dẫn giải thuật từng bước.

Hệ thống bài tập và thực hành

Các bài tập trong giáo trình được phân cấp từ mức độ làm quen đến ứng dụng:

  • Mức độ làm quen: Viết chương trình xuất văn bản, làm quen ký tự điều khiển (\n, \t), định dạng thiệp mời, nhập xuất biến đơn.
  • Mức độ áp dụng: Cài đặt các công thức toán học và hình học (diện tích/chu vi hình tròn $S = \pi r^2$, công thức Heron tính diện tích tam giác $S = \sqrt{p(p-a)(p-b)(p-c)}$).
  • Mức độ giải thuật: Tách số, kiểm tra tính chất số học, giải phương trình, xử lý mảng và cấu trúc dữ liệu.

Hướng dẫn tự học và phương pháp đánh giá

  • Yêu cầu đối với người học: Sinh viên bắt buộc phải chuẩn bị bài trước khi đến lớp, gạch chân các vấn đề chưa hiểu trong tài liệu để trao đổi với giảng viên. Sau mỗi buổi thực hành tại phòng máy, sinh viên phải làm lại toàn bộ bài tập ở nhà để củng cố kỹ năng gõ code và tư duy thuật toán.
  • Phương pháp đánh giá: Môn học sử dụng hình thức chấm điểm quá trình (chuyên cần, mức độ tham gia và điểm kiểm tra bài thực hành hàng tuần tại phòng máy).

Điểm nổi bật và tính thực tiễn

  • Tính chuẩn xác và bám sát thực nghiệm: Toàn bộ cú pháp và giải thuật trong giáo trình đều được thiết kế tương thích với các trình biên dịch C chuẩn, kèm theo hướng dẫn phím tắt biên dịch rõ ràng trên hai môi trường lập trình phổ biến trong giáo dục đại học là Dev-C++ và C-Free.
  • Mô hình hóa bài toán thực tế: Giáo trình không chỉ đưa ra các bài toán tính toán đại số thuần túy mà còn đưa vào các bài toán mô phỏng nghiệp vụ thực tế như:
    • Hệ thống tính tiền cước taxi lũy tiến theo số km và cước mở cửa.
    • Quản lý giờ vào/ra ca làm việc của nhân viên trong khung giờ từ 6h đến 18h.
    • Quản lý hồ sơ điểm số sinh viên, phân loại học tập và lọc hồ sơ theo ngành học (Tin học, Kế toán, Quản trị).
  • Quy chuẩn kỹ thuật viết mã: Tài liệu hướng dẫn chi tiết các thao tác chuẩn hóa dữ liệu, chẳng hạn như cơ chế xử lý trôi lệnh bằng việc xóa bộ nhớ đệm bàn phím (fflush(stdin) hoặc flushall()) trước khi nhập chuỗi ký tự, hay cách chuẩn hóa phân số có mẫu số âm thành mẫu số dương.

Đối tượng sử dụng giáo trình

Đối tượng Mục đích sử dụng Yêu cầu / Điều kiện tiên quyết
Sinh viên đại học/cao đẳng Học phần Thực hành Kỹ thuật Lập trình (năm thứ nhất ngành CNTT, Phần mềm, Hệ thống thông tin). Tư duy logic cơ bản, kiến thức toán học phổ thông (đại số, phương trình, hình học).
Giảng viên phòng máy Làm tài liệu hướng dẫn thực hành theo đề cương chi tiết môn học CMP3017. Phân bổ bài tập theo thời lượng từng buổi học trên phòng máy (6 bài/tuần).
Người tự học lập trình Làm tài liệu nhập môn ngôn ngữ lập trình C và rèn luyện kỹ năng giải thuật cơ sở. Cài đặt môi trường Dev-C++ hoặc C-Free; tự giác giải bài tập theo hướng dẫn.

Câu hỏi thường gặp

1. Giáo trình này phù hợp với những ai?

Tài liệu phù hợp cho sinh viên bắt đầu học lập trình tại các trường đại học, cao đẳng (đặc biệt là sinh viên theo học chương trình Công nghệ Thông tin môn CMP3017), cũng như người học cần tài liệu chuẩn hóa về cú pháp C và giải thuật cơ sở.

2. Cần chuẩn bị kiến thức nền tảng nào trước khi học?

Người học chỉ cần kiến thức toán học ở bậc trung học phổ thông (các phép toán số học, giải phương trình bậc nhất, bậc hai, tính chất hình học cơ bản) và khả năng tư duy logic; không đòi hỏi đã biết lập trình từ trước.

3. Điểm khác biệt của tài liệu so với sách lý thuyết là gì?

Tài liệu tập trung 100% vào việc rèn luyện kỹ năng viết mã (coding) và giải thuật trên máy tính. Mỗi phần kiến thức đều gắn liền với cấu trúc câu lệnh cụ thể, bảng tra cứu kiểu dữ liệu, các cảnh báo lỗi thường gặp và mã nguồn mẫu từng bước.

4. Làm thế nào để tự học giáo trình này đạt hiệu quả cao nhất?

Người học nên đọc phần tóm tắt lý thuyết, tự gõ lại các đoạn mã mẫu vào IDE Dev-C++ hoặc C-Free để kiểm tra kết quả hiển thị, sau đó tự cài đặt các bài tập thực hành nâng cao mà không phụ thuộc vào code gợi ý.

5. Giáo trình có cung cấp giải thuật chi tiết cho các bài toán phức tạp không?

Có. Giáo trình cung cấp giải thuật chi tiết dưới dạng từng bước logic (step-by-step) cho các bài toán như: kiểm tra 3 cạnh tam giác, tìm ước chung lớn nhất, kiểm tra số nguyên tố/số hoàn thiện, thuật toán tách đảo chữ số và thuật toán quản lý mảng cấu trúc sinh viên.

Kết luận

Tài liệu "Hướng Dẫn Học Lập Trình C: Bài Tập và Kiến Thức Cơ Bản" (CMP3017) là tài liệu học tập chuẩn mực về kỹ thuật lập trình thủ tục có cấu trúc bằng ngôn ngữ C. Việc hoàn thành toàn bộ 6 chuyên đề thực hành trong giáo trình giúp người học hình thành phản xạ tư duy lập trình vững chắc, nắm vững cấu trúc dữ liệu cơ sở và sẵn sàng tiếp cận các học phần nâng cao tiếp theo như Cấu trúc dữ liệu và Giải thuật, Lập trình hướng đối tượng và Hệ điều hành.