ผลต่างระหว่างรุ่นของ "การโปรแกรมภาษาซี สำหรับโปรแกรมเมอร์จาวาและซีชาร์ป"

จาก Theory Wiki
ไปยังการนำทาง ไปยังการค้นหา
แถว 146: แถว 146:
 
  gcc square.c -o square
 
  gcc square.c -o square
  
สิ่งที่เกิดขึ้นระหว่างการคอมไพล์เพื่อสร้างแฟ้ม <tt>square</tt> ที่ทำงานได้ คือคอมไพเลอร์จะแปลแฟ้ม <tt>square.c</tt> ให้เป็นแฟ้มเป้าหมาย (object file) ก่อน ในแฟ้มดังกล่าวจะประกอบไปด้วยรหัสภาษาเครื่องของคำสั่งที่เขียนใน <tt>square.c</tt> ทั้งหมด อย่างไรก็ตาม สังเกตว่า โปรแกรมดังกล่าวมีการใช้งานฟังก์ชัน <tt>scanf</tt> และ <tt>printf</tt> ซึ่งไม่ได้ถูกนิยามไว้ในแฟ้มดังกล่าว (แม้มีการประกาศฟังก์ชันในแฟ้ม <tt>stdio.h</tt> แต่ไม่มีการระบุนิยามของฟังก์ชันดังกล่าว)
+
สิ่งที่เกิดขึ้นระหว่างการคอมไพล์เพื่อสร้างแฟ้ม <tt>square</tt> ที่ทำงานได้ คือคอมไพเลอร์จะแปลแฟ้ม <tt>square.c</tt> ให้เป็นแฟ้มวัตถุ (object file) ก่อน ในแฟ้มดังกล่าวจะประกอบไปด้วยรหัสภาษาเครื่องของคำสั่งที่เขียนใน <tt>square.c</tt> ทั้งหมด อย่างไรก็ตาม สังเกตว่า โปรแกรมดังกล่าวมีการใช้งานฟังก์ชัน <tt>scanf</tt> และ <tt>printf</tt> ซึ่งไม่ได้ถูกนิยามไว้ในแฟ้มดังกล่าว (แม้มีการประกาศฟังก์ชันในแฟ้ม <tt>stdio.h</tt> แต่ไม่มีการระบุนิยามของฟังก์ชันดังกล่าว)
  
ในขั้นตอนของการสร้างแฟ้มเป้าหมาย ถ้าโปรแกรมมีการอ้างอิงถึงฟังก์ชันที่อยู่นอกขอบเขตแฟ้ม การอ้างอิงดังกล่าวจะถูก "จด" เอาไว้ เพื่อนำไปค้นหาและเชื่อมโยงต่อในขั้นตอนการลิงก์
+
ในขั้นตอนของการสร้างแฟ้มวัตถุ ถ้าโปรแกรมมีการอ้างอิงถึงฟังก์ชันที่อยู่นอกขอบเขตแฟ้ม การอ้างอิงดังกล่าวจะถูก "จด" เอาไว้ เพื่อนำไปค้นหาและเชื่อมโยงต่อในขั้นตอนการลิงก์
  
 
เราสามารถสั่งให้ <tt>gcc</tt> ทำงานเฉพาะขั้นตอนแรกได้โดยสั่ง
 
เราสามารถสั่งให้ <tt>gcc</tt> ทำงานเฉพาะขั้นตอนแรกได้โดยสั่ง
แถว 161: แถว 161:
 
  ต้องการ: scanf, printf
 
  ต้องการ: scanf, printf
  
เมื่อนำแฟ้มเป้าหมายดังกล่าวที่มีการประกาศ <tt>main</tt> ไปลิงก์เข้ากับไลบรารีภาษาซี ซึ่งมีการประกาศ <tt>scanf</tt> และ <tt>printf</tt> ไว้ ก็จะได้ผลลัพธ์ที่ต้องการ
+
เมื่อนำแฟ้มวัตถุดังกล่าวที่มีการประกาศ <tt>main</tt> ไปลิงก์เข้ากับไลบรารีภาษาซี ซึ่งมีการประกาศ <tt>scanf</tt> และ <tt>printf</tt> ไว้ ก็จะได้ผลลัพธ์ที่ต้องการ
  
 
'''หมายเหตุ''': เราสามารถทดลองดูผลลัพธ์ที่เกิดจากการ "หากันไม่เจอได้" โดยลองเปลี่ยนชื่อฟังก์ชัน <tt>main</tt> หรือแก้ฟังก์ชัน <tt>scanf</tt> หรือ <tt>printf</tt> เป็นชื่ออื่นที่ไม่มีการนิยามในระบบ
 
