Object Pascal - Label

สวัสดีครับ การบ้านเป็นยังไงบ้างครับ ยากไปไหมเอ่ย ลองมาดูเฉลยกันเลย

7)

8)

9)

10)

11)

12)

มาถึงเรื่องของวันนี้กันดีกว่า นั้นก็คือเรื่อง Label นั้นเอง !!!

แล้วเจ้า Label มันคืออะไร ?
    มันก็คือตำแหน่งที่เรา mark ไว้เพื่อจะสามารถย้อนกลับมาทำงานได้ เรื่องนี้ไม่มีอะไร ลองดูตัวอย่างกันเลย (เพื่อความสะดวกขอเอาการบ้านข้อ 12 มาดัดแปลงละกัน)

ลองดูที่บรรทัดที่ 8 จะเห็นว่ามีการประกาศ Label ชื่อว่า Main ไว้
บรรทัดที่ 15 มีการกำหนดจุดเริ่มต้นของ Main
บรรทัดที่ 24 เป็นการกระโดดไปทำงานที่ Main
ส่วนคำสั่ง Exit ในบรรทัดที่ 19 เอาไว้ออกจากฟังก์ชั่นที่ทำงานอยู่ ในที่นี้หมายถึงออกจากโปรแกรม

ส่วนใหญ่แล้วจะไม่ค่อยได้ใช้ Label กันสักเท่าไร เพราะมีโอกาสที่จะใช้ผิดมาก (สับสนว่ามันกระโดดไปไหน ถ้ามี Label เยอะ ๆ)

วันนี้ก็เอาไว้เท่านี้ ไว้เจอกันใหม่วันเสาร์ครับ ^_^

Object Pascal - วนซ้ำ

สวัสดีครับ เมื่อวานลืมมาเขียนต่อ ต้องขอโทษด้วยนะครับ ^_^

ก่อนอื่นเลย เรามาเฉลยการบ้านกันก่อนดีกว่า

5)

6)

เอาหล่ะครับ มาขึ้นเรื่องของวันนี้ดีกว่า ซึ่งก็คือเรื่อง การวนซ้ำ (Looping) นั้นเอง

Loop ใน Object Pascal มีอยู่ 3 แบบด้วยกัน คือ
  - While
  - Repeat Until
  - For

ลองมาดู Loop แบบ While กันก่อนดีกว่า

    Loop จะทำงานเมื่อเงื่อนไขเป็นจริง พอทำเสร็จก็จะมาเช็คเงื่อนไขใหม่ ถ้ายังเป็นจริงอยู่ก็ทำซ้ำไปเรื่อย ๆ จนกว่าเงื่อนไขจะเป็นเท็จ

ต่อไปมาดู Loop แบบ Repeat Until กันดีกว่า

    เมื่อรันโปรแกรม จะทำคำสั่งระหว่าง repeat ... until ก่อน 1 รอบ แล้วไปเช็คเงื่อนไขว่าเป็นจริงหรือเท็จ ถ้าเป็น เท็จ จะวนลูปต่อ แต่ถ้าเป็น จริง จะหลุดออกจากลูป (repeat until แปลว่า ทำซ้ำ จนกระทั่ง)

Loop แบบที่ 3 เป็นลูปที่วนซ้ำโดยมีตัวนับ ลองดู code กันเลย

    ทำงานโดยขั้นแรก จะกำหนดค่าให้ I เป็น Low แล้วทำงานในลูป พอจบ 1 รอบ จะบวก I ขึ้น 1 (I := I + 1) แล้วทำซ้ำจนรอบสุดท้าย I เป็น High
  เช่น for I := 0 to 9 do เป็นการวนซ้ำ 10 รอบ (จาก 0 ถึง 9)

ลองดูตัวอย่างโปรแกรมรับค่าตัวเลขที่ไม่ติดลบ ถ้าติดลบให้รับค่าเข้ามาใหม่

ลองดูตัวอย่าง Loop for กันบ้าง

จะเห็นว่าค่า Low จะต้อง น้อยกว่า High เสมอ เพราะถ้า Low > High จะไม่มีการเข้าไปทำงานในลูป
  แต่ถ้าต้องการให้ไล่จากมากไปน้อย เราจะใช้ downto แทน to เช่น

สำหรับลูป while จะให้ดู code โปรแกรมหาผลรวมของตัวเลขจำนวนเต็มที่รับเข้ามาจนกว่าผลรวมจะมีค่ามากกว่ากว่าหรือเท่ากับ 1 หมื่น

จบแล้วครับ สั้นนิดเดียวเอง ต่อไปก็ถึงการบ้านแล้ว ^_^

