ผมเลยลองเขียนปลั๊กอินไว้ “กรองข้อความ” โดยใช้เงื่อนไขง่ายๆ ว่า

“ใน 1 ชม. ที่ผ่านมา ถ้าเธอยังไม่เคยส่งข้อความหาฉันเลย แล้วจู่ๆ ส่ง URL มาให้ ฉันจะขอโยนข้อความนั้นทิ้งซะ (มันต้องเป็น spam แน่เลย!)”

Anti MSN Spam

ลองเขียนไว้ 2 version ครับ เขียนด้วย Python กับ C

1. anti-msn-spam.py

ลองเขียนตัวต้นแบบด้วย Python ครับ ใช้ dbus คุยกับ pidgin เพื่อเช็คว่ามีข้อความส่งมารึเปล่า (หาอ่านเพิ่มเติมได้จาก wiki นี้)

คิดว่าใช้ได้บน linux เท่านั้น เพราะมันใช้ dbus น่ะครับ
วิธีใช้: เปิด pidgin แล้วเรียกคำสั่งต่อไปนี้

python anti-msn-spam.py

พอโปรแกรมจับ SPAM ได้มันก็จะบ่นออกมาทาง command line ว่า “ข้อความ…..โดน block ทิ้ง เพราะสงสัยว่าเป็น SPAM” (โค้ด version python น่าจะทำความเข้าใจได้ง่ายสุดครับ ลองแกะเล่นดูได้นะ )

2. anti_msn_spam_c.zip

version C นี้ไปเอาโค้ด message_filter.c ของคุณ Huy Phan มาโมดิฟาย… ของเดิมเค้าเขียนโปรแกรม “block ข้อความที่มีแต่ smiley”

วิธีใช้ ดาวน์โหลดไฟล์ zip ไปจะมี anti_msn_spam.c กับ anti_msn_spam.so
- สำหรับคนใช้ x86 กับ pidgin 2.5.5 (บน linux):
1. สามารถเอาไฟล์ anti_msn_spam.so ไปใส่ไว้ที่ /home/USERNAME/.purple/plugins/anti_msn_spam.so ได้เลย
2. เปิด pidgin ขึ้นมาใหม่ เลือกเมนู Tools->Plugins
3. ติ๊กถูกหน้า “Anti MSN Spam 1.0″ เป็นอันเสร็จ

- สำหรับคนอื่นๆ (เช่น คนใช้ pidgin บน windows)
น่าจะต้อง compile เองครับ ทำตามคู่มือนี้เลย เหมือนจะต้องใช้ MinGW มา compile ครับ ถ้าใครพยายามแล้วติดปัญหา ก็แปะคอมเม้นท์มาได้นะครับ

โม้ไว้นิ๊สนึง… ตั้งแต่ลองใช้มา 3-4 สัปดาห์ ก็ยังไม่เจอ SPAM กวนใจอีกเลย ไม่รู้ว่าเค้าเลิกส่ง SPAM กันแล้ว หรือว่า Plugin เราดีจริง หะๆ

Q: eXceed Camp หรือค่ายทะลุฟ้าคืออะไร?
A: ค่าย 7 วันสำหรับนิสิตที่กำลังจะขึ้นปี 2 จากวิศวคอมฯ บางเขน+กำแพงแสน+วิศวซอฟต์แวร์ ประมาณ 120 คนมานั่งเรียน….จัดกลุ่มประมาณ 7-8 คนแล้วให้ลองเขียนโปรแกรมด้วยกันภายในเวลา 2 คืน 1 วัน

จะเห็นว่าเดือนที่แล้ว ผมไม่ได้เขียนบล็อกเลย เพราะนั่งคุย นั่งเตรียมค่ายกับเพื่อนๆ ปี 3 แล้วก็เขียน eXceed wiki ที่เป็นคลังความรู้ให้น้องๆ ในค่าย น่าดีใจที่ตอนนี้ wiki ของค่ายมีเนื้อหามากกว่า 500 หน้าแล้วครับ (เขียนกันมาเป็นปีที่ 2 แล้ว… ขอบคุณพี่ๆ CPE20&SKE04 ที่เริ่มต้นเขียนเนื้อหาใน wiki ไว้เยอะมาก)

กิจกรรมในค่าย