'''หมายเหตุ''': เราสามารถทดลองดูผลลัพธ์ที่เกิดจากการ "หากันไม่เจอได้" โดยลองเปลี่ยนชื่อฟังก์ชัน <tt>main</tt> หรือแก้ฟังก์ชัน <tt>scanf</tt> หรือ <tt>printf</tt> เป็นชื่ออื่นที่ไม่มีการนิยามในระบบ
  
 
=== การลิงก์เมื่อมีแฟ้มโปรแกรมต้นฉบับหลายแฟ้ม ===
 
=== การลิงก์เมื่อมีแฟ้มโปรแกรมต้นฉบับหลายแฟ้ม ===
 +
 +
จากตัวอย่างที่แล้ว ทุก ๆ แฟ้มโปรแกรมต้นฉบับเมื่อแปลงเป็นแฟ้มวัตถุจะมีการประกาศนิยามวัตถุต่าง ๆ เอาไว้ สมมติเรามีแฟ้มโปรแกรมสองแฟ้มดังนี้
 +
 +
'''แฟ้ม <tt>a.c</tt>'''
 +
<geshi lang="c">
 +
include <stdio.h>
 +
 +
void a()
 +
{
 +
  printf("this is a\n");
 +
}
 +
 +
void c()
 +
{
 +
  b();
 +
  printf("this is c\n");
 +
}
 +
 +
main()
 +
{
 +
  c();
 +
}
 +
</geshi>
 +
 +
'''แฟ้ม <tt>b.c</tt>'''
 +
<geshi lang="c">
 +
#include <stdio.h>
 +
 +
void b()
 +
{
 +
  a();
 +
  printf("this is b\n");
 +
}
 +
</geshi>
 +
 +
เมื่อสั่งคอมไฟล์แฟ้มทั้งสองด้วยคำสั่ง
 +
 +
gcc -c a.c
 +
gcc -c b.c
 +
 +
ได้แฟ้มวัตถุ <tt>a.o</tt> และ <tt>b.o</tt> มา แต่ละแฟ้มจะมีข้อมูลสำหรับการเชื่อมโยงและการอ้างอิงดังนี้
 +
 +
      a.o                    b.o
 +
---------------        ----------------
 +
has: main, a, c        has: b
 +
want: b                want: a
 +
 +
ดังนั้น เมื่อเรานำทั้งสองแฟ้มมาลิงก์รวมกัน การอ้างอิงดังกล่าวก็จะถูกเชื่อมโยงได้เรียบร้อย  การลิงก์สามารถทำได้โดยสั่ง
 +
 +
gcc a.o b.o
 +
 +
ผลลัพธ์ที่ได้จะอยู่ในแฟ้ม <tt>a.out</tt> ตามปกติ  ถ้าหากต้องการได้แฟ้มที่ทำงานได้ชื่อ abc เราสามารถใช้ option '''-o''' ในการระบุชื่อแฟ้มได้ โดยสั่ง
 +
 +
gcc a.o b.o -o abc
 +
 +
=== การประกาศฟังก์ชัน ===
 +
 +
อย่างไรก็ตาม ถ้าเราแก้ไขแฟ้ม <tt>b.c</tt> ให้เป็นดังนี้
 +
 +
'''แฟ้ม <tt>b.c</tt>'''
 +
<geshi lang="c">
 +
#include <stdio.h>
 +
 +
void b(int x)  /* เปลี่ยนการประกาศ */
 +
{
 +
  int i;
 +
 +
  for(i=0; i<x; i++)
 +
    a();
 +
  printf("this is b\n");
 +
}
 +
</geshi>
 +
 +
เราจะพบว่า เรายังสามารถรวมแฟ้มโปรแกรม <tt>a.c</tt> และ <tt>b.c</tt> เข้าด้วยกันได้เช่นเดิม อย่างไรก็ตาม เราพบว่าการเรียกใช้ฟังก์ชัน <tt>b</tt> ใน <tt>a.c</tt> นั้น'''ผิดพลาด''' เพราะว่ามีการเรียกใช้ฟังก์ชันโดยส่งค่าผิด
 +
 +
