หน้าเว็บ

วันอาทิตย์ที่ 26 สิงหาคม พ.ศ. 2555

Code ตัวอย่างโปรแกรม และหน้าตาโปรแกรมภาษาซี


ตัวอย่างที่ แสดงตัวอย่างโปรแกรมภาษาซีเบื้องต้น
#include <stdio.h>
void main( ) {
/* Display message to standard output */
printf(“My first program.”);

ตัวอย่างที่ 2 แสดงตัวอย่างโปรแกรมภาษาซีเบื้องต้น
#include <stdio.h> void main( ) { /* Display message to standard output */ printf
(“My first program.”); }

ตัวอย่างที่ 3 แสดงตัวอย่างโปรแกรมภาษาซีเบื้องต้น
#include
<stdio.h>
void
main
()
{
/* Display message
to standard
output */
printf
(
My first program.”
)
;
}

ตัวอย่างที่ 4 แสดงตัวอย่างการใช้ค่าของตัวแปรชนิด char
#include <stdio.h>
void main( ) {
int no;
char ch;
ch = ‘J’;
printf(“char : %c, dec : %d, oct : %o, hex : %x”, ch, ch, ch, ch);
no = ch;
printf(“\nno : %d, ch : %c”, no, ch);
no = 68;
ch = no;
printf(“\nno : %d, ch : %c”, no, ch);
}
ผลการทำงานของโปรแกรม
char : J, dec : 74, oct : 112, hex : 4a
no : 74, ch : J
no : 68, ch : D

ตัวอย่างที่ 5 แสดงตัวอย่างการรับข้อมูลเพื่อนำมาแสดงผล
#include <stdio.h>
void main( ) {
char name[100];
printf("What is your name ?\n");
scanf("%s", name);
printf("Very glad to know you, ");
printf("%s.",name);
}
ผลลัพธ์ของการทำงาน
What is your name ?
Willy
Very glad to know you, Willy.

ตัวอย่างที่ 6 แสดงการกำหนดค่าจำนวนจริงให้กับตัวแปรจำนวนเต็ม
#include <stdio.h>
void main( ) {
int x;
x = 14.8328;
printf(“x value is %d”, x);
}
ผลการทำงานของโปรแกรม
x value is 14

ตัวอย่างที่ 7 โปรแกรมหาผลรวมของเลขจำนวนเต็ม 2 จำนวนที่รับข้อมูลจากผู้ใช้
#include <stdio.h>
void main( ) {
int x, y, z;
printf(“Enter X value : “);
scanf(“%d”, &x);
printf(“Enter Y value : “);
scanf(“%d”, &y);
z = x + y;
printf(“Summary of X and Y is %d”, z);
}
ผลการทำงานของโปรแกรม
Enter X value : 15
Enter Y value : 20
Summary of X and Y is 35

ตัวอย่างที่ 8 แสดงการใช้ตัวดำเนินการเพิ่มค่า
#include <stdio.h>
void main( ) {
int y, count;
count = 1;
y = count++;
printf(“y = %d, count = %d”, y, count);
count = 1;
y = ++count;
printf(“\ny = %d, count = %d”, y, count);
}
ผลการทำงานของโปรแกรม
y = 1, count = 2
y = 2, count = 2

ตัวอย่างที่ 9 แสดงการใช้ตัวดำเนินการเปลี่ยนชนิดข้อมูล
#include <stdio.h>
void main( ) {
int x;
x = 2.5 * 2;
printf(“x value is %d”, x);
x = (int)2.5 * 2;
printf(“\nx value is %d”, x);
x = (int)(2.5 * 2);
printf(“\nx value is %d”, x);
}
ผลการทำงานของโปรแกรม
x value is 5
x value is 4
x value is 5

ตัวอย่างที่ 10 แสดงของการเปรียบเทียบด้วยตัวกาํเนินการความสัมพันธ์
#include <stdio.h>
void main( ) {
int x, y
printf(“Enter X : “);
scanf(“%d”, &x);
printf(“Enter Y : “);
scanf(“%d”, &y);
printf(“X > Y is %d”, x>y);
}

ผลการทำงานของโปรแกรม
Enter X : 32
Enter Y : 24
X > Y is 1

โปรแกรมแบบวนซ้ำ (คำสั่งประเภท For , while,do while)

คำสั่ง for สำหรับคำสั่ง for นั้น จะมีการทำงานเหมือนกับ while คือตรวจสอบเงื่อนไขหรือการเปรียบเทียบก่อน แล้วจึงทำคำสั่งภายในลูป แต่มักใช้ในกรณีที่ทราบจำนวนครั้งในการวนซ้ำที่แน่นอน 
for (กำหนดค่าเริ่มต้น ; เงื่อนไข ; การเพิ่ม/ลดค่าตัวแปร)
{
คำสั่ง;
}

ตัวอย่างที่ 15
1
2
3
4
5
6
ึ7
8
9
<?

for($a = 1 ; $a < 13 ; $a++)
{
echo "<font color=green>";
echo "2 x $a =",2*$a,"<br>";
echo "</font>";
}
?>

