Transcript C language

Function
ั
ฟังก์ชน
ความหมาย
การประกาศ
และการใช ้
1
ฟั งก์ ช~ ัน (Function)
การเขียนโปรแกรมแบบโครงสร ้าง
ฟังกชั
์ นมาตรฐาน (Library
ั functions)
ชนิดของฟั งก์ชน
ฟังกชั
่ ฒ
ั นาเองโดย
์ นทีพ
ั
การใชฟั้ งก์ชน
โปรแกรมเมอร(User
defined
์
ั functions)
การกาหนดฟังก์ชน
(Function definition)
้ ง
ั (Function invocation)
การเรียกใชฟ
ั ก์ชน
ั
โปรโตไทป์ของฟังก์ชน(Function
prototype)
ั มาตรฐานสาหรับการประมวลผล
ฟั งก์ชน
อักขระ
2
การเขียนโปรแกรมแบบโครงสร้าง
ั เจน
ใชผั้ งงานแบบโครงสร ้าง ทีม
่ รี ป
ู แบบชด
ั ซอนให
้
ย่อยปั ญหาหรืองานทีซ
่ บ
้เป็ นกลุม
่ ของ
งานง่ายๆ
ให ้แต่ละกลุม
่ งานย่อยเป็ นมอดูล(Module)
โดยกาหนดหน ้าทีแ
่ ละการสง่ ผ่านข ้อมูล
ั เจน
ระหว่าง มอดูลอย่างชด
คิดในเชงิ นามธรรม ด ้วยการอธิบายว่าสงิ่ นัน
้ ๆ
(หรือมอดูล) ทาอะไร แต่ยังไม่จาเป็ นต ้องบอก
ว่า ทาอย่างไร
3
การเขียนโปรแกรมแบบโครงสร้าง
ั้ ๆ
มองโปรแกรมเป็ นชน
ั ้ บนสุดเป็ นนามธรรมมากทีส
ชน
่ ด
ุ และเป็ น
ภาพง่ายทีส
่ ด
ุ
ั ้ หนึง่ เราก็จะได ้
เมือ
่ พิจารณาตา่ ลงมาชน
รายละเอียดเพิม
่ มากขึน
้
ั ้ ล่างสุด แสดงรายละเอียดทีป
ชน
่ ลีกย่อย
ทีส
่ ด
ุ
4
ั
ฟังก์ชนมาตรฐาน
(Library Functions)
ั
โปรโตไทป์ ของฟั งก์ชน
ประกาศไว้ในแฟ้มข้อมูลทีม
่ น
ี ามสกุล เป็น .h
int getch ( void ) ;
เรียกการประกาศนีโ้ ดยใช ้
ื่ แฟ้ม.h>
#include <ชอ
#include <conio.h>
ั ~ ขึน
การเรียกใชฟั้ งก์ชน
้ กับรูปแบบโปรโตไทป์ ของ
ั นั น
่
ฟั งก์ชน
้ ๆ เชน
ch = getch ( ) ;
ั ~ มีพร ้อมแล ้วในไลบรารี
การกาหนดฟั งก์ชน
5
ั
ฟังก์ชนมาตรฐานส
าหร ับการประมวลผลอ ักขระ
ฟั งก์ ชันสำหรับรับอักขระ
int getch(void); /*read a character from the console, no echo*/
int getche(void); /*read a character from the console, echo */
int getchar(void); /*read a character from stdin*/
ฟั งก์ ชันสำหรับแสดงอักขระ
int putch(int ); /* write a character to the console */
int putchar(int); /* write a character to stdout */
ฟั งก์ชนั /แมคโคร ใน ctype.h ~ ฟั งก์ชนั หรื อแมคโครที่ช่วยอำนวย
ควำมสะดวกในกำรเขียนโปรแกรม เช่น ฟั งก์ชนั ตรวจสอบว่ำตัว
อักขระนันเป็
้ นตัวพิมพ์ใหญ่หรื อไม่
6
้ ง
ั
การใชฟ
ั ก์ชนมาตรฐานร
ับอ ักขระ
getch()
เพื่อทำกำรอ่ ำน ตัวอักขระ จำกแป้นพิมพ์ โดยไม่ มีกำรสะท้ อนให้ เห็น
ตัวอักขระที่ป้อน
Include file
: <conio.h>
Prototype
: int getch ( void );
Argument
: ไม่ มี หรือไม่ ต้องระบุ
Return
: ค่ ำรหัส ASCII ของอักขระที่อ่ำนได้
int c;
c = getch();
/*ทันทีที่กดปุ่ ม ตัวอักขระจะไม่ปรำกฏ แต่จะถูกอ่ำน ดังนันเวลำป
้
้ อน จึงไม่ต้อง
กด Enter*/
printf(“Input character is %c with ASCII value %d\n”, c, c); 7
้ ง
ั
การใชฟ
ั ก์ชนมาตรฐานร
ับอ ักขระ
getche()
เพื่อทำกำรอ่ ำน ตัวอักขระ จำกแป้นพิมพ์ โดยมีกำรสะท้ อนให้ เห็น
ตัวอักขระที่ป้อน
Include file
Prototype
: <conio.h>
: int getche ( void );
Argument
:
Return
: ค่ ำรหัส ASCII ของอักขระที่อ่ำนได้
ไม่ มี หรือไม่ ต้องระบุ
int c;
c = getche();
/*ทันทีที่กดปุ่ ม ตัวอักขระจะปรำกฏ และจะถูกอ่ำน ดังนันเวลำป
้
้ อน จึงไม่
ต้ องกด Enter*/
printf(“Input character is %c with ASCII value %d\n”, c, c); 8
้ ง
ั
การใชฟ
ั ก์ชนมาตรฐานแสดงอ
ักขระ
putch()
เพื่อทำกำรแสดงตัวอักขระจำกแป้นพิมพ์ โดยมีกำรสะท้ อนให้ เห็น
ตัวอักขระที่ป้อน
Include file : <stdio.h>
Prototype
: int putch ( int );
Argument
: อักขระที่ต้องกำรแสดง
Return : ในกรณีที่แสดงได้ จะให้ คำ่ รหัส ASCII ของอักขระที่แสดง
ในกรณีที่แสดงไม่ได้ จะให้ เป็ นค่ำ EOF
putch(48); /* แสดง 0 */
putch(‘\a’); /* แสดงเสียงบี๊บ */
putch(‘A’+5); /* แสดงตัวอักษร F*/
int c, i;
for (i=1; i<5; i++) {
c = getch();
putch(‘*’);
}
9
้ ง
ั
การใชฟ
ั ก์ชนมาตรฐานร
ับอ ักขระ
getchar()
เพื่อทำกำรอ่ ำนทีละตัวอักขระ จำกบัฟเฟอร์ ของแป้นพิมพ์
(Keyboard buffer) โดยมีกำรสะท้ อนให้ เห็นตัวอักขระที่ป้อน
Include file
Prototype
: <stdio.h>
: int getchar ( void );
Argument
:
Return
: อักขระที่อ่ำนได้ ถ้ ำอ่ ำนไม่ ได้ จะให้ ค่ำเป็ น EOF
ไม่ มี หรือไม่ ต้องระบุ
int c;
c = getchar();
printf(“Input character is %c with ASCII value %d\n”, c, c);
10
้ ง
ั
การใชฟ
ั ก์ชนมาตรฐานแสดงอ
ักขระ
putchar()
เพื่อทำกำรแสดงตัวอักขระทำงอุปกรณ์ แสดงผลมำตรฐำน
Include file : <conio.h>
Prototype
: int putchar ( int );
Argument
: รหัส ASCII ของอักขระที่ต้องกำรแสดง
Return : อักขระที่แสดงหรื อปรำกฏ
ในกรณีที่แสดงไม่ได้ จะให้ เป็ นค่ำ EOF
putchar(48); /* แสดง 0 */
putchar(‘\a’); /* แสดงเสียงบี๊บ */
putchar(‘A’+5); /* แสดงตัวอักษร F*/
11
้ ง
ั าหร ับการประมวลผลอ ักขระ
ต ัวอย่างการใชฟ
ั ก์ชนส
จงเขียนโปรแกรมเพื่อรับอักขระ แล้ วแสดงชุดของอักขระที่รับ โดย
แสดงเป็ นตัวพิมพ์ใหญ่ทงหมด
ั้
พร้ อมทังแทรกบรรทั
้
ดว่ำงหำกเจอ
กำรขึ ้นบรรทัดใหม่ หยุดกำรป้อนข้ อมูลด้ วยกำรกด Control-D
เช่น รับข้ อมูลเป็ น I’ll be a champion! <กด enter>
ผลลัพธ์ได้ เป็ น I’LL BE A CHAMPION!
<เว้ น 1 บรรทัด>
<cursor รอรับกำรป้อนข้ อมูล>
12
ตัวอย่าง (ต่อ)
Start
Get C
y
C != ^D
y
‘a’<= C <=‘z’
n
n
Stop
C = ‘\n’ n
y
Print double new line
Capitalize C
Get C
Print C
13
ั สาหรับการประมวลผลอักขระ
ตัวอย่างการใชฟั้ งก์ชน
#include <stdio.h>
#define ControlD
4
#define NEWLINE ‘\n’
void main ( ) {
int c;
/* get characters, stop at end of file */
}
while ((c = getchar()) != ControlD)
if (‘a’ <= c && c <= ‘z’)
putchar(c + ‘A’ - ‘a’); /*print out the upper case letter */
else
if (c == NEWLINE) {
putchar(NEWLINE); /*write the newline character*/
putchar(NEWLINE); /*another one to double space*/
}
else
putchar(c); /*Otherwise just output the character*/
14
The macro in ctype.h
Macro
isalpha(c)
isupper(c)
islower(c)
isdigit(c)
isalnum(c)
isxdigit(c)
isspace(c)
ispunct(c)
iscntrl(c)
isascii(c)
Nonzero is returned if :
toupper(c)
tolower(c)
toascii(c)
change c to uppercase
change c to lowercase
change c to ASCII code
Function / Macro effect
c is a letter
c is an uppercase letter
c is a lowercase letter
c is a digit
c is a letter or digit
c is a hexadecimal digit
c is a white space character
c is a punctuation character
c is a control character
c is an ASCII code
15
ั สาหรับการประมวลผลอักขระ
ตัวอย่างการใชฟั้ งก์ชน
#include <stdio.h>
#include <ctype.h>
#define ControlD
4
#define NEWLINE ‘\n’
void main ( ) {
int c;
while ((c = getchar()) != ControlD)
if (islower(c))
putchar(toupper(c)); /*print out the upper case letter */
else
if (c == NEWLINE) {
putchar(NEWLINE); /*write the newline character*/
putchar(NEWLINE); /*another one to double space*/
}
else
putchar(c); /*Otherwise just output the character*/ 16
}
ฟั งก์ ชันที่พัฒนำโดยโปรแกรมเมอร์
ั (Function definition)
การกาหนดฟั งก์ชน
ั (Function invocation)
การเรียกใชฟั้ งก์ชน
ั
การประกาศโครงร่างหรือรูปแบบการเรียกใชฟั้ งก์ชน
(Function prototype)
ลาดับการวาง มี 2 ลักษณะ
1. Function definition
1. Function prototype
2. Function invocation
2. Function invocation
3. Function definition
17
ต ัวอย่าง
#include <stdio.h>
void prn_msg(void) {
printf(“Message for you only :\n”);
printf(“Have a nice day!!! \n”);
}
void main() {
prn_msg(); /* function is invoked here*/
}
18
กำรกำหนดฟั งก์ ชัน
Function header
ื่ ฟั งก์ชน
ั (การประกาศ พารามิเตอร์)
ชนิดข ้อมูลทีส
่ ง่ กลับ ชอ
{
ั ;
การประกาศตัวแปรภายในฟั งก์ชน
คาสงั่ ;
return ค่าทีต
่ ้องการสง่ กลับ ;
}
Function body
int min (int x, int y) {
return (x<y? x : y);
}
19
return statement
ั ทีถ
คาสงั่ หยุดการทางานของฟั งก์ชน
่ ก
ู เรียกและ
ั ทีเ่ รียก
ย ้ายการทางานกลับไปยังฟั งก์ชน
โดยในการย ้ายการทางานกลับนั น
้ อาจมีการสง่ ค่า
ั ด ้วย
กลับหรือกาหนดค่าให ้กับฟั งก์ชน
่ กล ับ
กรณีไม่มค
ี า
่ สง
return;
่ กล ับ
กรณีมค
ี า
่ สง
return นิพจน์;
ั ต้อง
โดยทีช
่ นิดข้อมูลของนิพจน์และของฟังก์ชน
เป็นชนิดเดียวก ัน
20
ต ัวอย่าง
void ex_sub(int x) {
if (x < 0) return;
printf(“Have a nice day!!! \n”);
}
int max(int x, int y) {
return (x > y ? x : y);
}
21
กำรเรียกใช้ ฟังก์ ชัน
รูปแบบ จะต้ องสอดคล้ องกับที่ประกำศ
ในส่วนหัวของฟั งก์ชนั หรือ
ตำมรูปแบบโปรโตไทป์ของฟั งก์ชนั
หำกฟั งก์ชนั มีชนิดข้ อมูลเป็ น void จะเรี ยกใช้ ฟังก์ชนั ดังนี ้
Function name (); หรื อ
Function name (argument list);
หำกฟั งก์ชนั มีชนิดข้ อมูลเป็ นอย่ำงอื่น(ที่ไม่ใช่ void) จะ
เรี ยกใช้ ฟังก์ชนั โดยมีตวั แปรรอรับค่ำ หรื อไม่ก็ได้
โดยกำรส่งค่ำของอำร์ กิวเมนต์ให้ กบั พำรำมิเตอร์ เป็ นลักษณะของกำร
คัดลอกค่ำ (Call by value)
22
ตัวอย่ ำงกำรเรี ยกใช้ (๑)
void ex_sub(int x) {
if (x < 0) return;
printf(“Have a nice day!!! \n”);
}
อำร์ กิวเมนต์
ex_sub(8); /*Have a nice day!!! will be displayed*/
ex_sub(-1); /* Nothing’s displayed */
23
ตัวอย่ ำงกำรเรี ยกใช้ (๒)
int max (int x, int y) {
return (x > y ? x : y);
}
int
maximum;
printf(“Maximum of 8 and 80 is %d\n”, max(8, 80));
/*80 will be displayed*/
maximum = max(8, 80);
printf(“Maximum of 8 and 80 is %d\n”, maximum);
24
แบบฝึ กหัด
จงหำแสดงผลลัพธ์ เมื่อทำกำรรันโปรแกรมต่ อไปนี ้
#include <stdio.h>
void A (int x) {
printf(“%d : ”, x);
}
void B (int x) {
A(++x);
printf(“%d : ”, x);
}
void main () {
B(8);
A(2);
B(10);
}
25
ฟั งก์ ชันที่พัฒนำโดยโปรแกรมเมอร์ (2)
โปรโตไทป์ของฟั งก์ ชัน
จำเป็ นต้ องมีในกรณีที่กำรกำหนดฟั งก์ชนั ถูกประกำศไว้ หลังกำร
เรี ยกใช้
ประกำศไว้ ก่อนกำรเรี ยกใช้ และก่อนกำรกำหนดฟั งก์ชนั
มีรูปแบบเหมือนส่วนหัวของฟั งก์ชนั นัน่ เอง แต่ไม่มีชื่อพำรำมิเตอร์
รูปแบบ
ชนิดข้ อมูลที่ส่งกลับ ชื่อฟั งก์ ชัน (ชนิดข้ อมูลของพารามิเตอร์ );
int max ( int, int ) ;
26
ต ัวอย่าง
#include <stdio.h>
int max (int, int); /* Function prototype */
void main ( ) {
int maximum;
printf(“Maximum of 8 and 80 is %d\n”, max(8, 80));
/*80 will be displayed*/
maximum = max(8, 80);
printf(“Maximum of 8 and 80 is %d\n”, maximum);
}
int max(int x, int y) {
return (x > y ? x : y);
}
27
ฟั งก์ ชันที่พัฒนำโดยโปรแกรมเมอร์ (3)
ประเภทของฟั งก์ ชัน ~ จำแนกตำมลักษณะกำรส่งผ่ำนข้ อมูล
ฟั งก์ ชันที่ไม่ มีกำรส่ งผ่ ำนข้ อมูล
ฟั งก์ ชันที่ส่งค่ ำทำงเดียว
ฟั งก์ ชันที่มีกำรส่ งค่ ำกลับไปที่ช่ ือฟั งก์ ชัน
ฟั งก์ ชันที่มีกำรผ่ ำนค่ ำไปกลับ
ฟั งก์ ชันมำตรฐำน อำจถูกจำแนกได้ ในลักษณะเดียวกันนี ้
กำรส่ งผ่ ำนค่ ำ มี ๒ แบบ
Call by value
Call by reference
28
ั ไ่ ม่มก
่ ผ่านข้อมูล
ฟังก์ชนที
ี ารสง
ั
รูปแบบการกาหนดฟั งก์ชน
ื่ ฟั งก์ชน
ั (){
void ชอ
ั
การประกาศตัวแปรภายในฟั งก์ชน
คาสงั่ หรือชุดคาสงั่
}
รูปแบบของโปรโตไทป์
อาจเป็ นคาสั่ งเพือ
่ เรียกใช้
ฟังกชั
่ ได้ ยกเวน
้
์ นอืน
ฟังกชั
์ น main()
ื่ ฟั งก์ชน
ั ( ) ;
void ชอ
29
ต ัวอย่าง
#include <stdio.h>
void makeline ( ) {
int i=0;
for (; i<= 80; i++)
putchar(‘=’);
putchar(‘\n’);
}
void main ( ) {
makeline( );
printf(”Heading”);
makeline( );
}
#include <stdio.h>
void makeline ( );
void main ( ) {
makeline( );
printf(” Heading” );
makeline( );
}
void makeline ( ) {
int i=0;
for (; i<= 80; i++)
putchar(‘=’);
putchar(‘\n’);
}
30
ั ส
่ ค่าทางเดียว
ฟังก์ชนที
่ ง
ั
การกาหนดฟั งก์ชน
ื่ ฟั งก์ชน
ั (การประกาศพารามิเตอร์์)์ {
void ชอ
ั
การประกาศตัวแปรภายในฟั งก์ชน
คาสงั่ หรือชุดคาสงั่
}
อาจเป็ นคาสั่ งเพือ
่ เรียกใช้
ฟังกชั
่ ได้ ยกเวนฟั
้ งกชั
์ นอืน
์ น
main()
การประกาศโปรโตไทป์
ื่ ฟั งก์ชน
ั ( ชนิดข ้อมูลของพารามิเตอร์);
void ชอ
ชนิดขอมู
้ ลและจานวน ของ
การเรียกใช ้
อารกิ
ยวกับ
่
์ วเมนต ์ เป็ นอยางเดี
ื่ ฟั งก์ชน
ั (อาร์กวิ เมนต์
พารามิ
ชอ
); เตอร ์
31
ั ส
่ ค่าทางเดียว
ต ัวอย่าง - ฟังก์ชนที
่ ง
/*Demonstrate passing by value*/
#include <stdio.h>
#define Heading ”Report Heading”
void makeline (int);
void main ( ) {
makeline(10);
printf(Heading); putchar(‘\n’);
makeline(strlen(Heading));
}
void makeline (int a) {
for ( ; a > 0; a--)
putchar(‘=’);
putchar(‘\n’);
}
==========
Report Heading
==============
_
32
ฟั งก์ ชันที่มีกำรส่ งค่ ำกลับไปที่ช่ ือฟั งก์ ชัน
กำรกำหนดฟั งก์ ชัน
ชนิดข้ อมูลทีส่ ่ งกลับ ชื่อฟั งก์ ชัน ์์() {
การประกาศตัวแปรภายในฟั งก์ ชัน
คาสั่งหรือชุดคาสั่ง
่ ีชนิดข้ อมูลเดียวกับฟั งก์ ชัน ;
return ค่ าทีม
}
โปรโตไทป์ของฟั งก์ ชัน
ชนิดข้ อมูล ชื่อฟั งก์ ชัน ();
กำรเรียกใช้ ฟังก์ ชัน
ตัวแปรทีม่ ารั บค่ า = ชื่อฟั งก์ ชัน ( );
33
ต ัวอย่าง
# include <stdio.h>
int getdigit( ) {
char c;
c = getche( );
return ((‘ 0 ’ <= c && c <= ‘ 9 ’) ? c - ’0 ’ : -1);
}
int getnum ( ) {
getnum.h
int
i, num=0;
while ((i=getdigit()) != -1)
num = num*10 + i;
return num;
}
void main ( ) {
printf(“Input number is %d\007\n”, getnum());
}
34
ต ัวอย่าง(ต่อ)
# include <stdio.h>
#include “getnum.h”
void main ( ) {
printf(“Input number is %d\007\n”, getnum());
}
35
ฟั งก์ ชันที่มีกำรผ่ ำนค่ ำไปกลับ
ั
การกาหนดฟั งก์ชน
ื่ ฟั งก์ชน
ั (การประกาศพารามิเตอร์) {
ชนิดข ้อมูลทีส
่ ง่ กลับ ชอ
ั
การประกาศตัวแปรภายในฟั งก์ชน
คาสงั่ หรือชุดคาสงั่
ั ;
return ค่าทีม
่ ช
ี นิดข ้อมูลเดียวกับฟั งก์ชน
}
ื่ ฟั งก์ชน
ั (ชนิดข ้อมูลของพารามิเตอร์);
ชนิดข ้อมูล ชอ
่ื ฟั งก์ชน
ั (อาร์กวิ เมนต์ ) ;
ตัวแปรทีม
่ ารับค่า = ชอ
36
ั านวณค่าแฟคตอเรียล
ตัวอย่าง - ฟังก์ชนค
#include <stdio.h>
#include <getnum.h>
long factor (int );
void main ( ) {
int n;
printf(“Enter a positive number, finish by pressing Enter”);
n = getnum( );
printf(“Factorial of %d = %ld\n”, n, factor(n));
}
long factor ( int n) {
long fl=1;
for (; n > 0; n--) fl *= n;
return fl;
}
37
ย ังมีตอ
่ ...
กำรส่ งผ่ ำนข้ อมูลแบบ Call by value
ค่ำของอำร์ กิวเมนต์จะถูก copy ให้ เป็ นค่ำของพำรำมิเตอร์ ใน
ฟั งก์ชนั ที่ถกู เรี ยก
กำรเปลี่ยนแปลงค่ำของพำรำมิเตอร์ ในฟั งก์ชนั ที่ถกู เรี ยก จะไม่มีผล
ต่อค่ำของอำร์ กิวเมนต์ในส่วนของฟั งก์ชนั ที่เรี ยกไปยังฟั งก์ชนั นันๆ
้
Call by reference
ค่ำของอำร์ กิวเมนต์จะมีชนิดข้ อมูลเป็ นพอยน์เตอร์ (pointer)
หรื อตำแหน่งในหน่วยควำมจำ
38
แบบฝึ กห ัด
จงเขียนฟั งก์ชนั ชื่อ reverse เพื่อทำกำรกลับหลัก ของเลขจำนวนหนึ่ง
เช่น เรี ยกฟั งก์ชนั เป็ น
result = reverse(325);
เมื่อทำงำนสำเร็ จ result จะมีคำ่ เป็ น 523
จงเขียนโปรแกรมเพื่อพิมพ์ปฎิทินของแต่ละเดือน ตำมต้ องกำร โดยไม่ใช้ ตวั แปร
ชุด กำหนดให้ วันที่ 1 มกรำคม พ.ศ. 2545 ตรงกับวันอังคำร
จงเขียนโปรแกรมทำกำร Zapping ข้ อมูลที่ป้อน 1 บรรทัด โดยให้ ตดั ช่องว่ำง
ออก และเปลี่ยนตัวอักษรแรกของคำที่ป้อนให้ เป็ นพิมพ์ใหญ่
เช่น ป้อนข้ อมูลเป็ น The final day is Sunday.
ผลลัพธ์ที่ได้ เป็ น TheFinalDayIsSunday.
39