สังเกตว่าระหว่างที่คอมไพเลอร์แปลโปรแกรม <tt>a.c</tt> นั้น คอมไพเลอร์ไม่มีข้อมูลของฟังก์ชัน <tt>b</tt> อยู่เลย ทำให้ไม่ทราบว่าการเรียกใช้นั้นผิดพลาด
 +
 +
ความผิดพลาดเช่นนี้สามารถป้องกันได้โดยใส่การประกาศฟังก์ชัน <tt>b</tt> ไว้ก่อนที่ตอนต้นของโปรแกรม <tt>a.c</tt> ดังนี้
 +
 +
<geshi lang="c">
 +
#include <stdio.h>
 +
 +
void b(int x);
 +
 +
void a()
 +
{
 +
  // . . . ละไว้
 +
}
 +
// . . . ละไว้
 +
</geshi>
 +
 +
เมื่อสั่งคอมไพล์เราจะพบว่าคอมไพเลอร์แสดงข้อผิดพลาดดังนี้
 +
 +
$ gcc a.c b.c
 +
a.c: In function ‘c’:
 +
a.c:12: error: too few arguments to function ‘b’
 +
 +
ดังนั้นเพื่อรับประกันว่าการเรียกใช้ฟังก์ชันนั้นถูกต้อง เราจึงต้องมีการประกาศฟังก์ชันไว้ก่อนที่จะใช้ นี่เป็นอีกสาเหตุหนึ่งที่เราต้อง include แฟ้ม <tt>stdio.h</tt>

รุ่นแก้ไขเมื่อ 14:32, 12 กรกฎาคม 2552

เอกสารนี้เกี่ยวข้องกับการโปรแกรมภาษาซี โดยออกแบบสำหรับผู้มีความรู้พื้นฐานการโปรแกรมในภาษาตระกูล java และ c# มาแล้ว

<geshi lang="c">

  1. include <stdio.h>

main() {

 printf("Hello, world.\n");

} </geshi>

พอยน์เตอร์ (Pointers)

โปรแกรมภาษาซีมองหน่วยความจำเป็นตาราง แต่ละหน่วยย่อยของหน่วยความจำจะมีตำแหน่งระบุอยู่ ไล่เรียงกันไป หน่วยย่อยสุดของการอ้างถึงหน่วยความจำคือไบต์

พอยน์เตอร์เป็นตัวแปรที่ใช้เก็บตำแหน่งในหน่วยความจำ หรือเรียกว่าตัวแปรพอยน์เตอร์ ชี้ ไปยังตำแหน่งที่มันเก็บอยู่

อย่างไรก็ตามเนื่องจากการชี้ไปยังหน่วยความจำตำแหน่งใด ๆ โดยไม่ระบุประเภทข้อมูลที่เก็บอยู่ที่จุดนั้นไม่เพียงพอในการประมวลผล โดยทั่วไปแล้วการประกาศพอยน์เตอร์จำเป็นจะต้องระบุประเภทข้อมูลที่ตัวแปรนั้นชี้ไปด้วย

การประกาศตัวแปรแบบพอยน์เตอร์ทำได้โดยการใส่ * หน้าชื่อตัวแปร เช่นการเขียน int *a; คือการประกาศให้ตัวแปร a เป็นตัวแปรพอยน์เตอร์ไปยังตำแหน่งข้อมูลที่เก็บข้อมูลประเภท int

เมื่อเรามีตัวแปรพอยน์เตอร์แล้ว การอ้างถึง ข้อมูล ที่ตัวแปรนั้นชี้อยู่ ทำได้โดยใช้ตัวดำเนินการ * ใส่ด้านหน้า ในทางกลับกัน การหาตำแหน่งในหน่วยความจำจากตัวแปร (หรือข้อมูล) ทำได้โดยใช้ตัวดำเนินการ & พิจารณาโปรแกรมด้านล่าง

<geshi lang="c">

  1. include <stdio.h>