7) จงเขียนโปรแกรมรับค่าจำนวนเต็ม แล้วใช้ for วนลูปพิมพ์สูตรคูณแม่ที่รับเข้ามา
8) จงเขียนโปรแกรมพิมพ์สูตรคูณตั้งแต่แม่ 2 ถึง แม่ 12 โดยใช้ for
9) จงเขียนโปรแกรมรับค่าเข้ามาเรื่อย ๆ จนกว่าค่าที่รับเข้ามาจะน้อยกว่าค่าที่รับเข้ามาก่อนหน้า
10) จงเขียนโปรแกรมรับค่าเข้ามาเรื่อย ๆ จนกว่าค่าที่รับเข้ามาจะน้อยกว่าค่าที่รับเข้ามาก่อนหน้า 2 ครั้งติดกัน
11) จงเขียนโปรแกรมหาค่าเฉลี่ยเงินเดือน ให้รับค่าเงินเดือนเข้ามาจนกว่าค่าที่รับเข้ามาจะน้อยกว่าหรือเท่ากับ 0
12) จงเขียนโปรแกรมรับค่าจำนวนเต็มแล้วหาค่า Factorial ( ! ) ซึ่ง
0! = 1
1! = 1
2! = 2 * 1
3! = 3 * 2 * 1
n! = n * n-1 * n-2 * ... * 1 เมื่อ n > 0

Object Pascal - เงื่อนไข

สวัสดีครับ กลับมาเจอกันอีกแล้ว ไม่รู้ว่ามีคนอ่านรึเปล่านะ ฮ่า ๆ

เป็นยังไงบ้างครับ ได้ลองเขียนโปรแกรมคำนวณอะไรเล็ก ๆ น้อย ๆ พวก พื้นที่สามเหลี่ยม ฯลฯ เล่นกันรึยังครับ

วันนี้ผมจะมาบอกวิธีเพิ่มเงื่อนไขลงไปในโปรแกรมครับ

เรื่องนี้ก็ไม่มีอะไรมากครับ แค่ตรวจสอบค่าเงื่อนไข ว่าถ้าเป็นจริงให้ทำอย่างหนึ่ง แต่ถ้าไม่จริงให้ทำอีกอย่าง

มาดูเงื่อนไขแบบแรกเลยครับ เป็นเงื่อนไขแบบ ถ้าจริงให้ทำอย่างหนึ่ง แต่ถ้าไม่จริงให้ข้ามไปทำสั่งต่อไป
เป็นแบบคือ if _____ then
อย่างเช่น ผมจะเช็คว่า ค่าที่รับเข้ามาเป็นเลขคู่ใช่หรือไม่ ถ้าใช่ให้แสดงผลว่า Even ลองมาดู Source Code กันเลยครับ

จาก Source Code นะครับ จะเห็นว่า ถ้าเลขที่รับเข้ามาเป็นเลขคู่ (หาร 2 แล้วเหลือเศษ 0) ให้พิมพ์คำว่า Even แล้วก็พิมพ์คำว่า End แต่ถ้ารับค่ามาเป็นเลขคี่ จะไม่เข้าไปทำงานในคำสั่ง if จะพิมพ์คำว่า End เลย

ลองดูผลการรัน

จะเห็นว่ามันจะทำงานคำสั่งหลังคำสั่ง if เพียงคำสั่งเดียว แล้วถ้าต้องการให้ทำหลาย ๆ คำสั่งหล่ะ ?
  เราจะใช้บล็อกคำสั่ง หรือก็คือ begin ... end; นั้นเอง
ลองใส่ begin end; กันดูครับ

ต่อไปเป็นถ้าเช็คเงื่อนไขแบบ ถ้าจริงให้ทำอย่างหนึ่ง แต่ถ้าไม่จริงให้ทำอีกอย่าง
เราจะใช้ if ___ then ___ else ___
ลองดูตัวอย่างเลย

ถ้าสังเกตดี ๆ จะเห็นว่า หลังคำสั่งก่อนที่จะขึ้น else ไม่มี ; (Semi-Colon) ปิดท้าย

เราจะไม่ใส่ ; ปิดท้ายคำสั่งสุดท้าย ก่อนที่จะขึ้น else ถ้าเราใช้ begin end เราจะไม่ใส่ ; หลัง end เช่น

if อีกแบบ คือ if else if จริง ๆ ก็ไม่ใช่แบบใหม่หรอก แต่เป็นการซ้อน if เข้าไปอีกชั้น
เช่นถ้าเราจะตรวจสอบว่า เลขที่ใส่เข้ามา อยู่ระหว่างช่วงไหน เราจะเขียนได้เป็นแบบนี้

ลองเขียนแล้วรันดูนะครับ ;)

นอกจากนี้เรายังสามารถเชื่อมเงื่อนไข หลายเงื่อนไขเข้าด้วยกันได้โดยใช้ and, or หริอ xor
แต่จะต้องใส่วงเล็บแต่ละเงื่อนไขด้วย เช่น

  ต่อไปเงื่อนไขอีกแบบ ก็คือเงื่อนไขแบบ case of คือการเลือก ทำงานคล้าย ๆ if else if แต่ใช้ได้กับ ตัวอักษร (Char) กับ จำนวนเต็ม เท่านั้น
  ลองเอา Code ข้างบนมาเปลี่ยนเป็น case of ดูจะได้ว่า

