การเขียนโปรแกรมในสมัยดั้งเดิมนั้น จะเป็นการเขียนคำสั่ง (instruction) ให้คอมพิวเตอร์ปฏิบัติงานต่าง ๆ เรียงกันไปตามลำดับ เช่น
รอรับค่าจากแป้นพิมพ์จำนวน 10 ค่า
นำค่าที่ได้มาบวกกัน
นำผลลัพธ์ที่ได้มาหารด้วย 10
แสดงผลลัพธ์ที่ได้ออกทางจอภาพ

จะเห็นว่าการทำงานของโปรแกรม จะเป็นการทำงานตามชุดคำสั่ง เรียงกันไปตามลำดับ ซึ่งเป็นลักษณะ ที่เรียกว่า ภาษาเชิงกระบวนงาน (procedural languages) ต่อมา เมื่อมีการพัฒนาโปรแกรม ให้มีความซับซ้อนยิ่งขึ้น มี การกระทำกระบวนงาน ดังข้างต้น หลายสิบหลายร้อยกระบวนงาน ซึ่งถ้าเขียนโปรแกรมแบบให้มี ชุดคำสั่ง เรียง กันไปเรื่อย ๆ ดังข้างต้น ก็จะทำให้โปรแกรมประกอบด้วย บรรทัดคำสั่งเรียงติดต่อกันไป จำนวนหลายร้อย หลายพัน บรรทัด ซึ่งเป็นการยากที่ นักเขียนโปรแกรม จะสามารถตรวจสอบข้อผิดพลาดได้

จึงได้มีการมีการแบ่งส่วนของโปรแกรมออกไป เป็นกลุ่มคำสั่งย่อย (subroutine) ซึ่งในภาษาซีเรียกว่า function ย่อย การแบ่งโปรแกรมไปเป็น กลุ่ม function ย่อย ๆ ซึ่งภายในจะบรรจุ ชุดคำสั่ง (instruction) ที่ทำงานเฉพาะอย่าง นี้ ทำให้โปรแกรมมีการแบ่งเป็นส่วน ๆ ทำให้ง่ายต่อการทำความ เข้าใจ และการบำรุงรักษา ได้ดีในระดับหนึ่ง การแบ่งโปรแกรมออกเป็น function ย่อยนี้ เป็นพื้นฐานประการหนึ่ง ของการ เขียนโปรแกรมเชิงโครงสร้าง (structural programming) ซึ่งเป็นแนวคิดที่ได้รับการยอมรับ ในการเขียนโปรแกรม มาเป็นเวลานานพอสมควร ในการเขียนภาษา C

อย่างไรก็ตาม เมื่อโปรแกรมมีความซับซ้อนยิ่งขึ้นไปอีก การเขียนโปรแกรมเชิงโครงสร้างนี้ ก็ไม่เพียงพอที่จะรองรับ ฟังก์ชั่นย่อยจำนวนมหาศาล และตัวแปรในการเขียนโปรแกรม จำนวนมากมายนั้นได้ จึงได้มีการพัฒนาแนวคิด เกี่ยวกับการโปรแกรมเชิงวัตถุ (Object Oriented Programming) หรือ OOP ขึ้นมา ซึ่งในแนวคิดนี้ จะได้มีการ รวบเอาตัวแปรและฟังก์ชั่นย่อย ที่ทำงานในกลุ่มเดียวกัน เข้ามาไว้ด้วยกัน และมีการป้องกัน ไม่ให้มีการเข้าถึงตัวแปร และฟังก์ชั่นย่อยเหล่านี้ได้โดยไม่ได้ตั้งใจ ซึ่งจะช่วยให้โปรแกรมที่เขียนขึ้นนี้ มีเสถียรภาพมากขึ้น นอกจากนั้นยังมีการ เพิ่มเติมคุณสมบัติอื่น ๆ เข้าไปอีก เช่นความสามารถ ในการสืบทอดคุณลักษณะนี้ ไปยังโปรแกรมอื่น ๆ ที่จะเขียนขึ้น ในอนาคตได้อีก ทำให้เรียกภาษา C ที่ได้พัฒนาขึ้นนี้ว่า C++ (C plus plus)

ชนิดของตัวแปรที่ใช้ในภาษา C

รูปแบบฟังก์ชั่นในภาษา C

	ชนิดของค่าที่ส่งกลับ ชื่อฟังก์ชั่น(ค่าที่ส่งให้ฟังก์ชั่นนี้ค่าที่ 1,ค่าที่ส่งให้ฟังก์ชั่นนี้ค่าที่ 2,...)
	{
		ชุดคำสั่งในการทำงาน;
		ชุดคำสั่งในการทำงาน;
		return ค่าที่ส่งกลับ;
	 }
เช่น	
	int sumparameter(int x,int y)
	{
		int z;
		z = x+y;
		return z;
	 }
จะสังเกตเห็นว่าทุก ๆ คำสั่งจะต้องตามด้วยเครื่องหมาย semi-colon ;