แสดงผลลัพธ์ 

จากตัวอย่างที่ 15 เป็นโปรแกรมสูตรคูณแม่ 2 โดย $a จะเริ่มเก็บค่าจาก 1 ในขณะที่เงื่อนไขยังเป็นจริง (นั่นคือ $a < 13) ก็จะทำคำสั่งในลูปทั้ง 3 คำสั่ง หลังจากนั้นตัวแปร $a จะถูกเพิ่มค่าทีละหนึ่ง และทำงานไปเรื่อยๆ จนกระทั่งเงื่อนไข $a < 13 เป็นเท็จ

ตัวอย่างที่ 16
1
2
3
4
5
6
ึ7
8
9
10
11
<table border=1>
<?
$a = 1;
for($a = 1 ; $a < 13 ; $a++)
{
echo "<tr>";
echo "<td>2 x $a</td><td>",2*$a,"</td>";
echo "</tr>";
}
?>
< /table>

แสดงผลลัพธ์ 
คำสั่ง while
เป็นคำสั่งที่ใช้วนซ้ำ โดยจะตรวจสอบเงื่อนไขก่อน ถ้าพบว่าเงื่อนไขเป็นจริง จึงจะทำคำสั่งที่อยู่ภายในลูป(loop) หลังจากนั้นจึงกลับมาตรวจสอบเงื่อนไขอีกครั้ง วนซ้ำเช่นนี้ไปเรื่อยๆ จนกว่าเงื่อนไขจะเป็นเท็จ 
while (เงื่อนไข)
{
คำสั่ง;
}

ตัวอย่างที่ 13 
1
2
3
4
5
6
ึ7
<?
$size = 1;
while ($size < 7)
{ echo "<font size = $size color=blue>HELLO<br>";
$size++;
}
?>

แสดงผลลัพธ์ 
จากตัวอย่าง โปรแกรมจะตรวจสอบเงื่อนไขก่อนว่าเป็นจริงหรือไม่ จะเห็นว่า $size มีค่าเท่ากับ 1 ซึ่งน้อยกว่า 7 ดังนั้นเงื่อนไขจึงเป็นจริง แล้วจึงเข้าไปทำคำสั่งที่อยู่ในลูปทั้ง 2 คำสั่ง โดยเพิ่มค่า $size ขึ้นอีกหนึ่ง
หลังจากนั้นก็กลับไปตรวจสอบเงื่อนไขต่อว่าเป็นจริงหรือไม่ ในที่นี้จะวนซ้ำทั้งสิ้น 6 รอบ
  คำสั่ง do..while คำสั่ง do..while จะมีการทำงานคล้ายกับ while แต่ต่างกันตรงที่ คำสั่ง do..while จะตรวจสอบเงื่อนไขทีหลัง นั่นคือจะมีการทำคำสั่งในลูปอย่างน้อย 1 ครั้งเสมอ เมื่อทำคำสั่งในลูปแล้วจึงตรวจสอบเงื่อนไขทีหลัง
do
{
คำสั่ง;
}
while (เงื่อนไข)


ตัวอย่างที่ 14
1
2
3
4
5
6
ึ7
8
<?
$a = 1;
do
{
echo $a," ";
$a++;
} while($a<=20)
?>

แสดงผลลัพธ์ 


ที่มา : http://www.mwit.ac.th/~jeab/40201/ch7.php#for

การเลือกทำงานตามเงื่อนไข (คำสั่ง IF ELSE SWITCH)

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

คำสั่งควบคุม (Control Statement)
คำสั่งควบคุมเป็นคำสั่งที่สำคัญในการเขียนโปรแกรม คือ ช่วยควบคุมทิศทางการทำงานของโปรแกรมให้เป็นไปตามที่ต้องการ โดยแบ่งออกเป็น 2 ประเภท คือ คำสั่งเงื่อนไข (Condition Sratement) ได้แก่ if,if-else , switch-case และคำสั่งทำซ้ำ (Iteration Statement) ได้แก่ for,while,do-while 
คำสั่ง if
คำสั่ง if จะใช้ในกรณีที่มีทางเลือกให้ทำงานอยู่เพียงทางเลือกเดียว โดยถ้าตรวจสอบเงื่อนไขแล้วเป็นจริง จึงจะทำงานตามคำสั่ง

รูปแบบคำสั่ง if 
if (เงื่อนไข )
{
คำสั่งที่ 1;
}
คำสั่งที่ 2;



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