เจอแบบนี้เลยอาจจะงง
ลองมาดูตัวอย่างแบบง่าย ๆ ดีกว่า เช่น ตรวจสอบว่าค่าที่ใส่มาเป็น 1, 2 หรือ 3

จะเห็นว่า โครงสร้างของ case of จะเป็น
case ตัวแปรที่ตรวจสอบ of
  case_1: คำสั่ง1;
  case_2: คำสั่ง2;
  ...
  else คำสั่งเมื่อไม่ใช่ค่าที่ตรวจสอบข้างบน
end;

เราจะใส่ else หรือไม่ใส่ก็ได้ และยังสามรถใช้ begin end; ได้อีกด้วย และถ้าต้องการตรวจสอบหลายค่า
เช่น เป็น 1, 2 หรือ 1..10, 30..40 ลองดูคำสั่งดีกว่าครับ :)

เป็นยังไงบ้างครับ หวังว่าจะเข้าใจกันนะครับ

ก่อนจากกันวันนี้ ผมขอฝากการบ้านไว้สักหน่อยละกันครับ ฝึกเยอะ ๆ จะได้เก่ง ๆ

5) เขียนโปรแกรมรับค่าคะแนน แล้วตรวจสอบว่าคะแนนอยู่ช่วงไหน แล้วแสดงเกรดดังนี้
คะแนน 0 - 49 เกรด F
คะแนน 50 - 60 เกรด D
คะแนน 61 - 70 เกรด C
คะแนน 71 - 80 เกรด B
คะแนน 81 - 100 เกรด A

6) รับค่าเงินเข้ามาแล้วเช็คว่า ถ้าค่าที่รับเข้ามาน้อยกว่า 1 หมื่นบาท จะได้ดอกเบี้ย 3% แต่ถ้ามากกว่า 1 หมื่นบาท แต่น้อยกว่า 1 แสนบาท จะได้ดอกเบี้ย 6% ถ้ามากกว่านั้นจะได้ดอกเบี้ย 8%

วันนี้ก็เอาไว้แค่นี้นะครับ :)

Object Pascal - ตัวแปรและตัวดำเนินการ

สวัสดีเพื่อน ๆ พี่ ๆ น้อง ๆ ทุกคนครับ
เมื่อวานผมไม่ได้มาเขียนเพิ่ม หวังว่าจะยังไม่ลืมนะครับ ;)

   วันนี้ผมจะมาทบทวนเรื่องตัวแปรสักหน่อย เรื่องนี้เป็นพื้นฐานที่สำคัญมาก ๆ รวมถึงการดำเนินการกับตัวแปรด้วย

   ยังจำกันได้ไหมครับว่ากฎการตั้งชื่อตัวแปรมีอะไรบ้าง ถ้าจำไม่ได้ให้กลับไปอ่านะครับ :)
ผมจะมาเพิ่มกฎพิเศษอีกข้อนึง แต่คงเรียกว่ากฎพิเศษไม่ได้หรอก เพราะมันไม่เหมือนกับกฎการตั้งชื่อตัวแปรในภาษาอื่น
   นั้นก็คือ การตั้งชื่อตัวแปรที่ซ้ำกับคำสงวน เราสามารถใช้อักขระพิเศษ & นำหน้าได้ ไม่ใช่แค่ใช้กับชื่อที่ซ้ำกับคำสงวนเท่านั้น ยังใช้กับชื่อตัวแปรธรรมดาได้อีกด้วย ไม่ใช่แค่ใช้กับ Delphi ได้นะครับ ยังใช้กับ Free Pascal (Lazarus) ได้อีกด้วย เพราะว่าภาษา Object Pascal จะถือว่าตัวพิมพ์เล็ก และตัวพิมพ์ใหญ่เป็นตัวเดียวกัน การที่จะตั้งชื่อตัวแปรให้ไม่ซ้ำกันคงจะยาก
    เช่นในภาษา C ถ้าจะใช้ตัวแปรเก็บค่าที่เหมือนกัน 2 ค่า บางคนอาจจะประกาศชื่อเป็น a, A ซึ่งถือเป็นคนละตัวกันในภาษา C แต่ใน Object Pascal จะถือเป็นตัวแปรตัวเดียวกัน

ผมขอเอาตารางคำสงวนจาก help ของ Delphi XE มาให้ดูนะครับ

(ms-help://embarcadero.rs_xe/rad/Fundamental_Syntactic_Elements.html)

   ลองใช้ & มาสร้างตัวแปรที่ใช้ชื่อในคำสงวนพวกนั้นดูครับ ;)

มาดูเรื่องการดำเนินการ (Expression) กันดีกว่าครับ
    ลองดูรูปแบบการดำเนินการแบบต่าง ๆ ดูกัน ~