เครื่องหมายในการดำเนินการทางคณิตศาสตร์และตรรกศาสตร์

	+	การบวก เช่น x + y
	-	การลบ เช่น x - y
	*	การคูณ เช่น x * y
	/	การหาร เช่น x/y
	%	การหารเอาเศษ (modulus) 
		ผลที่ได้คือเศษที่เหลือ เช่น 21/4 จะได้คำตอบคือ 1
	++	การเพิ่มค่า เช่น x++ จะเท่ากับ x+1
	- - 	การลดค่า เช่น y- - จะเท่ากับ y - 1
	>	มากกว่า เช่น a > b
	>=	มากกว่าหรือเท่ากับ เช่น z>=y
	<	น้อยกว่า เช่น z < a
	<= 	น้อยกว่าหรือเท่ากับ เช่น z <= a
	==	เท่ากัน เช่น a == b
	!=	ไม่เท่ากัน เช่น a != b
	&&	AND  ผลลัพธ์จะเป็นจริงต่อเมื่อค่าทั้งสองข้างเป็นจริงเท่านั้น
	||	OR    ผลลัพธ์จะเป็นเท็จต่อเมื่อค่าทั้งสองข้างเป็นเท็จเท่านั้น
	!	NOT ผลลัพธ์จะเป็นจริงต่อเมื่อค่าเดิมเป็นเท็จ 
		และผลลัพธ์จะเป็นเท็จต่อเมื่อค่าเดิมเป็นจริง

เงื่อนไขในภาษา C

1. เงื่อนไข if
	if(a == c) printf("a เท่ากับ c");
	else printf("a ไม่เท่ากับ c");
    คือถ้าเงื่อนไขในวงเล็บ (a == c) เป็นจริง ก็จะทำคำสั่ง printf("a เท่ากับ c");
                                                แต่ถ้าเป็นเท็จ ก็จะทำคำสั่งหลัง else คือ printf("a ไม่เท่ากับ c");
2. เงื่อนไข switch( ) ... case
	switch(num)
	{
	  case 1:  คำสั่ง1 ;
		break;
	  case 2:  คำสั่ง2;
		break;
	  default:  คำสั่ง3;
               	 }
    ถ้าค่าในวงเล็บ (num) เท่ากับ 1 จะทำคำสั่ง1
    ถ้าค่าในวงเล็บ (num) เท่ากับ 2 จะทำคำสั่ง2
    แต่ถ้าค่าในวงเล็บ (num) ไม่เท่ากับค่าใดในหัวข้อ case เลย ก็จะทำคำสั่งหลังหัวข้อ default
    คือคำสั่ง3

การวนลูป

1. ลูป for
	for(ตัวแปร = ค่าเริ่มต้น ; เงื่อนไข ; การเพิ่มหรือลดค่าตัวแปร)
	 {
                   คำสั่งที่1;
	   คำสั่งที่2;
                   คำสั่งที่3;
                   }
        เช่น for(x = 0; x < 10; x++)
                {
	   printf("test");
                  }
         จะทำให้มีการพิมพ์คำว่า test ออกทางจอภาพ 10 ครั้ง

2. ลูป while
               while(เงื่อนไข)
                 {
	   คำสั่งที่1;
	   คำสั่งที่2;
	   คำสั่งที่3;
	  }
   เช่น while(x < 10)
           {
              printf("test");
              x++;
            }
          จะทำให้มีการพิมพ์ค่าว่า test ออกทางจอภาพ และเพิ่มค่า x ไปเรื่อย ๆ จนกว่า
    ค่า x มากกว่าหรือเท่ากับ 10

3. ลูป do...while
   	do{
	      คำสั่งที่1;
	      คำสั่งที่2;
	      คำสั่งที่3;
	     }while(เงื่อนไข)
    จะคล้าย ๆ กับคำสั่ง while เพียงแต่ว่าจะต้องมีการกระทำคำสั่ง1, 2, 3 ก่อน
    ที่จะมาเปรียบเทียบเงื่อนไข และจะทำไปเรื่อย ๆ จนกว่าเงื่อนไขเป็น "เท็จ"

คลาสและออปเจ็ค (class and object)

ในภาษา C++ นั้น ได้มีการเพิ่มความสามารถ อีกอย่างหนึ่งเข้ามา ก็คือการประกาศคลาส (class) ซึ่งภายใน คลาสนี้ จะรวบรวมเอาตัวแปร และฟังก์ชั่นที่ในงานเฉพาะอย่าง ไว้ด้วยกัน การประกาศคลาส จะทำได้ดังตัวอย่าง

	class myclass
	   {
		private: int myage;
		             float mysalary;
		protected: int setmyage(int newage);
			 float setmysalary(float mysalary);
		public:      int readmyage(void);
			 float readmysalary(void);
	    }; 