กิจกรรมก็ไม่มีอะไรมากครับ กิน เรียน นอน ตีดอท(เฉพาะบางคน อิๆ) เนื้อหาที่พยายามยัดเยียดให้น้องๆ ในค่ายปีนี้คือ Windows Form, SVN และ OOP สาเหตุที่ต้องสอน Windows Form เพราะตอนปี 1 น้องเรียน C# มาครับ ถ้าจะทำ App. ก็หนีไม่พ้นต้องใช้ Windows Form … แล้วแถม SVN ให้น้องๆ เพราะคาดว่าน่าจะช่วยให้น้องแลกโค้ดกันได้สะดวกขึ้น (ปีที่แล้วใช้ thumb drive เสียบเข้าเสียบออกติดไวรัสกันกระจาย) และสุดท้ายคือ OOP ที่หวังว่าน้องจะได้แบ่งโปรแกรมออกเป็นคลาสหลายๆ คลาส แล้วกระจายกันเขียนคนละคลาส (idea OOP ตกทอดมาจากรุ่นพี่ครับ)

นอกจากเนื้อหาที่บังคับยัดเยียดแล้ว… เรายังมีเนื้อหาที่น้องๆ เลือกเรียนตามความสนใจอีก 7 เรื่อง… พอเรียนกันเสร็จแล้วก็ได้เวลาปล่อยน้องๆ ทำโปรเจคครับ

==ชะแว๊บ… เวลาผ่านไป 2 คืน 1 วัน… ไปดูผลงานน้องๆ กันเลยดีกว่า==

ผลงานน้องๆ

ภาพซ้ายมือนี้ เป็นตอนที่ผมไปลองเล่นเกมส์ที่น้องเขียนขึ้น ชื่อว่า TYPING SHOOTER ครับ สร้างด้วย XNA Studio (พี่โบะเจ๋งมาก สอนน้องแค่ 2 ชม.ครึ่ง น้องก็เขียนเกมส์ได้แล้ว) เป็นเกมส์ฝึกพิมพ์ดีด ต้องพิมพ์คำศัพท์ให้ทันก่อนที่ซอมบี้จะเดินมาถึงตัวเรา… ปรากฏว่าเล่นไปเล่นมา น้องแก้โปรแกรมให้ผมเจอกับ level พิเศษ…ซอมบี้เดินเร็วอย่างโหดครับ พิมพ์ไม่ทัน Game Over ตามภาพ (น้องมันก็ยิ้มสะใจอยู่ด้านหลังนะนั่น)

จริงๆ ยังมีโปรเจคเจ๋งๆ อีกตั้ง 16 โปรเจคครับ ลองคลิกเข้าไปดู+ดาวน์โหลดมาลองเล่นกันได้ (คาดว่าน้องๆ จะเขียน wiki +อัพโปรแกรมกันเสร็จภายในวันที่ 7 มิ.ย. นี้ครับ)

x = 01001111000000001010101011110000

ให้กลายเป็น

y = 00001111010101010000000011110010

(คือ เขียน bit ใน x จากหลังมาหน้านั่นแหละครับ)

ตอนแรกพยายามนึกวิธีเอง ได้วิธีถึกๆ แบบต้องวนลูป 32 ครั้งค่อยๆ ดึง bit ตัวท้ายออกมาใส่อีกตัวแปรนึงไปเรื่อยๆ (32 ครั้ง = 32 bit) พอไปค้นในเน็ตเจอ Bit Twiddling Hacks ซึ่งแข็งแกร่งมาก (ทำเสร็จในไม่กี่ operation) ขอเอาโค้ดมาแปะตามนี้

unsigned int v; // 32 bit word to reverse bit order
// swap odd and even bits
v = ((v >> 1) & 0x55555555) | ((v & 0x55555555) << 1);
// swap consecutive pairs
v = ((v >> 2) & 0x33333333) | ((v & 0x33333333) << 2);
// swap nibbles ... 
v = ((v >> 4) & 0x0F0F0F0F) | ((v & 0x0F0F0F0F) << 4);
// swap bytes
v = ((v >> 8) & 0x00FF00FF) | ((v & 0x00FF00FF) << 8);
// swap 2-byte long pairs
v = ( v >> 16             ) | ( v               << 16);