X - ตัวแปร
@X - ค่าตำแหน่งในหน่วยความจำของตัวแปร X
10 - ค่าคงที่ตัวเลข
Write(X) - เรียกฟังก์ชัน
X * Y - X คูณ Y
X / (X - 1) - เอา X - 1 มาหาร X พูดแบบนี้อาจจะงง เปลี่ยนใหม่เป็น หาร X ด้วย X - 1 ดีกว่า
X := 5 - การกำหนดค่า
X = 5 - ตรวจสอบว่า X = 5
อย่างสับสนเครื่องหมาย := กับ = นะครับ
:= คือการนำค่าทางขวาไปกำหนดให้ตัวแปรทางซ้าย ส่วน = คือการตรวจสอบว่า ค่าทั้งสองค่า เท่ากันหรือไม่
X in SetA - ตรวจสอบว่า X อยู่ใน เซ็ต ที่ชื่อ SetA หรือไม่
not B - ค่าตรงข้ามทางตรรกศาสตร์ของตัวแปร B
หมายถึง
  not True = False (ไม่จริง = เท็จ)
  not False = True (ไม่เท็จ = จริง)
['a', 'b', 'c'] - เซ็ต
Char(50) - การเปลี่ยนชนิด

เรื่องที่เขียนมาเมื่อกี้อาจจะงง ๆ ไม่ต้องไปสนใจครับ เดี๋ยวได้ใช้แล้วจะเข้าใจเอง :)

ลองมาดูตัวดำเนินการกันดีกว่าครับ

Arithmetic Operators (ตัวดำเนินการทางคณิตศาสตร์)
คิดว่าคงไม่ต้องบอกมากนะครับ ว่าแต่ละเครื่องหมาย หมายถึงอะไร
+ - * / div mod
ขอบอกแค่ 2 ตัวนะครับ คือ div กับ mod
   div คือการหาร แล้วตัดเศษทิ้ง ตัดทิ้งนะครับ ไม่ปัดขึ้น ค่าที่ได้จะเป็นจำนวนจริง
เช่น
3 div 2 = 1
10 div 3 = 2
   mod คือการหารเอาเศษ หรือก็คือ x mod y = x - (x div y) * y
เช่น
3 mod 2 = 1
10 mod 3 = 1
10 mod 4 = 2
ควรระวังเวลาใช้ x / y , x div y , x mod y เมื่อ y = 0 จะทำให้เกิด Runtime Error

Boolean Operators (ตัวดำเนินการทางตรรกศาสตร์)
not (negation)
and (conjunction)
or (disjunction)
xor (exclusive disjunction)
สามารถอ่านเพิ่มเติมได้ในหนังสือคณิต ม. 4 นะครับ

Relational Operators
=     เท่ากับ
<>   ไม่เท่ากับ
<     น้อยกว่า
>     มากกว่า
<=   น้อยกว่าหรือเท่ากับ
>=   มากกว่าหรือเท่ากับ

ที่ยกมาเป็นแค่บางส่วนที่สำคัญ ยังมีตัวดำเนินการอีกแต่อาจจะยังไม่จำเป็นต้องใช้ตอนนี้เลยขอไม่กล่าวถึง


ลำดับความสำคัญของตัวดำเนินการ
  การดำเนินการจะเรียงลำดับความสำคัญไว้ตามนี้ครับ

(ms-help://embarcadero.rs_xe/rad/Expressions_(Delphi).html)

ตัวอย่างเช่น 1 + 3 * 2 จะบวก หรือคูณก่อน ?
  คำตอบคือ 1 + 3 * 2 = 1 + (3 * 2) = 1 + 6 = 7
ซึ่งก็คือ คูณมีลำดับความสำคัญก่อนบวก
สำหรับตัวดำเนินการที่มีความสำคัญเท่ากัน เช่น * / div mod จะทำจากซ้ายไปขวา เช่น
  3 * 2 / 6 * 5 mod 2 ซึงก็คือ ((3 * 2) / 6) * 5 = (6 / 6) * 5 = 1 * 5 = 5

วันนี้ขอจบลงเท่านี้นะครับ ยังไม่มีการบ้านเช่นเคย แต่ขอให้ไปฝึกใช้เครื่องหมายกันดูนะครับ
สวัสดีครับผม ^-^

Object Pascal - ค่าคงที่

สวัสดีครับ เจอกันอีกแล้วนะครับ ;)

ก่อนอื่นผมขอเฉลยการบ้านของเมื่อวานนะครับ

3) ข้อนี้ทำเหมือนในตัวอย่างเลยครับ

4) ข้อนี้ก็ไม่มีอะไรครับ ให้รับข้อมูลเป็นแบบ string แทน

เป็นยังไงบ้างครับ ไม่ยากเลยใช่ไหมหล่ะ :)

มาเข้าเรื่องของวันนี้ดีกว่าครับ
    ซึ่งก็คือเรื่อง ...  ค่าคงที่ ยังไงหล่ะครับ ^_^

แล้วไอค่าคงที่มันคืออะไรหล่ะ ?
    มันก็เหมือนกับตัวแปรที่เก็บค่า ๆ เดียวตลอดการทำงานของโปรแกรม โดยที่ไม่สามารถเปลี่ยนค่าของมันได้
    ตัวอย่างเช่น ค่าคงที่ทางคณิตศาสตร์ เช่น ค่า พาย มีค่าประมาณ 3.14159265358979324