main() {

 int a = 10;
 int b = 20;
 int *c;
 printf("%d, %d\n",a,b);
 c = &a;
 *c = 30;
 printf("%d, %d\n",a,b);
 c = &b;
 *c = 40;
 printf("%d, %d\n",a,b);  

} </geshi>

ให้ผลลัพธ์เป็น

10, 20
30, 20
30, 40

พอยน์เตอร์มีประโยชน์มากในการเขียนฟังก์ชันให้มีผลข้างเคียง (side effect) ตัวอย่างเช่นฟังก์ชัน swap ด้านล่าง

<geshi lang="c"> void swap(int *a, int *b) {

 int tmp = *a;
 *a = *b;
 *b = tmp;

} </geshi>

เนื่องจากตัวแปรแบบพอยน์เตอร์เป็นตัวแปรที่อยู่ในหน่วยความจำ ตัวแปรเราจึงมีตัวแปรพอยน์เตอร์ที่ชี้ไปยังข้อมูลแบบพอยน์เตอร์ได้ พิจารณาส่วนของโปรแกรมต่อไปนี้

<geshi lang="c">

 int a = 10, b = 20;
 int *c = &a;
 int **d = &c;
 *c = 30;   // ตัวแปร a เปลี่ยนค่าเป็น 30
 *d = &b;   // ตอนนี้ c ชี้ไปที่ b
 *c = 100;  // ตัวแปร b เปลี่ยนค่าเป็น 100
 **d = 200;  // **d = *(*d) = *c นั่นคือ หลังคำสั่งนี้ ตัวแปร b เปลี่ยนค่าเป็น 200

</geshi>

การอ่านและเขียนผลลัพธ์

สำหรับการอ่านสตริง ดูในส่วนของการประมวลผลสตริง (ด้านล่าง)

คำสั่งพื้นฐานของภาษา C ในการอ่านและเขียนผลลัพธ์คือ scanf และ printf ซึ่งประกาศอยู่ในไฟล์หัว stdio.h

ในการอ่านและแสดงผลลัพธ์นั้น ฟังก์ชันทั้งสองจะพิจารณาข้อมูลและตัวแปรที่รับมาตามประเภทข้อมูลที่ระบุใน format string (ซึ่งระบุเป็นอาร์กิวเมนต์แรก)

พิจารณาส่วนของโปรแกรมต่อไปนี้

<geshi lang="c">

 int a;
 float b;
 scanf("%d %f", &a, &b);
 printf("a plus 100 is %d.  b divided by 2 is %f.\n", a+100, b/2);

</geshi>

สังเกตว่าในตัวอย่างข้างต้นฟังก์ชัน scanf นั้นรับอาร์กิวเมนต์เป็นตำแหน่งของตัวแปร a และ b อย่างที่เกริ่นไว้ ถ้าเราไม่ได้ระบุชนิดข้อมูล (%d สำหรับ int หรือ %d สำหรับ float) ฟังก์ชัน scanf ก็จะไม่ทราบว่าจะจัดการกับข้อมูลที่อ่านเข้ามาอย่างไร

ในการอ่านข้อมูลด้วยฟังก์ชัน scanf นั้น ฟังก์ชันดังกล่าวจะอ่านข้ามช่องว่างและบรรทัดใหม่ให้เสมอทำให้สะดวกเวลาอ่านข้อมูลหลาย ๆ ตัว (แต่อาจมีปัญหาบ้างถ้าต้องการอ่าน string ที่มีช่องว่างอยู่ด้วย)

ความผิดพลาดที่เกิดขึ้นบ่อยเวลาใช้ฟังก์ชัน scanf ก็คือการลืมใส่ & เพื่อระบุตำแหน่ง เช่นดังตัวอย่างด้านล่าง

<geshi lang="c">

 int a;
 scanf("%d", a);   // ถ้า a มีค่า 0, scanf จะพยายามเขียนข้อมูลลงในตำแหน่ง 0

</geshi>

อย่างไรก็ตาม ไม่ใช่ว่าเราจะใส่ & เสมอไป ตัวอย่างเช่น ส่วนของโปรแกรมด้านล่างอ่านข้อมูลเข้าไปที่ตัวแปร a ได้อย่างถูกต้อง

<geshi lang="c">

 int a; int *b = &a;
 scanf("%d", b);     // b ชี้ไปที่ a

</geshi>