ตอนแรกดูโค้ดแล้วก็งงๆ มันทำงานได้ยังไงหว่า ขอยกตัวอย่างการทำงานกับเลข 8 bit โดยใช้สัญลักษณ์ ABCDEFGH แทน 0, 1 และขอรันโค้ดจากบรรทัดล่างขึ้นบนซึ่งให้ผลลัพธ์เหมือนกัน (มันจะเข้าใจง่ายกว่าจริงๆ นะ)

x = ABCDEFGH
x = EFGHABCD	// สลับ nibble (4 bits) ที่ติดกัน
x = GHEFCDAB	// สลับ คู่บิต (2 bits) ที่ติดกัน
x = HGFEDCBA	// สลับ 'บิตที่อยู่ตำแหน่งคี่' กับ 'บิตที่อยู่ตำแหน่งคู่'

ถ้ายังไม่เข้าใจบ่นได้เลยครับ

เกมส์ Mysweeper เป็นเกมส์ที่ปั่นอย่างบ้าระห่ำ ใน 1 ชม. (ไม่ยอมอ่านหนังสือสอบ) เพื่อที่จะเอาไปบอกน้องๆ ปีหนึ่งว่า นี่คือเกมส์เล็กๆ ที่สร้างด้วย Visual C# ได้นะครับ (ผมกำลังจะสอนน้องๆ เรื่อง Windows Form Application ครับ)

แต่เขียนเสร็จเก็บไว้มันก็เท่านั้น เอาโค้ดมาแจกละกันครับ เผื่อใครจะลองเอาไปศึกษาดู อ่านรู้เรื่องไม่รู้เรื่องก็ทิ้ง comment ไว้ได้นะครับ สาเหตุที่เอาโค้ดมาแจกเพราะตอนสมัยหัดเขียน Visual Basic ครั้งแรกๆ ก็มาดาวน์โหลดโค้ดชาวบ้านไปนั่งดู (เยอะมากๆ) โค้ดอันนึงที่ประทับใจมากคือโค้ดของ Tamagotchi Simulator ของคุณ Tooh (พีรภัทร์ สว่างเพียร) แล้วเอามานั่งแกะๆ แล้วได้รับความรู้มากมาย

ผมเลยหวังว่าโปรแกรมเล็กๆ ที่ผมเขียนนี้อาจจะเป็นแหล่งเรียนรู้ให้กับคนอื่นได้ไม่มากก็น้อยฮับ

ดาวน์โหลดโค้ดเกมส์ mysweeper (ขนาด 46KB สร้างด้วย Visual Studio 2008)

#include <stdio.h>
int main(){
      float a = 10.1F;
      printf("%d", a);
      return 0;
}

Result:
1073741824

เราก็เกิดอาการสงสัย และเดาว่า มันคงอ่านค่า binary ทั้งดุ้นของ float เป็นแบบ int และพิมพ์ออกมา เราก็เลยลองฟังก์ชัน printbin เพื่อพิมพ์ binary representation ของตัวแปรใดๆ (ดูว่าใน ram มันเก็บเป็นเลขฐานสองยังไง) ได้โค้ดอย่างนี้…

#include <stdio.h>
void printbin(char *c, int bytes)
{  // author: nattster.siamdev.net
  int i, j;
  char a;
  for(j=bytes-1; j>=0; j--)
  {
    a = c[j];
    for(i=sizeof(char)*8-1; i>=0; i--)
    {
      printf("%d", (((a & 1<<i) > 0) ? 1 : 0));
    }
  }
  printf("\n");
}
int main(){
  float a = 10.1F;
  printf("%d\n", a);
  printbin((char*)&a, sizeof(float));
  return 0;
}

Result:
1073741824
01000001001000011001100110011010

เลขฐานสองยาวๆ อันล่างเป็น binary representation ของ 10.1F ตามมาตรฐาน IEEE754-1985 พอลองแปลงเลขฐานสองก้อนนี้กลับไปเป็นฐานสิบมันได้ = 1092721050 ซึ่งคลาดเคลื่อนจากผลที่ได้จาก printf(“%d”, a); นิดหน่อย สรุปว่าเราก็ยังไม่รู้อยู่ดีว่า printf มันเอาอะไรออกมาพิมพ์