เราอาจจะประกาศค่าคงที่ Pi = 3.14159265358979324 ไปเลย
วิธีการประกาศง่ายกว่าการประกาศตัวแปรอีกครับ

const
   Pi = 3.14159265358979324;

หรือจะกำหนดชนิดของค่าคงที่ก็ได้ เช่น
const
   Pi : Double = 3.14;

ลองดูตัวอย่างโปรแกรมเลยครับ

    ส่วนใหญ่แล้ว ชื่อค่าคงที่จะใช้ตัวใหญ่ทั้งหมด แต่ก็ไม่ได้มีกฎอะไร ที่ให้ใช้ตัวใหญ่เพราะเราจะได้แยกความแตกต่างระหว่างตัวแปรกับค่าคงที่ได้ แต่ในภาษา Object Pascal จะถือว่าตัวอักษรตัวใหญ่ กับตัวเล็กถือเป็นตัวเดียวกับ เช่น A กับ a เป็นตัวเดียวกัน
    เราจึงสามารถเขียนฟังก์ชัน Writeln เป็น writeln หรือ WriteLn หรือ WRITELN หรือ wrITeLN ก็ได้ มีความหมายเหมือนกัน
    เรายังสามารถพิมพ์คำสั่งหลายคำสั่งในบรรทัดเดียวกันก็ได้ แต่อย่าลืมใส่ ; (Semi-Colon) ปิดท้ายด้วยหล่ะ
    เช่น เราจะพิมพ์ว่า
   Write('Input: '); Readln(R); Ans = R * R; Writeln('Ans = ', R:0:2);
    แบบนี้ก็ไม่ผิดครับ แต่จะทำให้เราอ่านยาก เวลาเขียนโปรแกรมจึงควรจะพิมพ์ให้เราอ่านง่ายมากที่สุด

    หัวข้อของวันนี้ก็จบลงเพียงเท่านี้
    เรื่องนี้ไม่มีอะไรยากครับ วันนี้ผมขอไม่ให้การบ้านนะครับ ^_^ พอดีพึ่งกลับมาถึงบ้าน คิดโจทย์ไม่ทัน ต้องขออภัย สำหรับคนที่รอ
    ส่วนพรุ่งนี้ผมกลับดึกมาก คงไม่ได้มาเขียนต่อ ยังไงก็ต้องขอโทษล่วงหน้าด้วยนะครับ

สำหรับวันนี้ก็ สวัสดีครับ

Object Pascal - ตัวแปร

สวัสดีครับ กลับมาเจอกันอีกเช่นเคย จนถึงตอนนี้ ผมขอขอบคุณเพื่อน ๆ พี่ ๆ น้อง ๆ ทุกคนที่เข้ามาอ่านนะครับ

ถึงจะมีไม่กี่คนก็เถอะ :)

ก่อนอื่นเลยผมขอเฉลยการบ้านของเมื่อวานก่อนนะครับ

1) โจทย์คือให้พิมพ์ชื่อของตนเองลงไป ก็ง่าย ๆ ครับ จัดยัดลงใน Write หรือ Writeln ได้เลยครับ

แล้วก็อย่าลืมใส่ Readln; ต่อท้ายด้วยนะครับ ^-^

2) ข้อนี้ก็ไม่มีอะไรครับ ใช้ Writeln 3 ตัวก็ได้แล้วครับ

เป็นไงบ้างครับ ไม่ยากเลยใช่ไหม

ก่อนจะเริ่มในส่วนของวันนี้ พอดีมีคนถามมาว่า มีโปรแกรมอื่นที่ใช้แทน Delphi ได้ไหม

     มีครับ เป็นโปรแกรมฟรี ก็คือ Lazarus ครับ โหลดได้จากเว็บของ Free Pascal ครับ

     http://www.freepascal.org/

สำหรับการสร้าง Project ใน Lazarus นะครับ ให้สร้างแบบ Program ธรรมดา ไม่ต้องสร้างแบบ Console Application นะครับ เพราะมันเป็นคนละแบบกัน

ส่วน Source Code ที่มันเขียนมาให้ ก็ไม่ต้องไปสนใจครับ ให้เขียน Code ของเราในส่วนของ begin - end. ก็พอครับ ลองดูในรูปนะครับ

เอาละครับ มาถึงหัวข้อในวันนี้กันครับ

วันนี้เราจะมาเรียนเรื่อง ตัวแปร กันครับ

แล้วตัวแปรมันคืออะไรหล่ะ

     ตัวแปร (Variable) ก็คือตัวเก็บข้อมูลครับ คงจะเคยเจอกันในคณิตแล้ว เช่น ตัวแปร x, y, z อะไรทำนองนั้น

     แต่ตัวแปรในการเขียนโปรแกรมจะต้องกำหนดชนิดของตัวแปร เช่น จำนวนเต็ม จำนวนจริง ข้อความ ตัวอักษร ฯลฯ

     ตัวแปรแต่ละชนิดจะเก็บข้อมูลต่างชนิดไม่ได้นะครับ เช่นประกาศตัวแปรให้เก็บจำนวนเต็ม จะไปเก็บจำนวนจริง (จำนวนที่มีทศนิยม) ไม่ได้ นอกจากจะแปลงค่าจำนวนจริงให้เป็นจำนวนเต็มก่อน (เช่น ปัดทศนิยมขึ้น หรือตัดทศนิยมทิ้ง)

    รูปแบบการประกาศตัวแปรในภาษา Object Pascal ก็ไม่ยากครับ ลองมาดูกันเลยครับ