ฟลวชาร์ตแสดงการทำงานของคำสั่งเงื่อนไข if
ตัวอย่างที่ 1 โปรแกรมแสดงการทำงานของคำสังเงื่อนไข if
1 :#include <stdio.h>
2 :#include <conio.h>
3 :void main()
4 :}
5 :clrscr();
6 :int age;
7 :printf("How old are you = ");
8 :scanf ("%d",&age);
9 :if(age<18)
10 :printf(" Your are young\n");
11 :printf("You are %d years old");
12 :getch();
13 :{
ผลลัพธ์ของโปรแกรม
   
ผลการรันครั้งที่ 1
How old are you = 15
Your are young
You are 15 years old
ผลการรันครั้งที่ 2
How old are you = 18
You are 18 years old

ธิบายโปรแกรม
โปรแกรมทำการตรวจสอบเงื่อนไขว่า หากอายุน้อยกว่า 18 ปี ให้พิมพ์คำข้อความ Your are young ซึ่งสังเกตโปรแกรมบรรทัดที่ 9 เท่านั้นที่เป็นคำสั่งภายในบล๊อคของคำสั่ง if ส่วนบรรทัดที่ 10 เป็นคำสั่งนอกบล๊อคของ if ดังจะเห็นได้จากผลลัพธ์ที่แสดง

          หากเงื่อนไขที่ตรวจสอบเป็นจริง ข้อความในบรรทัดที่ 9 จะถูกพิมพ์ หลังจากนั้นก้จะทำคำสั่งที่อยู่นอกเงื่อนไข if ต่อไป คือพิมพ์ข้อความในบรรทัดที่ 10
          แต่หากเงื่อนไขที่ตรวจสอบเป็นเท็จ ข้อความในบรรทัดที่ 9 ที่เป็นคำสั่งในส่วนของเงื่อนไข if ก็จะไม่ถูกประมวลผล แต่จะข้ามการทำงานไปประมวลผลในบรรทัดที่ 10 เลย

ตัวอย่างที่ 2 โปรแกรมแสดงการทำงานของคำสังเงื่อนไข if
1 :#include<stdio.h>
2 :#include<conio.h>
3 :void main()
4 :{
5 :clrscr();
6 :int age;
7 :printf("How old are you : ");
8 :scanf ("%d",&age);
9 :if(age<18) {
10 :printf("Your age less than 18 years old\n");
11 :printf("You are young\n");
12 :}
13 :printf("You are %d years old",age);
14 :getch();
15 :}
ผลลัพธ์ของโปรแกรม     
ผลการรันครั้งที่ 1
How old are you : 15
Your age less than 18 years old
You are young
You are 15 years old
ผลการรันครั้งที่ 2
How old are you : 18
You are 18 years old

อธิบายโปรแกรม
โปรแกรมที่ 2 ต่างจากโปรแกรมที่ 1 ตรงที่มีการนำเครื่องหมาย { } มาใช้คลุมคำสั่งที่อยู่ภายในบล๊อคของเงื่อนไข if มีคำสั่งที่ต้องทำงานเพียง 1 คำสั่งเหมือนโปรแกรมที่ 1 ก็ไม่จำเป็นต้องใน { } ให้กับบล๊อคของ if (แต่ถ้าจะใส่ก็ไม่ผิด) แต่สำหรับโปรแกรมที่ 2 เมื่อตรวจสอบว่าอายุน้อยกว่า 18 แล้ว จะมี 2 คำสั่งที่ต้องทำ คือ บรรทัดที่ 9 และ 10 ดังนั้นต้องใส่ { } คลุมด้วย (เมื่อบรรทัดที่ 9 และ 10 เรียบร้อยแล้ว ก็จะไปทำงานในบรรทัดที่ 12 ต่อไป) และหากอายุมากกว่าหรือเท่ากับ 18 ก็จะข้ามการทำงานในบล๊อคของ if ไปทำบรรทัดที่ 12 ทันที
คำสั่ง if-else
คำสั่ง if-else จะใช้ในกรณีที่มีทางเลือกให้ทำงาน 2 ทางเลือกขึ้นไป โดยการทำงานของคำสั่ง if-else จะเริ่มจากการตรวจสอบเงื่อนไข หถ้าผลออกมาเป็นจริงจะทำงานตามคำสั่งที่อยู่หลัง if แต่ถ้าการตรวจสอบเงื่อนไผลออกมาเป็นเท็จ ให้ทำงานตามคำสั่งที่อยู่หลัง else แทน
รูปแบบคำสั่ง if-else
if (เงื่อนไข)
{
คำสั่งที่ 1;
}
else
{
คำสั่งที่ 2;
}
คำสั่งที่ 3;


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

โฟลวชาร์ตแสดงการทำงานของคำสั่งเงื่อนไข if-else
ตัวอย่างโปรแกรมที่ 1
if (a % 2 = = 0)
printf ("Even number");ถ้าค่าของ a หารด้วย 2 ลงตัว (เหลือเศา 0) ให้แสดงข้อความ Even number
else
printf("Odd number");แต่ถ้าเงื่อนไขของ if เป็นเท็จ (a หารด้วย 2 ไม่ลงตัว) ให้แสดงข้อความ Odd number
ตัวอย่างโปรแกรมที่ 2 โปรแกรมแสดงการรับข้อมูลเข้าทางแป้นพิมพ์ แล้วทำการตรวจสอบว่าถ้าค่าที่เรับเข้ามานั้นเท่ากับศูนย์ ให้พิพม์คำว่า "ZERO" แต่ถ้าไม่เท่ากับศูนย์ให้พิมพ์คำว่า "NON-ZERO"
#include<stdio.h>
#include<conio.h>
void main()
{
clrscr():
int i;
printf(" Enter your number = ");
scanf("%d",&i);
if (i= = 0)
{
prinft("ZERO");
}
else
printf("NON-ZERO");

}


ที่มา : http://www.lks.ac.th/kuanjit/c_page01.html

ประเภทของข้อมูลภาษาซี

ข้อมูลใน C แบ่งชนิดข้อมูลออกเป็น 2 ประเภท คือ

1. Simple data type เป็นชนิดข้อมูลที่ใช้แสดงค่าของสิ่งใดสิ่งหนึ่งเพียงรายการเดียว เช่น
ค่าความสูง นํ้าหนัก จํานวนนักเรียน อุณหภูมิ ระดับคะแนน เป็นต้น

2. Structure เป็นข้อมูลชนิดใช้แสดงค่าของสิ่งใดสิ่งหนึ่งหลายรายการ เช่น ความสูงของนัก
เรียนใน ชั้น ม. 6, รายชื่อนักเรียนใน 1 กลุ่ม ต้องกําหนดเป็นข้อมูล
ชนิดโครงสร้างแบบ อาร์เรย์ (array) แบบโครงสร้าง(structure) หรือแบบยูเนียน(union) เป็นต้น
ข้อมูล Simple data type รายละเอียดชนิดของมูลและช่วงของข้อมูลประเภท Simple data type
แสดงได้ดังตารางต่อไปนี้ 

ชนิดข้อมูลค่าตํ่าสุดค่าสูงสุดใช้พื้นที่หน่วยความจำ
char-1281271 byte
unsigned char02551 byte
int-32,76832,7672 byte
unsigned int065,5352 byte
short int-32,76832,7672 byte
long-2,147,483,6482,147,483,6474 byte
unsigned long04,294,967,2954 byte
float3.4x10 ยกกำลัง -383.4x10 ยกกำลัง 384 byte
double1.7x10 ยกกำลัง -3081.7x10 ยกกำลัง 3088 byte
long double3.4x10 ยกกำลัง -49323.4x10 ยกกำลัง493210 byte


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

#include<stdio.h>
main()
{
int num1=10;
กำหนดตัวแปรชื่อ num1 เป็นจำนวนเต็มมีค่าเท่ากับ 10
int num2=10;
กำหนดตัวแปรชื่อ num2 เป็นจำนวนเต็มมีค่าเท่ากับ 10
int sum;
กำหนดตัวแปรชื่อ sum เป็นจำนวนเต็มมีค่า

sum = num1 + num2; ทำการบวกค่า sum
printf("Result Data = %d",sum);
แสดงผลค่าตัวแปร sum ออกไปที่หน้าต่าง
}
ทำการเขียน Source code

ทำการเขียน Source code ลงไปในโปรแกรม Borland Turbo C เพื่อทดสอบ


ที่มา: http://www.prasansoft.com/C-programming-5.php

โครงสร้างภาษาซี

ภาษา C เป็นภาษาคอมพิวเตอร์ที่ถูกค้นคิดขึ้นโดย Denis Ritchie ในปี ค.ศ. 1970
โดยใช้ระบบปฏิบัติการของยูนิกซ์ (UNIX) นับจากนั้นมาก็ได้รับความนิยมเพิ่มขั้นจนถึงปัจจุบัน ภาษา C สามารถติดต่อในระดับฮาร์ดแวร์ได้ดีกว่าภาษาระดับสูงอื่น ๆ ไม่ว่าจะเป็นภาษาเบสิกฟอร์แทน ขณะเดียวกันก็มีคุณสมบัติของภาษาระดับสูงอยู่ด้วย ด้วยเหตุผลดังกล่าวจึงจัดได้ว่าภาษา C เป็นภาษาระดับกลาง (Middle –lever language)
ภาษา C เป็นภาษาคอมพิวเตอร์ชนิดคอมไพล์ (compiled Language) ซึ่งมีคอมไพลเลอร์ (Compiler) ทำหน้าที่ในการคอมไพล์ (Compile) หรือแปลงคำสั่งทั้งหมดในโปรแกรมให้เป็นภาษาเครื่อง (Machine Language) เพื่อให้เครื่องคอมพิวเตอร์นำคำสั่งเหล่านั้นไปทำงานต่อไป
โครงสร้างของภาษา C
ทุกโปรแกรมของภาษา C มีโครงสร้างเป็นลักษณะดังรูป



เฮดเดอร์ไฟล์ (Header Files)
เป็นส่วนที่เก็บไลบรารี่มาตรฐานของภาษา C ซึ่งจะถูกดึงเข้ามารวมกับโปรแกรมในขณะที่กำลังทำการคอมไพล์ โดยใช้คำสั่ง
#include<ชื่อเฮดเดอร์ไฟล์> หรือ
#include “ชื่อเฮดเดอร์ไฟล์” 
เฮดเดอร์ไฟล์นี้จะมีส่วนขยายเป็น .h เสมอ และเฮดเดอร์ไฟล์เป็นส่วนที่จำเป็นต้องมีอย่างน้อย 1 เฮดเดอร์ไฟล์ ก็คือ เฮดเดอร์ไฟล์ stdio.h ซึ่งจะเป็นที่เก็บไลบรารี่มาตรฐานที่จัดการเกี่ยวกับอินพุตและเอาท์พุต
ส่วนตัวแปรแบบ Global (Global Variables)
เป็นส่วนที่ใช้ประกาศตัวแปรหรือค่าต่าง ๆ ที่ให้ใช้ได้ทั้งโปรแกรม ซึ่งใช้ได้ทั้งโปรแกรม ซึ่งในส่วนไม่จำเป็นต้องมีก็ได้
ฟังก์ชัน (Functions)
เป็นส่วนที่เก็บคำสั่งต่าง ๆ ไว้ ซึ่งในภาษา C จะบังคับให้มีฟังก์ชันอย่างน้อย 1 ฟังก์ชั่นนั่นคือ ฟังก์ชั่น Main() และในโปรแกรม 1 โปรแกรมสามารถมีฟังก์ชันได้มากกว่า 1 ฟังก์ชั่น


ส่วนตัวแปรแบบ Local (Local Variables)
เป็นส่วนที่ใช้สำหรับประกาศตัวแปรที่จะใช้ในเฉพาะฟังก์ชันของตนเอง ฟังก์ชั่นอื่นไม่สามารถเข้าถึงหรือใช้ได้ ซึ่งจะต้องทำการประกาศตัวแปรก่อนการใช้งานเสมอ และจะต้องประกาศไว้ในส่วนนี้เท่านั้น 
ตัวแปรโปรแกรม (Statements)
เป็นส่วนที่อยู่ถัดลงมาจากส่วนตัวแปรภายใน ซึ่งประกอบไปด้วยคำสั่งต่าง ๆ ของภาษา C และคำสั่งต่าง ๆ จะใช้เครื่องหมาย ; เพื่อเป็นการบอกให้รู้ว่าจบคำสั่งหนึ่ง ๆ แล้ว ส่วนใหญ่ คำสั่งต่าง ๆ ของภาษา C เขียนด้วยตัวพิมพ์เล็ก เนื่องจากภาษา C จะแยกความแตกต่างชองตัวพิมพ์เล็กและพิมพ์ใหญ่หรือ Case Sensitive นั่นเอง ยกตัวอย่างใช้ Test, test หรือจะถือว่าเป็นตัวแปรคนละตัวกัน นอกจากนี้ภาษา C ยังไม่สนใจกับการขึ้นบรรทัดใหม่ เพราะฉะนั้นผู้ใช้สามารถพิมพ์คำสั่งหลายคำสั่งในบรรทัดเดียวกันได้ โดยไม่เครื่องหมาย ; เป็นตัวจบคำสั่ง


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


หมายเหตุ (Comment) / Remark 
ส่วนที่ไม่ต้องประมวลผลมักใช้ในการอธิบายการทำงานของโปรแกรม ซึ่งจะใช้เครื่องหมาย /*และ */ ปิดหัวและปิดท้ายของข้อความที่ต้องการ




การตั้งชื่อ 
การตั้งชื่อ (Identifier) ให้กับตัวแปร ฟังก์ชันหรืออื่น ๆ มีกฎเกณฑ์ในการตั้งชื่อ ดังนี้
1. ตัวแรกของชื่อจะต้องขึ้นต้องด้วยตัวอักษรหรือเครื่องหมาย _ เท่านั้น
2. ตัวอักษรตั้งแต่ตัวที่ 2 สามารถเป็นตัวเลข หรือเครื่องหมาย_ก็ได้
3. จะต้องไม่มีการเว้นวรรคภายในชื่อ แต่สามารถใช้เครื่อง_คั่นได้
4. สามารถตั้งชื่อได้ยาไม่จำกัด แต่จะใช้ตัวอักษรแค่ 31 ตัวแรกในการอ้างอิง 
5. ชื่อที่ตั้งด้วยตัวอักษรพิมพ์ใหญ่และพิมพ์เล็ก จะถือว่าเป็นคนละตัวกัน 
6. ห้ามตั้งชื่อซ้ำกับคำสงวนของภาษา C


ชนิดข้อมูล
ในการเขียนโปรแกรมภาษา C นั้น ผู้ใช้จะต้องกำหนดชนิดให้กับตัวแปรนั้นก่อนที่จะนำไปใช้งาน โดยผู้ใช้จะต้องรู้ว่าในภาษา C นั้นมีชนิดข้อมูลอะไรบ้าง เพื่อจะเลือกใช้ได้อย่างถูก
ต้องและเหมาะสม ในภาษา C จะมี 4 ชนิดข้อมูลมาตรฐาน ดังนี้
ชนิดข้อมูลแบบไม่มีค่า หรือ Void Type (Void)
ข้อมูลชนิดนี้ จะไม่มีค่าและจะไม่ใช้ในการกำหนดชนิดตัวแปร แต่ส่วนใหญ่จะใช้เกี่ยวกับฟังก์ชั่น ซึ่งจะขอยกไปอธิบายในเรื่องฟังก์ชั่น
ชนิดข้อมูลมูลแบบจำนวนเต็ม หรือ Integer Type (int)
เป็นชนิดข้อมูลที่เป็นตัวเลขจำนวนเต็ม ไม่มีทศนิยม ซึ่งภาษา C จะแบ่งข้อมูลชนิดนี้ออกได้เป็น 3 ระดับ คือ short int , int และ long int ซึ่งแต่ละระดับนั้นจะมีขอบเขตการใช้งานที่แตกต่างกัน 
ชนิดข้อมูลแบบอักษร หรือ Character Type (char)
ข้อมูลชนิดนี้ก็คือ ตัวอักษรตั้งแต่ A-Z เลข 0-9 และสัญลักษณ์ต่าง ๆ ตามมาตรฐาน ACSII (American Standard Code Information Interchange) ซึ่งเมื่อกำหนดให้กับตัวแปรแล้วตัวแปรนั้นจะรับค่าได้เพียง 1 ตัวอักษรเท่านั้น และสามารถรับข้อมูลจำนวนเต็มตั้งแต่ถึง 127 จะใช้ขนาดหน่วยความจำ 1ไบต์หรือ 8 บิต
ชนิดข้อมูลแบบทศนิยม หรือ Floating Point Type (flat)
เป็นข้อมูลชนิดตัวเลขที่มีจุดทศนิยม ซึ่งสามารถแบ่งออกเป็น 3 ระดับ คือ float, double และ long double แต่ละระดับนั้นจะมีขอบเขตที่แตกต่างกันในการใช้งาน ดังแสดงในตารางที่ 2-2
ตัวแปร 
ตัวแปร คือ ชื่อที่ใช้อ้างถึงตำแหน่งต่าง ๆ ในหน่วยความจำ ซึ่งใช้เก็บข้อมูลต่าง ๆ ด้วยขนาดตามชนิดข้อมูล


การประกาศตัวแปร 
การประกาศตัวแปรในภาษา C นั้นสามรถทำได้ 2 ลักษณะ คือ การประกาศตัวแปรแบบเอกภาพ หรือการประกาศตัวแปรแบบ Global คือ ตัวแปรที่จะสามารถเรียกใช้ได้ทั้งโปรแกรม และแบบที่สองการประกาศตัวแปรแบบภายใน หรือการประกาศตัวแปรแบบ Local ซึ่งตัวแปรแระเภทนี้จะใช้ได้ในเฉพาะฟังก์ชั่นของตัวเองเท่านั้น



การกำหนดค่าให้กับตัวแปร
การกำหนดค่าให้กับตัวแปรนั้น จะสามารถกำหนดได้ตั้งแต่ตอนที่ประกาศตัวแปรเลยหรือจะกำหนดให้ภายในโปรแกรมก็ได้ ซึ่งการกำหนดค่าจะใช้เครื่องหมาย = กั้นตรงกลาง
int total = 0;
ถ้ามีตัวแปรข้อมูลชนิดเดียวกัน ก็สามารถทำแบบนี้ได้
int total =0,sum
หรือ 
int total =0,sum=0;
ถ้าเป็นการกำหนดภายในโปรแกรม ซึ่งตัวแปรนั้นได้ประกาศไว้แล้วสามารถทำแบบนี้
total = 50;
หรือ 
total = total+sum
หรือกำหนดค่าจาการพิมพ์ข้อมูลเข้าทางคีย์บอร์ด
scanf(“%d”,&total);




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


ชนิดข้อมูลแบบค่าคงที่ (Constants)
ชนิดข้อมูลประเภทนี้ ชื่อก็บอกอยู่ว่าเป็นชนิดข้อมูลแบบค่าคงที่ ซึ่งก็คือข้อมูลตัวแปรประเภทที่เป็น Constants ผู้ใช้จะไม่สามารถเปลี่ยนแปลงค่าของตัวแปรตัวนั้น ในขณะที่โปรแกรมทำงานอยู่
รูปแบบ
Const[ชนิดข้อมูล][ตัวแปร]=[ค่าหรือ นิพจน์]



statements ในภาษา c คือ คำสั่งต่าง ไ ที่ประกอบขึ้นจนเป็นตัวโปรแกรม ซึ่งในภาษา c นั้นได้แบ่งออกเป็น 6 แบบ คือ Expression Statement และ Compound Statement ณ.ที่นี้จะมีด้วยกัน 2 แบบ

Expression Statement หรือเรียกอีกอย่างหนึ่งว่า Single Statement ซึ่ง Statement แบบนั้นจะต้องมีเครื่องหมาย; หลังจาก statement เมื่อภาษา C พบเครื่องหมาย ; จะทำให้มันรู้ว่าจบชุดคำสั่งแล้ว แล้วจึงข้ามไปทำ Statement ชุดต่อไป
a = 2;
หรือ
printf(“x contains %d, y contains %d\n”,x,y);
Compound Statement คือ ชุดคำสั่งที่มีคำสั่งต่าง ๆ รวมอยู่ด้านใน Block ซึ่งจะใช้เครื่องหมาย {เป็นการเปิดชุดคำสั่ง และใช้} เป็นตัวปิดชุดคำสั่ง ตัวอย่างที่เห็นได้ชัดเจนสำหรับ Statement แบบนี้ คือ ตัวฟังก์ชั่น Main โดยทั่ว ๆ ไปในภาษา C Compound Statement จะเป็นตัวฟังก์ชัน

วันจันทร์ที่ 20 สิงหาคม พ.ศ. 2555

ประวัติภาษาซี

        ภาษาซี (C) เป็นภาษาโปรแกรมบนคอมพิวเตอร์ที่มีวัตถุประสงค์ทั่วไป พัฒนาขึ้นเมื่อ พ.ศ. 2515 (ค.ศ. 1972) โดย เดนนิส ริตชี ที่เบลล์เทเลโฟนแลบอลาทอรีส์ (Bell Telephone Laboratories) เกิดขึ้นเพื่อสร้างระบบปฏิบัติการยูนิกซ์ในขณะนั้น


ประวัติ

การพัฒนาช่วงแรก
การเริ่มต้นพัฒนาภาษาซีเกิดขึ้นที่เบลล์แล็บส์ของเอทีแอนด์ทีระหว่าง พ.ศ. 2512–2516 แต่ตามข้อมูลของริตชี ช่วงเวลาที่เกิดความสร้างสรรค์มากที่สุดคือ พ.ศ. 2515 ภาษานี้ถูกตั้งชื่อว่า "ซี" เพราะคุณลักษณะต่าง ๆ ต่อยอดมาจากภาษาก่อนหน้าคือ "บี" ซึ่งจากข้อมูลของเคน ทอมป์สัน (Ken Thompson) กล่าวว่าภาษาบีเป็นรุ่นที่แยกตัวออกจากภาษาบีซีพีแอลอีกทอดหนึ่ง จุดเริ่มต้นของภาษาซีผูกอยู่กับการพัฒนาระบบปฏิบัติการยูนิกซ์อย่างใกล้ชิด ซึ่งเดิมพัฒนาด้วยภาษาแอสเซมบลีบนหน่วยประมวลผลพีดีพี-7โดยริตชีและทอมป์สัน โดยผสมผสานความคิดหลากหลายจากเพื่อนร่วมงาน ในตอนท้ายพวกเขาตัดสินใจที่จะย้ายระบบปฏิบัติการนั้นลงในพีดีพี-11 แต่ภาษาบีขาดความสามารถบางอย่างที่จะใช้คุณลักษณะอันได้เปรียบของพีดีพี-11 เช่นความสามารถในการระบุตำแหน่งที่อยู่เป็นไบต์ จึงทำให้เกิดการพัฒนาภาษาซีรุ่นแรกขึ้นมา รุ่นดั้งเดิมของระบบยูนิกซ์บนพีดีพี-11ถูกพัฒนาขึ้นด้วยภาษาแอสเซมบลี เมื่อประมาณ พ.ศ. 2516 ภาษาซีเพิ่มชนิดข้อมูล struct ทำให้ภาษาซีเพียงพออย่างมีประสิทธิภาพ ซึ่งเคอร์เนลยูนิกซ์ส่วนใหญ่ถูกเขียนด้วยภาษาซี นี้ก็เป็นเคอร์เนลหนึ่งของระบบปฏิบัติการที่พัฒนาด้วยภาษาอื่นนอกเหนือจากภาษาแอสเซมบลี (ระบบอื่นเช่นมัลติกส์เขียนด้วยภาษาพีแอล/วัน เอ็มซีพีสำหรับเบอร์โรส์ บี5000เขียนด้วยภาษาอัลกอล ในปี พ.ศ. 2504)

ภาษาเคแอนด์อาร์ซี

เมื่อ พ.ศ. 2521 ไบรอัน เคอร์นิกัน (Brian Kernighan) และเดนนิส ริตชี ได้ตีพิมพ์หนังสือเล่มแรกชื่อ เดอะซีโปรแกรมมิงแลงกวิจ (The C Programming Language) ซึ่งเป็นที่รู้จักในกลุ่มโปรแกรมเมอร์ภาษาซีว่า "เคแอนด์อาร์" (K&R อักษรย่อของผู้แต่งทั้งสอง) หนังสือเล่มนี้ทำหน้าที่เป็นข้อกำหนดของภาษาอย่างไม่เป็นทางการมาหลายปี ภาษาซีรุ่นดังกล่าวจึงมักถูกอ้างถึงว่าเป็น ภาษาเคแอนด์อาร์ซี (K&R C) ส่วนหนังสือที่ปรับปรุงครั้งที่สองครอบคลุมมาตรฐานแอนซีซีที่มีขึ้นทีหลัง
ภาษาเคแอนด์อาร์ซีได้แนะนำคุณลักษณะหลายประการเช่น

  • ไลบรารีไอ/โอมาตรฐาน
  • ชนิดข้อมูล long int (จำนวนเต็มขนาดยาว)
  • ชนิดข้อมูล unsigned int (จำนวนเต็มไม่มีเครื่องหมาย)
  • ตัวดำเนินการกำหนดค่าแบบประสมในรูปแบบ =ตัวดำเนินการ (เช่น =-) ถูกเปลี่ยนเป็น ตัวดำเนินการ= (เช่น -=) เพื่อลดปัญหาความกำกวมเชิงความหมาย อย่างเช่นกรณี i=-10 ซึ่งจะถูกตีความว่า i =- 10 แทนที่จะเป็นอย่างที่ตั้งใจคือ i = -10
แม้ว่าหลังจากการเผยแพร่มาตรฐานของภาษาซีเมื่อ พ.ศ. 2532 ภาษาเคแอนด์อาร์ซีถูกพิจารณาว่าเป็น "ส่วนร่วมต่ำสุด" อยู่เป็นเวลาหลายปี (ความสามารถในการแปลรหัสจำนวนหนึ่งเป็นคำสั่งซึ่งทำงานได้บนเครื่องใดก็ตามเป็นอย่างน้อย) ซึ่งโปรแกรมเมอร์ภาษาซีต้องจำกัดความสามารถของพวกเขาในกรณีที่ต้องการให้ระบบสามารถใช้ได้กับหลายเครื่องมากที่สุด เนื่องจากตัวแปลโปรแกรมเก่า ๆ ก็ยังคงมีการใช้งานอยู่ และการเขียนภาษาซีแบบเคแอนด์อาร์อย่างระมัดระวังสามารถเข้ากันได้กับภาษาซีมาตรฐานเป็นอย่างดี ในภาษาซีรุ่นแรก ๆ เฉพาะฟังก์ชันที่คืนค่าไม่เป็นจำนวนเต็ม จำเป็นต้องประกาศไว้ก่อนการนิยามฟังก์ชันหากมีการเรียกใช้ อีกนัยหนึ่งคือ ฟังก์ชันที่ถูกเรียกใช้โดยไม่มีการประกาศมาก่อน ถือว่าฟังก์ชันนั้นจะคืนค่าเป็นจำนวนเต็มหากค่าของมันถูกใช้งานการประกาศฟังก์ชันของภาษาเคแอนด์อาร์ซีไม่มีการระบุข้อมูลเกี่ยวกับอาร์กิวเมนต์ที่ใช้ ดังนั้นจึงไม่มีการตรวจชนิดข้อมูลพารามิเตอร์ของฟังก์ชัน แม้ว่าตัวแปลโปรแกรมบางตัวจะแสดงข้อความเตือน ถ้าฟังก์ชันถูกเรียกใช้ภายในโดยมีจำนวนอาร์กิวเมนต์ที่ผิด หรือถ้าฟังก์ชันถูกเรียกใช้หลายครั้งจากภายนอกโดยมีชนิดข้อมูลของอาร์กิวเมนต์ต่างกัน เครื่องมือภายนอกอาทิ ลินต์ (lint) ของยูนิกซ์ถูกพัฒนาขึ้นเพื่อให้สามารถตรวจสอบความคงเส้นคงวาของฟังก์ชันที่ใช้งานข้ามไฟล์รหัสต้นฉบับหลายไฟล์
หลายปีถัดจากการเผยแพร่ภาษาเคแอนด์อาร์ซี คุณลักษณะที่ไม่เป็นทางการหลายอย่างก็ถูกเพิ่มเข้ามาในภาษา ซึ่งรองรับโดยตัวแปลโปรแกรมจากเอทีแอนด์ทีและผู้ผลิตรายอื่น คุณลักษณะที่เพิ่มเหล่านี้เช่น

  • ฟังก์ชัน void
  • ฟังก์ชันที่คืนค่าเป็นชนิดข้อมูล struct หรือ union (แทนที่จะเป็นตัวชี้)
  • การกำหนดค่าให้กับชนิดข้อมูล struct
  • ชนิดข้อมูลแจงนับ (enumerated type)
ส่วนขยายที่เพิ่มขึ้นอย่างมากและการขาดข้อตกลงในเรื่องไลบรารีมาตรฐาน อีกทั้งความนิยมในภาษาและข้อเท็จจริงที่ว่าไม่เพียงแต่ตัวแปลโปรแกรมยูนิกซ์เท่านั้นที่พัฒนาขึ้นตามข้อกำหนดของเคแอนด์อาร์ ทั้งหมดนำไปสู่ความสำคัญของการทำให้เป็นมาตรฐาน




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


ที่มา: http://th.wikipedia.org/wiki/%E0%B8%A0%E0%B8%B2%E0%B8%A9%E0%B8%B2%E0%B8%8B%E0%B8%B5