แต่! ได้ฟังก์ชัน printbin เอาไว้ใช้เป็นของเล่นในอนาคต เผื่ออยากดูว่าตัวแปรอื่นๆ มันเก็บข้อมูลใน memory ยังไง
ปล. คิดว่าฟังก์ชันทำงานถูกต้องแล้วนะ เพราะลองใส่เลข 0.15625 แล้วมันได้เลขฐานสองถูกต้องตามรูปนี้อ่ะ

IEEE754 representation of 0.15625 (Ref: wikipedia.org)

malloc(ขนาดหน่วยความจำเป็นไบต์);

calloc(หน่วยความจำกี่ช่อง, ช่องละกี่ไบต์)

เกิดอาการสงสัยอย่างแรง ว่าไหนๆ มันก็ทำงานได้เหมือนๆ กันแล้ว ทำไมต้องมีตั้งสองฟังก์ชัน พอไปเปิด man ดูก็เจอข้อแตกต่างว่า malloc จะจองพื้นที่ให้ แล้วก็จบแค่นั้น แต่ calloc จะจองพื้นที่ให้และกำหนดค่าเริ่มต้นเป็น 0 ด้วย

ลองดูโค้ดและผลลัพธ์ของโปรแกรม น่าจะช่วยให้เข้าใจง่ายขึ้นครับ

#include<stdio.h>
#include<stdlib.h>
int main() {
	int *a = (int*) malloc(sizeof(int)*10);
	int *b = (int*) calloc(10, sizeof(int));
	int i;
	for(i=0;i<10;i++)
	{
		printf("a = %d, b = %d\n", a[i], b[i]);
	}
	return 0;
}

ผลลัพธ์:
a = 3221200, b = 0
a = 3215048, b = 0
a = 1095651909, b = 0
a = 1346192717, b = 0
a = 1095910725, b = 0
a = 1196314448, b = 0
a = 1866661971, b = 0
a = 1701860205, b = 0
a = 977485155, b = 0
a = 1852397404, b = 0

ดังนั้นควรเลือกฟังก์ชันให้เหมาะสมกับการใช้งาน เพราะมี overhead ไม่เท่ากันนะครับ

$ man qsort

เพื่อดูรายละเอียดของฟังก์ชัน qsort ได้ผลลัพธ์ตามนี้ (ทีนี้จะได้รู้และว่าต้อง include file ไหนและฟังก์ชันรับอาร์กิวเมนท์อะไรบ้าง)