รูปแบบคือ

var

  Var_Name: Var_Type;

ลองดูตัวอย่างกันครับ

     จากในรูปนะครับ เมื่อเราจะประกาศตัวแปร เราจะต้องประกาศคำว่า var ก่อน เพื่อบอกว่า จะประกาศตัวแปรแล้วนะ

     จากบรรทัดที่ 9 นะครับ ผมกระกาศว่า Num: Integer; ซึ่งก็คือ ประกาศตัวแปรที่ชื่อว่า Num ให้เป็นชนิด Integer (จำนวนเต็ม) บรรทัดที่ 10 คือ ประกาศตัวแปร 2 ตัว ชื่อว่า Str1 กับ Str2 เป็นชนิด string (ข้อความ)

     ส่วนบรรทัดที่ 11 จะเห็นว่า ผมประกาศตัวแปรชื่อว่า Sum เป็น จำนวนจริง แล้วกำหนดค่าเริ่มต้นให้กับตัวแปรเป็น 0

    เมื่อประกาศตัวแปร ก่อนการใช้ตัวแปร เราจะต้องกำหนดค่าให้กับตัวแปรก่อนเสมอ

    เพราะว่า เมื่อมีการประกาศตัวแปร จะมีการจองหน่วยความจำขึ้นมา ซึ่งหน่วยความจำนั้นอาจจะมีข้อมูลเก่าอยู่ที่เป็นค่าอะไรก็ไม่รู้

    แล้วมันมีชนิดของตัวแปร (Variable Type) อะไรบ้างหล่ะ

    ถ้าจะแบ่งออกเป็นกลุ่มใหญ่ ๆ จะแบ่งได้เป็น จำนวนเต็ม, จำนวนจริง, อักขระ (ตัวอักษร 1 ตัว), สายอักขระ (ข้อความ / ตัวอักษรหลายตัว), ค่าทางตรรกศาสตร์ (จริงกับเท็จ)

     แล้วแต่ละกลุ่มยังมีการแบ่งย่อยออกไปอีกตามขนาดของหน่วยความจำที่ใช้

   ตัวอย่างเช่น

     Integer ใช้หน่วยความจำ 4 byte เก็บตัวเลขได้ตั้งแต่ -2,147,483,648 จนถึง 2147483647 หรือก็คือ 2^31 ถึง 2^31-1 นั้นเอง ที่ต้อง -1 เพราะว่ารวมเลข 0 เข้าไปในค่าบวกด้วย

     แต่ถ้าไม่ต้องการจำนวนที่ติดลบหล่ะ เช่นต้องการเก็บจำนวนนักเรียน มันไม่มีทางติดลบแน่ ๆ มันก็มีตัวแปรอีกแบบครับ ก็คือตัวแปรแบบ unsigned หรือก็คือ ตัวแปรที่ไม่คิดเครื่องหมาย

     ใน Object Pascal เรียกตัวแปร Integer ที่ไม่คิดเครื่องหมายว่า Cardinal ใช้ 4 byte เหมือนกันครับ เก็บข้อมูลได้ตั้งแต่ 0 ถึง 2^32-1 หรือก็คือ 0 ถึง 4,294,967,295 นั้นเอง

เอาหล่ะครับ ลองมาดูชนิดตัวแปรแบบต่าง ๆ กันครับ

ในรูปเป็นตัวอย่างคร่าว ๆ นะครับ

     ต่อไปคือ กฎการตั้งชื่อตัวแปรครับ เท่าที่ผมจำได้

          เอ๊ะ เดี๋ยวนะ นี่แสดงว่ามั่วเองหมดเลยหล่ะสิ

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

    กฎ ก็ไม่มีอะไรมากครับ ผมขอเขียนเป็นข้อ ๆ ตามนี้เลยครับ

        1) ตัวอักษรตัวแรกต้องเป็นภาษาอังกฤษตัวพิมพ์เล็ก พิมพ์ใหญ่ หรือ underscore ( _ ) เท่านั้น ห้ามขึ้นต้นด้วยตัวเลข

        2) ตัวอักษรอื่น ๆ ที่ไม่ใช่ตัวแรก จะเป็นภาษาอังกฤษพิมพ์เล็ก พิมพ์ใหญ่ underscore หรือ ตัวเลข เท่านั้น ห้ามใช้อักขระพิเศษ เช่น / \ | & ^ % $ # @ ! + - = * ฯลฯ

        3) ชื่อตัวแปรต้องห้ามซ้ำกับคำสงวนในภาษา Object Pascal เช่น program begin end var for if else then do while repeat until คำสงวนก็คือคำที่พิมพ์แล้วมันจะเด่นกว่าตัวอื่นครับ ดูไม่ยาก ;)

        จริง ๆ ก็น่าจะมีแค่นี้นะครับ แต่เหมือน Delphi เวอร์ชันใหม่ ๆ จะรองรับภาษาอื่น ๆ ที่ไม่ใช่ภาษาอังกฤษด้วย เช่นประกาศชื่อตัวแปรว่า var ตัวนับ: Integer; สามารถใช้ได้ครับ