ด้านล่างเป็นตารางของ format ที่ใช้บ่อย ๆ (รวมทั้งตัวอย่างการระบุการเว้นและทศนิยมสำหรับใช้ในคำสั่ง printf)

formatประเภทข้อมูล
%dint
%5dแสดง int แบบ 5 หลัก ชิดขวา
%ffloat
%5.2fแสดง float แบบ 5 หลักมีทศนิยม 2 ตำแหน่ง
%lfdouble
%sstring, เมื่อใช้กับฟังก์ชัน scanf จะถือว่า string ดังกล่าวมีขอบเขตอยู่ที่ช่องว่างหรือบรรทัดใหม่

อาร์เรย์และพอยน์เตอร์

โครงสร้าง (struct)

อาร์กิวเมนต์จาก command line

การประมวลผลสตริง

การคอมไพล์และลิงก์โปรแกรมที่อยู่ในหลายแฟ้ม

วิธีการคลาสสิกในการจัดการงานที่ใหญ่ ก็คือการแบ่งงานดังกล่าวเป็นส่วนย่อย ๆ การพัฒนาโปรแกรมก็เช่นเดียวกัน ถ้าโปรแกรมที่เราต้องการพัฒนามีขนาดใหญ่ การแบ่งโปรแกรมดังกล่าวออกเป็นส่วนย่อย ๆ ที่มีขนาดเล็กลงมักช่วยให้พัฒนาและทดสอบความถูกต้องได้ง่ายขึ้น นอกจากนี้ยังมีประโยชน์ที่ช่วยลดเวลาในการคอมไพล์อีกด้วย (โปรแกรมใหญ่ ๆ ถ้าคอมไพล์ทั้งหมดอาจใช้เวลานานมาก)

ในการนำแฟ้มโปรแกรมต้นฉบับหลาย ๆ แฟ้มมารวมกัน เราจำเป็นจะต้องเข้าใจการทำงานพื้นฐานของการคอมไพล์และลิงก์เสียก่อน

แฟ้มเป้าหมายและการลิงก์

พิจารณาโปรแกรมตัวอย่างด้านล่าง สมมติว่าชื่อ square.c

<geshi lang="c">

  1. include <stdio.h>

main() {

 int a;
 scanf("%d",&a);
 printf("The square of %d is %d\n", a, a*a);

} </geshi>

เมื่อเราสั่ง

gcc square.c -o square

สิ่งที่เกิดขึ้นระหว่างการคอมไพล์เพื่อสร้างแฟ้ม square ที่ทำงานได้ คือคอมไพเลอร์จะแปลแฟ้ม square.c ให้เป็นแฟ้มวัตถุ (object file) ก่อน ในแฟ้มดังกล่าวจะประกอบไปด้วยรหัสภาษาเครื่องของคำสั่งที่เขียนใน square.c ทั้งหมด อย่างไรก็ตาม สังเกตว่า โปรแกรมดังกล่าวมีการใช้งานฟังก์ชัน scanf และ printf ซึ่งไม่ได้ถูกนิยามไว้ในแฟ้มดังกล่าว (แม้มีการประกาศฟังก์ชันในแฟ้ม stdio.h แต่ไม่มีการระบุนิยามของฟังก์ชันดังกล่าว)

ในขั้นตอนของการสร้างแฟ้มวัตถุ ถ้าโปรแกรมมีการอ้างอิงถึงฟังก์ชันที่อยู่นอกขอบเขตแฟ้ม การอ้างอิงดังกล่าวจะถูก "จด" เอาไว้ เพื่อนำไปค้นหาและเชื่อมโยงต่อในขั้นตอนการลิงก์

เราสามารถสั่งให้ gcc ทำงานเฉพาะขั้นตอนแรกได้โดยสั่ง

gcc -c square.c

เราจะได้แฟ้มผลลัพธ์ชื่อ square.o แฟ้มดังกล่าวจะระบุข้อมูลดังนี้

square.o
--------
มี: main
ต้องการ: scanf, printf

เมื่อนำแฟ้มวัตถุดังกล่าวที่มีการประกาศ main ไปลิงก์เข้ากับไลบรารีภาษาซี ซึ่งมีการประกาศ scanf และ printf ไว้ ก็จะได้ผลลัพธ์ที่ต้องการ