QSORT(3)                   Linux Programmer`s Manual                  QSORT(3)
 
NAME
       qsort - sorts an array
 
SYNOPSIS
       #include <stdlib.h>
 
       void qsort(void *base, size_t nmemb, size_t size,
                  int(*compar)(const void *, const void *));
 
DESCRIPTION
       The  qsort()  function sorts an array with nmemb elements of size size.
       The base argument points to the start of the array.

แต่! ก่อนที่จะทำแบบนี้ได้ต้องติดตั้งแพคเกจ manpages-dev ก่อนครับ สำหรับผู้ใช้ ubuntu/debian (ใช้ Synaptic ติดตั้ง หรือ sudo apt-get install manpages-dev ก็ได้ครับ) สำหรับคนใช้ดิสโทรอื่นต้องลองค้น google ดูครับ

ถ้าลอง man printf ดูจะเจอ manual ของคำสั่ง printf ของ linux แทนที่จะเป็น reference ของฟังก์ชัน printf ของภาษา C แทน

วิธีเปิด manual ของ printf (ฟังก์ชันภาษา C) ให้เรียกคำสั่ง

$ man 3 printf

แทน ซึ่งหมายความว่า เปิดดูคำสั่ง printf ใน section ที่ 3 ของ manual ครับ (manual มีทั้งหมด 7-8 section… เขาแบ่ง section ตามหัวข้อครับ ดูรายละเอียดเพิ่มเติมที่นี่)

A = [1, 2, 3, 6, 7, 9, 12]
for x in A:
    if x % 3 == 0:
        A.remove(x)

List<int> A = new List<int>(new int[]{1, 2, 3, 6, 7, 9, 12});
foreach(int x in A)
{
    if(x % 3 == 0)
        A.Remove(x);
}

ในบล็อกนี้ขออนุญาตยกตัวอย่างแค่ 2 ภาษา คือ Python และ C# นะครับ สำหรับฝั่ง C# จะเจอกับ “Unhandled Exception: System.InvalidOperationException: Collection was modified;” (เขาบอกว่า เกิดการกระทำที่ไม่ถูกต้อง เนื่องจาก list ถูกแก้ไขระหว่างวนลูป) ส่วนคนใช้ Python จะไม่เจอปัญหาอะไรเวลารันครับ แต่พอลองพิมพ์ A ออกมาดูจะพบว่า

A = [1, 2, 6, 7, 12]

แงว… ทำไม 6 กับ 12 ยังโผล่ออกมา? ในเมื่อมันน่าจะ mod 3 ลงตัว… ในบล็อกนี้เราจะมาดูวิธีแก้ปัญหาที่มักจะเจอบ่อยๆ ปัญหานี้กันครับ

ปัญหาที่เจอใน Python คือ เลขจำนวนเต็มที่หารสามลงตัว ไม่โดนลบออกไปทุกตัว สาเหตุคือ ในการวนลูปบน list python จะมีตัวชี้ index ของ list สร้างขึ้นมา และในการวนลูปแต่ละรอบ index จะต้องโดนขยับไป 1 เสมอ ดังนั้นเมื่อตัวเลขโดนลบไป ตัวเลขอื่นๆ ที่อยู่ต่อท้ายจะเลื่อนมาแทนที่ตัวที่หายไป แล้วตัวที่เลื่อนมาแทนที่เนี่ยแหละครับ จะโดนข้ามไป (ไม่โดนตรวจสอบ)…. ถ้างง ลองดูตัวอย่างต่อไปนี้ครับ

A = 1 2 3 6 7 9 12

A = 1 2 3 6 7 9 12

A = 1 2 3 6 7 9 12

A = 1 2 6 7 9 12

จะเห็นว่ามีกรณีแบบนี้เกิดขึ้นได้ใน python และคนเขียนโปรแกรมก็ไม่รู้ว่าเกิดปัญหาขึ้นเลย (นอกจากมาดูผลลัพธ์) ดังนั้นใน C# เขาจึงห้ามวนลูปแบบ foreach แล้วแก้ไขข้อมูลใน list (เกิด InvalidOperationException นั่นเอง) ในเมื่อ foreach ใช้ไม่ได้ ขอลักไก่ใช้ for ธรรมดาแทนได้มั้ย? คำตอบคือ ไม่ได้ครับ ถ้าลองเขียนแล้วจะเจอปัญหาเหมือนกับที่เจอใน Python ครับ

แล้วเราจะแก้ปัญหานี้ยังไงดีหละ?

แบ่งได้เป็น 3 วิธีที่เจอบ่อยๆ ครับ

1. สร้าง List อีกอันมาเก็บเฉพาะผลลัพธ์ที่ต้องการ

วิธีนี้ง่ายๆ ตรงๆ เลยครับ ในเมื่อมี list A แล้วเราต้องการเฉพาะเลขที่หารสามไม่ลงตัว แล้วใช้ list ใหม่เป็นคำตอบ เราก็เขียนโปรแกรมประมาณนี้ได้เลยครับ

B = []
for x in A:
    if x % 3 <> 0:
        B.append(x)

List B = new List<int>();
foreach(int x in A)
{
    if (x % 3 != 0)
	B.Add(x);
}

อ่าวๆๆแบบนี้ โปรแกรมก็ต้อง copy ตัวเลขทุกตัว ไปใส่ list B แทน ซึ่งมันต้องทำงานช้าแน่ๆ เลย สมมติว่าเราต้องการลบเลขแค่ตัวเดียวใน list A แต่ดันต้อง copy ตัวที่ต้องการเก็บไว้ไปใส่ใน list B ซึ่งเสียเวลาทำงานตั้งนาน (แต่! จะเร็วกว่าวิธีอื่นๆ ถ้ามีตัวเลขที่ต้องโดนลบเยอะๆ ครับ)

งั้นไปดูวิธีที่สองดีกว่า

2. วนลูปในตัวก๊อบปี้ของ List

วิธีนี้คือ สร้างตัวก๊อบปี้ของ List (เอาตัวเลขทุกตัว) มาเลยครับ เอามาใช้วนลูป แล้วเวลาลบข้อมูลก็ลบใน list ของจริง ผลลัพธ์ก็จะเก็บอยู่ใน list A ตามปกติ

for x in A[:]:
    if x % 3 == 0:
        A.remove(x)

foreach(int x in new List<int>(A))
{
    if (x % 3 == 0)
	A.Remove(x);
}

หลายๆ คนคงจะเห็นว่า มันก็คล้ายๆ กับวิธีที่ 1 แหละน๊า… แค่สร้างตัวก๊อบปี้ไว้วนลูป ต้องเสียเวลาสร้างตัวก๊อบปี้เหมือนกันไม่ใช่เรอะ?… ฮึ่ม! งั้นลองไปดูวิธีที่ 3 กันครับ

3. วนลูปถอยหลัง

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

for i in reversed(range(len(A)))
    if x % 3 == 0:
        del A[i]

for(int i = A.Count - 1; i >= 0; i--)
{
    if (A[i] % 3 == 0)
	A.RemoveAt(i);
}

จากตัวอย่างโค้ดจะเห็นว่าเราใช้ del A[i] และ A.RemoveAt(i) เพื่อลบตัวเลข ที่ตำแหน่งใดๆ แทนที่จะใช้ Remove ที่ใช้ลบค่าใดๆ จะเห็นว่าวิธีที่สามนั้นน่าจะทำงานได้เร็วกว่าวิธีที่ 1 และ 2 เพราะไม่ต้องสร้างตัวก๊อบปี้ของ list นั่นเอง

สรุป

จากบล็อกนี้เราได้เรียนรู้วิธีแก้ปัญหาที่เกิดขึ้นจากการวนลูป แล้วลบ “ของ” ออกจาก list โดยแบ่งออกเป็น 3 วิธีที่เจอบ่อยๆ ซึ่งแต่ละวิธีก็มีประสิทธิภาพแตกต่างกันไปขึ้นกับการนำไปใช้ และความแตกต่างของแต่ละภาษา ใครชอบใครถนัดวิธีไหนก็เลือกไปใช้ตามสะดวก

ส่วนตั๊วส่วนตัวจากคนเขียน

ปล. สาเหตุที่มานั่งเขียน blog นี้เพราะผมเขียนโปรแกรมไปแล้วก็เจอ bug… คือ “ของ” ใน list มันโดนลบออกไปไม่หมด (แต่ python ไม่ยอมเตือนเหมือน C# หง่ะ!!) ก็เลยนั่งหา bug จนมาเจอ… เอาเป็นว่า เพื่อนๆ คนอื่นที่อ่านมาเจอบล็อกนี้แล้ว คงไม่พลาดแบบผมละกันครับ

ปล2. เพิ่งรู้ว่าใช้ reversed() แล้วโค้ดสวยกว่าเดิมเยอะเลย ปกติเวลาต้องการวนลูปจากมากไปน้อย (9 ถึง 0) ก็เขียนโค้ดน่าเกลียดๆ แบบนี้

for i in range(9, -1, -1):
    print i

พอเขียนบล็อกนี้แล้วเพิ่งรู้ว่าเขียนเป็น

for i in reversed(range(0, 9)):
    print i

สวยกว่าเยอะเลย

ปล3. ใครอยากให้เขียนบล็อก แล้วยกตัวอย่างภาษาอื่นๆ นอกจาก Python และ C# ช่วยทิ้งคอมเม็นท์ไว้ด้วยครับ

ใช้ scanf(“%s”, …); ก็อ่านได้เฉพาะบรรทัดที่ไม่มีเว้นวรรคเท่านั้น
จะใช้ gets() ก็พอช่วยได้ แต่ติดปัญหาที่ว่า พอใช้งานร่วมกับ scanf อื่นๆ แล้วเจอปัญหามากมาย

นายนิน PJ ก็ชี้ทางสว่างว่า scanf ก็สามารถอ่านข้อความได้ทั้งบรรทัดเหมือนกัน โดยใช้ modifier นิดหน่อยกับ scanf ตามตัวอย่างนี้

scanf("%[^\n]", myString);

โอ้โห..สุดยอด ทำไมมันง่ายจัง… ก่อนหน้านี้เคยเสียเวลาเขียน function อ่านค่าทีละตัวอักษร ใส่ string เอง ขอบคุณท่าน นิน PJ ครับ… อ้อ ใครอยากรู้เรื่องเกี่ยวกับ scanf เพิ่มเติมก็เรียกคำสั่งนี้เลยครับ

$ man scanf

Reference ฉบับอ่านง่าย: บล็อกพี่อิ๊กเรื่อง scanf 102

ต่อไปนี้เป็นวิธีสร้างหน้าต่าง Now loading แบบง่ายๆ โดยใช้ Threading เข้ามาช่วยนิดหน่อย ลองทำตามดูเลยก็ได้นะครับ

1. อันดับแรก ก็สร้างโปรเจคใหม่ขึ้น เป็นแบบ Windows Forms Application

2. ผมก็ออกแบบหน้าต่างหลัก ดังนี้ (เป็นโปรแกรมคำนวณลำดับเลข fibonacci ครับ)

มี button1 กับ listBox1 ครับ

3. สร้างหน้าต่างใหม่ ผมตั้งชื่อว่า ProgressForm (เป็นหน้าต่าง Now loading นั่นเองครับ)

ในหน้าต่างนี้ประกอบด้วย label 1 อันแสดงข้อความ Now Loading… และ progressBar โดยกำหนด คุณสมบัติของ progressBar ให้ Style เป็น Marquee และ MarqueeAnimationSpeed เป็น 50 (เพื่อให้ progressBar มันวิ่งไปเรื่อยๆ แบบตอนเราเปิดเครื่องคอมพิวเตอร์น่ะครับ)

4. กลับไปเขียนคำสั่งที่ฟอร์มแรกครับ

ผมเพิ่ม 1 function เอาไว้ใช้คำนวณค่าลำดับ Fibonacci ดังนี้ครับ

long fib(int n)
{
    if (n <= 2) return 1;
    return fib(n - 1) + fib(n - 2);
}

และเพิ่มคำสั่งในปุ่ม button1 ตามนี้ครับ

// เพิ่มโค้ดส่วนนี้ (อย่าลืม using System.Threading; ด้วยนะครับ)
Thread progressThread = new Thread(delegate()
{
    ProgressForm progress = new ProgressForm();
    progress.ShowDialog();
});
progressThread.Start();
 
// โค้ดที่ทำงานนานๆ
listBox1.Items.Clear();
for (int i = 1; i < 40; i++)
{
    listBox1.Items.Add(String.Format("fib({0}) = {1}", i, fib(i)));
    listBox1.SelectedIndex = listBox1.Items.Count - 1;
}
 
// เมื่อทำงานเสร็จแล้ว อย่าลืมเรียกคำสั่งนี้ (ปิดหน้าต่าง loading)
progressThread.Abort();

อ้ออย่าลืม ใส่ using System.Threading; ด้านบนของโปรแกรมด้วยนะครับ

หลักการทำงานก็คือ เมื่อเรากดปุ่ม button1 แล้ว เราจะสร้าง Thread ใหม่ขึ้นมา (progressThread) โดย Thread นี้ทำหน้าที่ แสดงหน้าต่าง ProgressForm ขึ้นมา หลังจากนั้น เราก็เขียนโค้ดตรงส่วนที่ต้องทำงานนานๆ (ในที่นี้คือโค้ดคำนวณลำดับ Fibonacci ซึ่งเขียนแบบ recursive จะได้ใช้เวลามากๆ) หลังจากที่ทำงานเสร็จแล้วเรา Abort Thread เพื่อปิดหน้าต่าง Now Loading ไป ครับ

เท่านี้เราก็สามารถสร้างหน้าต่าง Now loading แบบง่ายๆ ได้แล้วครับ จริงๆ แล้วถ้าเราจะทำหน้าต่าง Now loading ให้สมบูรณ์แบบ (เช่นแสดงสถานะเป็น percent หรือ มีปุ่ม cancel ในหน้าต่าง now loading) เราจำเป็นต้องเขียนโปรแกรมที่ซับซ้อนขึ้นกว่านี้อีกนิดหน่อยครับ (เอาเป็นว่าถ้าสนใจ ก็ทิ้ง comment ไว้นะครับ จะได้มาเขียนเพิ่มเติมครับ

อ้อ เกือบลืมไปครับ สำหรับใครที่…งงๆ ลองโหลดโค้ดโปรแกรมที่ใช้งานได้ไปดูก็ได้ครับ เขียนใน Microsoft Visual C# 2008 Express Edition ครับ

โค้ดโปรแกรม Now Loading (42kb)