ต่อไปมาดูการกำหนดค่าให้กับตัวแปรกันครับ

     เราสามารถกำหนดค่าให้กับตัวแปรตอนประกาศได้ครับ แต่ต้องเป็นการประกาศ 1 ตัวเท่านั้น เช่น

จากภาพจะเห็นว่า เราประกาศตัวแปร A เป็น Integer แล้วกำหนดค่า เป็น 10 แบบนี้ได้ครับ แต่บรรทัดที่เขียนว่า C, D: Integer = 9; แบบนี้ไม่ได้นะครับ ต้องกำหนดค่าให้กับตัวแปรเพียงตัวเดียวเท่านั้น

เครื่องหมายกำหนดค่า ( := )

     เครื่องหมายนี้คือการเอาค่าขวามือ ไปกำหนดให้กับตัวแปรทางซ้ายมือ เช่น

   จากรูปนะครับ จะเห็นว่า เราให้ A เป็น 10 ให้ B เป็น A + 20 ก็คือ 10 + 20 = 30 นั้นเอง แล้วก็ให้ C เป็น B + A = 30 + 10 = 40

แล้วถ้าต้องการให้ผู้ใช้กำหนดค่าลงไปหล่ะ จะทำยังไง

    มันก็คือการรับค่ายังไงหล่ะครับ

        เราได้ลองใช้คำสั่งรับค่ากันมาบ้างแล้ว จำได้ไหมเอ่ย... คำสั่งนั้นคือ Readln ไงครับ ที่เขียนก่อนจบการทำงานของโปรแกรม คราวนี้เราลองมาใช้เจ้า Readln รับค่าดูดีกว่าครับ

    ในภาพคือตัวอย่างโปรแกรมคำนวณพื้นที่วงกลม โดยการรับค่ารัศมี แล้วคำนวณจากสูตร พาย อาร์ กำลังสอง นั้นเอง

    แต่เมื่อรันแล้วใส่ตัวเลขลงไป คำตอบมันออกมาแปลก ๆ

    อ่าว ทำไมมันออกมาเป็น 1.32665000000000E+0002 หล่ะ มันคืออะไร ?

        มันก็คือ 1.32665 * 10^2 นี่เองครับ อย่าตกใจ

    แล้วจะให้มันแสดงผลแบบที่อ่านง่าย ๆ จะทำยังไงหล่ะ ?

        ต้องกำหนดค่าจำนวนทศนิยมให้มันครับ วิธีก็แสนง่าย

    เปลี่ยนจากแสดง A ไปเป็น A:0:2

    แล้วมันคืออะไรหล่ะ ?

    มันจะมีค่า 2 ตัวครับ จากตัวอย่าง ตัวแรกคือเลข 0 หมายถึง ให้กำหนดช่องว่างเพื่มให้พอดี 0 ช่อง ตรงนี้ผมคิดว่าอย่าพึ่งไปสนใจมันเลยครับ เรามาดูตัวหลังดีกว่า เลข 2 ข้างหลังหมายถึง ให้แสดงทศนิยม 2 ตำแหน่งนั้งเอง ลองรันดูใหม่ครับ เราจะได้คำตอบออกมาเป็น 132.66

ถึงตรงนี้แล้วผมคิดว่า ผู้อ่านคงจะงงกันไม่น้อย ขนาดผมเขียนเองยังงงเองเลยครับ ;)

แต่ยังไงผมก็จะฝากการบ้านไว้นะครับ อย่าลืมทำกันด้วยหล่ะ

3) จงเขียนโปรแกรมรับค่ารัศมี แล้วคำนวนหาเส้นรอบวงของวงกลม ให้ใช้สูตร เส้นรอบวง = 2 * พาย * r

4) จงเขียนโปรแกรมรับค่าชื่อผู้ใช้ แล้วแสดงข้อความว่า Hello, ชื่อที่รับเข้ามา.

   เช่น พิมพ์ชื่อไปว่า Acoshift

   ให้แสดงผลออกมาเป็น Hello, Acoshift.

   ( มี . ข้างหลังด้วยนะครับ เพื่อเพิ่มความยาก )

บทนี้อาจจะยากสักหน่อย แต่ขอให้พยายามลองเขียนดูครับ เขียนมั่ว ๆ ดูได้ครับ คอมไม่พังหรอก ^-^

ถ้ามีข้อสงสัยอะไรยังไงก็ส่งเมลมาถามผมได้นะครับที่ acoshift(at)gmail.com ผมจะรีบตอบกลับทันที่ที่เห็นเมลนะครับ