หมายเหตุ: เราสามารถทดลองดูผลลัพธ์ที่เกิดจากการ "หากันไม่เจอได้" โดยลองเปลี่ยนชื่อฟังก์ชัน main หรือแก้ฟังก์ชัน scanf หรือ printf เป็นชื่ออื่นที่ไม่มีการนิยามในระบบ

การลิงก์เมื่อมีแฟ้มโปรแกรมต้นฉบับหลายแฟ้ม

จากตัวอย่างที่แล้ว ทุก ๆ แฟ้มโปรแกรมต้นฉบับเมื่อแปลงเป็นแฟ้มวัตถุจะมีการประกาศนิยามวัตถุต่าง ๆ เอาไว้ สมมติเรามีแฟ้มโปรแกรมสองแฟ้มดังนี้

แฟ้ม a.c <geshi lang="c"> include <stdio.h>

void a() {

 printf("this is a\n");

}

void c() {

 b();
 printf("this is c\n");

}

main() {

 c();

} </geshi>

แฟ้ม b.c <geshi lang="c">

  1. include <stdio.h>

void b() {

 a();
 printf("this is b\n");

} </geshi>

เมื่อสั่งคอมไฟล์แฟ้มทั้งสองด้วยคำสั่ง

gcc -c a.c
gcc -c b.c

ได้แฟ้มวัตถุ a.o และ b.o มา แต่ละแฟ้มจะมีข้อมูลสำหรับการเชื่อมโยงและการอ้างอิงดังนี้

      a.o                     b.o
---------------         ----------------
has: main, a, c         has: b
want: b                 want: a

ดังนั้น เมื่อเรานำทั้งสองแฟ้มมาลิงก์รวมกัน การอ้างอิงดังกล่าวก็จะถูกเชื่อมโยงได้เรียบร้อย การลิงก์สามารถทำได้โดยสั่ง

gcc a.o b.o

ผลลัพธ์ที่ได้จะอยู่ในแฟ้ม a.out ตามปกติ ถ้าหากต้องการได้แฟ้มที่ทำงานได้ชื่อ abc เราสามารถใช้ option -o ในการระบุชื่อแฟ้มได้ โดยสั่ง

gcc a.o b.o -o abc

การประกาศฟังก์ชัน

อย่างไรก็ตาม ถ้าเราแก้ไขแฟ้ม b.c ให้เป็นดังนี้

แฟ้ม b.c <geshi lang="c">

  1. include <stdio.h>

void b(int x) /* เปลี่ยนการประกาศ */ {

 int i;
 for(i=0; i<x; i++)
   a();
 printf("this is b\n");

} </geshi>

เราจะพบว่า เรายังสามารถรวมแฟ้มโปรแกรม a.c และ b.c เข้าด้วยกันได้เช่นเดิม อย่างไรก็ตาม เราพบว่าการเรียกใช้ฟังก์ชัน b ใน a.c นั้นผิดพลาด เพราะว่ามีการเรียกใช้ฟังก์ชันโดยส่งค่าผิด

สังเกตว่าระหว่างที่คอมไพเลอร์แปลโปรแกรม a.c นั้น คอมไพเลอร์ไม่มีข้อมูลของฟังก์ชัน b อยู่เลย ทำให้ไม่ทราบว่าการเรียกใช้นั้นผิดพลาด

ความผิดพลาดเช่นนี้สามารถป้องกันได้โดยใส่การประกาศฟังก์ชัน b ไว้ก่อนที่ตอนต้นของโปรแกรม a.c ดังนี้

<geshi lang="c">

  1. include <stdio.h>

void b(int x);

void a() {

 // . . . ละไว้

} // . . . ละไว้ </geshi>

เมื่อสั่งคอมไพล์เราจะพบว่าคอมไพเลอร์แสดงข้อผิดพลาดดังนี้

$ gcc a.c b.c 
a.c: In function ‘c’:
a.c:12: error: too few arguments to function ‘b’

ดังนั้นเพื่อรับประกันว่าการเรียกใช้ฟังก์ชันนั้นถูกต้อง เราจึงต้องมีการประกาศฟังก์ชันไว้ก่อนที่จะใช้ นี่เป็นอีกสาเหตุหนึ่งที่เราต้อง include แฟ้ม stdio.h