จะเห็นว่า การประกาศคลาส จะขึ้นตันด้วยคำว่า class แล้วตามด้วย ชื่อคลาสที่เราต้องการ จากนั้นจะกำหนดชื่อ ตัวแปร และฟังก์ชั่นทั้งหมด ที่ใช้ในคลาสนี้ไว้ในเครื่องหมาย ปีกกา ({,}) ภายในคลาส จะมีตัวแปรและฟังก์ชั่น ที่ได้รับการกำหนดชนิดไว้ หลายแบบ ต่าง ๆ กันไป โดยตัวแปร หรือฟังก์ชั่น ที่เขียนตามหลัง คำว่า private: จะสามารถเข้าถึง หรือเปลี่ยนแปลงได้ จากฟังก์ชั่นที่อยู่ในคลาสนี้เท่านั้น ส่วนตัวแปร หรือฟังก์ชั่น ที่เขียนตามหลัง คำว่า protected: จะสามารถเข้าถึงได้จาก ฟังก์ชั่นที่อยู่ในคลาสนี้ หรือคลาสที่สืบทอด (derive) จาก คลาสนี้เท่านั้น ส่วนตัวแปร หรือฟังก์ชั่นที่ เขียนตามหลังคำว่า public จะสามารถเข้าถึงได้จากฟังก์ชั่นในคลาสใด ๆ ก็ได้ในตัวโปรแกรม

การสืบทอดคลาส ก็กระทำได้โดยใช้คำสั่งดังต่อไปนี้

	class myderivedclass:public myclass
	  {
		private: int myweight;
		protected: int setmyweight(int newweight);
		public: int readmyweight(void);
	    };

การสืบทอดคลาสใหม่ มาจากคลาสเดิม จะใช้วิธีการประกาศคลาสใหม่ แล้วตามด้วยเครื่องหมายโคลอน (:) แล้วตามด้วย คำว่า public แล้วตามด้วยชื่อคลาสเดิม ที่เราจะสืบทอดมา โดยที่คลาสใหม่ที่ได้นี้ จะคงลักษณะ ของคลาสเดิมทุกประการ และยังเพิ่ม ตัวแปร myweight และฟังก์ชั่นใหม่ ๆ คือ setmyweight() และ readmyweight() เข้าไปอีก

แต่การประกาศคลาส ดังข้างต้นนั้น เรายังไม่สามารถใช้งาน ตัวแปรและฟังก์ชั่นต่าง ๆ ในคลาสนั้น ๆ ได้ เพราะการประกาศ คลาสนั้น เป็นเหมือนการกำหนดคุณลักษณะ ของสิ่งใดสิ่งหนึ่งขึ้นมาเท่านั้นเอง ยังไม่มีการสร้างสิ่งนั้นขึ้นมาจริง ๆ ดังนั้นเมื่อจะใช้งาน ก็จะมีการสร้าง วัตถุเป้าหมาย (object) ของคลาสนั้น ๆ ขึ้นมา ซึ่งทำได้ดังต่อไปนี้

	myderivedclass class1;
	int age = class1.readmyage( );

การสร้างวัตถุเป้าหมาย ทำได้โดยการตั้งชื่อวัตถุเป้าหมาย อยู่ต่อกับชื่อคลาส ซึ่งในตัวอย่างข้างต้น เป็นการสร้างวัตถุเป้าหมาย ที่ชื่อว่า class1 ซึ่งเป็นวัตถุเป้าหมาย ของคลาส myderivedclass จากนั้นก็จะมีการเรียกใช้ ฟังก์ชั่น readmyage() ซึ่งฟังก์ชั่นนี้ถูกประกาศ ให้เป็นชนิด public จึงทำให้สามารถใช้ฟังก์ชั่นนี้ จากที่ใดก็ได้ภายในโปรแกรม การเรียกใช้ฟังก์ชั่นในคลาสใด จะทำได้โดยการพิมพ์ชื่อ ของฟังก์ชั่น นั้น ต่อจากชื่อของวัตถุเป้าหมายของคลาสนั้น โดยมีเครื่องหมายจุด (.) กั้นอยู่ตรงกลาง

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

	myclass *class2;		// กำหนดชื่อ class2 ขึ้นมาเป็นตัวแปร pointer
	class2 = new myclass;	// สร้างวัตถุเป้าหมายของ myclass ขึ้นมา โดยมีตัวชี้คือ class2
	int age = class2->readmyage();   //ใช้สัญลักษณ์ -> ในการอ้างถึงฟังก์ชั่นใน myclass
	delete class2;		// ลบตัวชี้ class2 ออกจากหน่วยความจำ เมื่อเลิกใช้งาน

การทบทวนแนวคิดภาษา C ก็ขอจบลงแต่เพียงเท่านี้นะคะ ถ้าต้องการทราบ รายละเอียดเพิ่มเติม ให้ไปศึกษาได้จาก หนังสือ การเขียนชุดคำสั่งภาษา C เบื้องต้น ที่มีจำหน่ายในร้านหนังสือทั่ว ๆ ไป ในตอนต่อไป จะได้นำเสนอ การเขียนโปรแกรมภาษา C บนวินโดวส์ แบบดั้งเดิม และแบบที่ใช้ MFC (microsoft foundation class) มาช่วย ให้การเขียนโปรแกรม มีความสะดวกขึ้น ติดตามอ่านตอนต่อไปนะคะ