ไว้เจอกันบทความหน้าครับ

Object Pascal - Hello World

สวัสดีเพื่อน ๆ พี่ ๆ น้อง ๆ ทุกท่านครับ กลับมาเจอกันอีกแล้ว
ตามที่ผมสัญญาไว้เมื่อวาน วันนี้ผมจะมานำเสนอวิธีเขียนโปรแกรมบน Console ครับ :)
แต่ เอ... แล้วไอ Console ที่ว่ามันคืออะไรหล่ะ ?
ถ้าจะพูดกันแบบง่าย ๆ เลย มันก็คือโปรแกรมที่แสดงผลใน cmd ยังไงหล่ะครับ
แล้วไอ cmd ที่ว่ามันคืออะไรหล่ะ ?
มันก็คือหน้าจอดำ ๆ ที่เอาไว้พิมพ์คำสั่งไงครับ ไม่เชื่อลองกด Start->Run แล้วพิมพ์ cmd แล้วกด Enter ดูสิ

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

     เอาละครับ บ่นมาซะยาว ลองมาเขียนโปรแกรมง่าย ๆ ที่เป็นพื้นฐานของการเขียนโปรแกรมทุกภาษากันก่อนเลย
นั้นก็คือ !!! โปรแกรม Hello World !!!
โปรแกรม Hello World คือโปรแกรมที่แสดงข้อความว่า Hello World ...
     แค่นี้แหละครับ เบสิกสุด ๆ แล้ว เอาละครับ มาลุยกันเลย !!

ในที่นี้ผมใช้โปรแกรม Delphi XE นะครับ จะได้เวอร์ชันอื่นก็ได้ครับ เหมือนกัน

     หลังจากเปิดโปรแกรมมา ให้สร้าง Project ใหม่ กดที่ File->New->Other...
แล้วเลือก Console Application ตามภาพเลยครับ

พอกด OK แล้วจะได้หน้าจอ (ไม่)โล่ง ๆ มีตัวหนังสือเขียนอยู่

มันคืออะไร ? อย่าพึ่งไปสนใจครับ ให้ลบส่วนที่อยู่ระหว่าง begin ถึง end. ออก แบบนี้ครับ

คำสั่งแรกที่ต้องรู้คือคำสั่ง Write กับ Writeln
     ... แล้วมันต่างกันยังไงหล่ะ
          คำสั่ง Write ก็เอาไว้แสดงข้อความยังไงหล่ะครับ ส่วน Writeln มาจากคำว่า Write Line ซึ่งก็คือ หลังจากที่แสดงข้อความแล้ว ให้ขึ้นบรรทัดใหม่นั้นเอง
     ข้อความในภาษา Object Pascal จะใช้ ' ' ครอบข้อความ เช่น 'Hello World' ฯลฯ
     ตัวอย่างการแสดงข้อความ Writeln('Hello World');
     เราสามารถขึ้นบรรทัดใหม่โดยการพิมพ์ว่า Writeln; เฉย ๆ ก็ได้ครับ

* ในภาษา Object Pascal จะเริ่มทำงานตามคำสั่งที่อยู่ระหว่าง begin ถึง end. ก่อนเสมอ ซึ่งก็คือ ส่วนหลักของโปรแกรม หรือเรียกอีกอย่างกว่า Main function นั้นเอง

เอาหล่ะครับ มาลองกันเลย !!!

จะเห็นว่าจะมีคำสั่ง Readln; อยู่บรรทัดสุดท้าย เอาไว้หยุดหน้าจอโปรแกรมตอนรัน
เพื่อให้โปรแกรมรอเรากด Enter ก่อนค่อยจบโปรแกรม ไม่เชื่อลองลบคำสั่ง Readln; ดูสิ มองไม่ทันเลยใช่ไหมหล่ะ ;)

ลองรันกันดูนะครับ

เป็นไงครับ โปรแกรมแรกของพวกเราโปรแกรม Hello World

แต่ก่อนจะจากกันไปผมก็ขอฝากการบ้านไว้สักเล็กน้อย ให้ไปฝึกทำกันดูครับ
เพราะการเขียนโปรแกรมต้องเขียนบ่อย ๆ จะทำให้เก่งขึ้นไงครับ :)

การบ้าน

1) จงเขียนโปรแกรมแสดงชื่อของตัวเองออกมา

2) จงเขียนโปรแกรมให้แสดงผลดังนี้ (ให้เว้นบรรทัดหลังจบ 1 คำ)
Apple
Banana
Carrot

การบ้าน 2 ข้อคงไม่เยอะเกินไปนะครับ ^-^
เดียวคราวหน้าผมจะมาเฉลยการบ้านให้ครับ
แต่ถ้าใครมีข้อสงสัย หรืออยากให้ผมตรวจการบ้านให้ก็ส่ง Source Code มาได้ครับ ที่เมลของผม
คือ acoshift(at)gmail.com อย่างลืมเปลี่ยน (at) เป็น @ ด้วยนะครับ ^w^

ไว้เจอกันใหม่ครับผม