ตัวอย่างประเภทโครงงานคอมพิวเตอร์

ตัวอย่างประเภทโครงงานคอมพิวเตอร์

1.โครงงานพัฒนาสื่อเพื่อการศึกษา

1.) สารานุกรมไทยฉบับมัลติมีเดีย

2.) พิพิธภัณฑ์หุ่นขี้ผึ้งไทย

3.) โปรแกรมช่วยสอนการทำงานของทรานซิสเตอร์

2.โครงงานพัฒนาเครื่องมือ

1.)โปรแกรมการค้นหาคำภาษาไทย

2.)โปรแกรมประมวลผลคำไทยบนระบบปฏิบัติการลีนุกซ์

3.)การส่งสัญญาณควบคุมอุปกรณ์อิเล็กทรอนิกส์

3.โครงงานจำลองทฤษฎี

1.) การทดลองผสมสารเคมีต่างๆ ด้วยคอมพิวเตอร์

2.) ปัจจัยต่างๆ กับการเคลื่อนที่ของเครื่องบิน

3.) ผลการปลูกข้าวในสภาวะแวดล้อมที่ต่างกัน

4.โครงงานประยุกต์ใช้งาน

 1.) โปรแกรมออกและตรวจข้อสอบ

2.) โฮมเพจส่วนบุคคล

3.) โปรแกรมช่วยปฐมพยาบาลเบื้องต้น

5.โครงงานพัฒนาเกม

1.) เกมผจญภัยกับพระอภัยมณี

2.) เกมหมากฮอส

3.) เกมอักษรไขว้

นางสาว อัญชลี ภูเพ็กซี่ ม.3/3 เลขที่ 3/3

บทที่ 8

ข้อมูลแบบโครงสร้างและยูเนียน

สำหรับในบทนี้จะกล่าวถึง ข้อมูลแบบโครงสร้าง (structures) ซึ่งเป็นข้อมูลชนิดหนึ่งที่มีลักษณะสำคัญ คือ สามารถรวบรวมข้อมูลหลาย ๆ ชนิดเข้ามาเก็บไว้ด้วยกัน เพื่อความสะดวกในการจัดการข้อมูลต่างชนิดกัน และช่วยในการจัดเก็บข้อมูลแบบ record ซึ่งเป็นพื้นฐานที่สำคัญในการจัดการแฟ้มข้อมูลต่อไป ส่วนในตอนท้ายของบทนี้จะกล่าวถึงข้อมูลแบบยูเนียน(unions) ซึ่งเป็นข้อมูลชนิดหนึ่งที่ทำให้เราสามารถใช้ตัวแปรหลาย ๆ ชนิด ภายในเนื้อที่เดียวกัน ทำให้การใช้เนื้อที่ในหน่วยความจำลดลง และสามารถทำงานได้อย่างมีประสิทธิภาพมากขึ้น 8.1 ความหมายและลักษณะของข้อมูลแบบโครงสร้าง ข้อมูลแบบโครงสร้าง คือ ข้อมูลชนิดหนึ่งที่เกิดจากการรวบรวมตัวแปรหลาย ๆ ชนิดมาเก็บไว้ด้วยกัน โดยเก็บไว้ภายใต้ชื่อโครงสร้าง (structure name) เดียวกัน ตัวอย่างที่ 8.1 ต้องการเก็บข้อมูลของพนักงานแต่ละคนซึ่งประกอบด้วย ชื่อพนักงาน ตำแหน่ง และเงินเดือน จำนวน 10 คน ดังนั้นข้อมูลของพนักงานคนที่ 1, 2, 3…, 10 จะมีโครงสร้างแฟ้มข้อมูลดังนี้ คือ ตารางที่ 8.1 แสดงโครงสร้างแฟ้มข้อมูลของพนักงาน คน ที่ ชื่อพนักงาน (ตัวแปรตัวที่ 1) ตำแหน่ง (ตัวแปรตัวที่ 2) เงินเดือน (ตัวแปรตัวที่ 3) 1 2 3 …. 10 นาย ก. นาย ข. นาย ค. ……… นาย ช. ผู้จัดการทั่วไป โปรแกรมเมอร์ นักวิเคราะห์ระบบ …………………. นักบัญชี 20,000 10,000 12,000 ………. 15,000 จะเห็นว่าข้อมูลของพนักงานแต่ละคนจะมีตัวแปรทั้งหมด 3 ตัวแปร คือ ตัวแปรที่เก็บชื่อพนักงาน ตัวแปรที่เก็บตำแหน่ง และตัวแปรที่เก็บเงินเดือน ตามลำดับ ลักษณะเช่นนี้เราสามารถนำข้อมูลของพนักงานแต่ละคนมาจัดเป็นข้อมูลแบบโครงสร้างได้ดังนี้ ตารางที่ 8.2 แสดงข้อมูลแบบโครงสร้าง ข้อมูล (data) ชื่อตัวแปร (variable name) ชนิดตัวแปร (type of variable) ชื่อพนักงาน ตำแหน่ง เงินเดือน emp_name position salary string string integer(int)

8.2 การประกาศข้อมูลแบบโครงสร้าง (declaration of a structure data type)

สามารถทำได้โดยคำสั่ง struct มาช่วยในการประกาศข้อมูลแบบโครงสร้าง โดยมีรูปแบบการประกาศดังนี้

รูปแบบที่ 1

struct struct_name
{
type1 name1;
type2 name2;
……..
typeN nameN;
} struct_var;

รูปแบบที่ 2

struct struct_name

{
type1 name1;
type2 name2;
……..
typeN nameN;
} ;
struct struct_name struct_var;

โดยที่

struct เป็นคำสั่งที่ใช้ประกาศข้อมูลแบบโครงสร้าง
struct_name เป็นชื่อข้อมูลแบบโครงสร้าง ใช้สำหรับประกาศข้อมูลแบบโครงสร้างกลุ่มอื่นให้มีโครงสร้างเหมือนกลุ่มโครงสร้างที่เคยประกาศไว้แล้ว
struct_var เป็นชื่อตัวแปรโครงสร้างใช้สำหรับอ้างอิงข้อมูลภายในโครงสร้าง
type1 name1, type2 name2,…,typeN nameN เป็นชนิด และชื่อตัวแปรที่ 1, 2, 3, … , N ตามลำดับ บางครั้งอาจจะเรียก name1, name2,…,nameN ว่า element 1, element 2, … , element N ตามลำดับ

ตัวอย่างที่ 8.2 แสดงการประกาศข้อมูลแบบโครงสร้าง
1)

struct employee
{
char emp_name[30];
char position[30];
int salary;
} person;
หรือจะใช้คำสั่งดังนี้
struct employee
{
char emp_name[30];
char position[30];
int salary;
};
struct employee person;

เมื่อใช้คำสั่งประกาศข้อมูลแบบโครงสร้างข้างต้น ภายในหน่วยความจำของเครื่องคอมพิวเตอร์ จะมีการจองเนื้อที่ดังนี้ (ดูรูปที่ 8.1 ประกอบ)

รูปที่ 8.1 แสดงข้อมูลแบบโครงสร้าง employee ภายในหน่วยความจำ

2)

struct y
{
int a;
char b;
float c;
} x;

หรือจะใช้คำสั่งดังนี้

struct y
{
int a;
char b;
float c;
};
struct y x;

เมื่อใช้คำสั่งประกาศข้อมูลแบบโครงสร้างข้างต้นภายในหน่วยความจำของเครื่องคอมพิวเตอร์จะมีการจองเนื้อที่ดังนี้ (ดูรูปที่ 8.2 ประกอบ)

รูปที่ 8.2 แสดงข้อมูลแบบโครงสร้าง y ภายในหน่วยความจำ

8.3 การอ้างอิงตัวแปรภายในข้อมูลแบบโครงสร้าง
(accessing structure members)
การอ้างอิงสมาชิกหรือตัวแปรภายในข้อมูลแบบโครงสร้าง สามารถทำได้โดยเรียกชื่อตัวแปรโครงสร้าง (struct_var) ตามด้วยเครื่องหมาย . (period) จากนั้นก็ตามด้วยชื่อตัวแปรภายในโครงสร้าง (element_name) หรือบางครั้งเรียกว่า member_name
รูปแบบการอ้างอิงตัวแปรภายในโครงสร้าง

struct_var. member_name

เช่น person.emp_name หมายถึง ชื่อพนักงาน
person.position หมายถึง ตำแหน่งของพนักงาน
person.salary หมายถึง เงินเดือนของพนักงาน
x.a, x.b, x.c หมายถึง ตัวแปร a, b และ c ตามลำดับ
(ให้ดูข้อมูลแบบโครงสร้างตัวอย่างที่ 1 และ 2 ที่ผ่านมาประกอบความเข้าใจด้วย)

เพื่อความเข้าใจเกี่ยวกับการประกาศข้อมูลแบบโครงสร้าง และการอ้างอิงสมาชิกภายในมากยิ่งขึ้น ให้ศึกษาจากโปรแกรมตัวอย่างดังต่อไปนี้

โปรแกรมตัวอย่างที่ 8.1 แสดงการประกาศตัวแปรข้อมูลแบบโครงสร้างและการอ้างอิงสมาชิกภายใน แบบที่ 1

/* struct1.c */

#include<stdio.h> /* บรรทัดที่ 1 */
#include<conio.h> /* บรรทัดที่ 2 */
void main(void) /* บรรทัดที่ 3 */
{ /* บรรทัดที่ 4 */
struct record /* บรรทัดที่ 5 */
{ /* บรรทัดที่ 6 */
int i; /* บรรทัดที่ 7 */
char j; /* บรรทัดที่ 8 */
float k; /* บรรทัดที่ 9 */
}; /* บรรทัดที่ 10 */
struct record one,two; /* บรรทัดที่ 11 */
clrscr(); /* บรรทัดที่ 12 */
one.i=7; one.j=’I’; one.k=1.2345; /* บรรทัดที่ 13 */
two.i=4; two.j=’J’; two.k=9.8765; /* บรรทัดที่ 14 */
printf("I = %d, J = %c, K = %.5f\n",one.i,one.j,one.k); /* บรรทัดที่ 15 */
printf("I2 = %d, J2 = %c, K2 = %.5f\n",two.i,two.j,two.k);/* บรรทัดที่ 16 */
printf("\nPress any key back to program…"); /* บรรทัดที่ 17 */
getch(); /* บรรทัดที่ 18 */
} /* บรรทัดที่ 19 */

ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 8.1 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้

บรรทัดที่ 5 ประกาศข้อมูลแบบโครงสร้าง โดยที่ record เป็นชื่อข้อมูลแบบโครงสร้าง
บรรทัดที่ 11 ประกาศตัวแปรโครงสร้างชื่อ one และ two
บรรทัดที่ 13 และ 14 เป็นการอ้างอิงตัวแปรภายในโครงสร้าง
บรรทัดที่ 15 นำค่าตัวแปร i, j, k ภายในโครงสร้าง one แสดงออกที่จอภาพ
บรรทัดที่ 16 นำค่าตัวแปร i, j, k ภายในโครงสร้าง two แสดงออกที่จอภาพ

โปรแกรมตัวอย่างที่ 8.2 แสดงการประกาศตัวแปรข้อมูลแบบโครงสร้างและการอ้างอิงสมาชิกภายใน แบบที่ 2

/* struct2.c */

#include<stdio.h> /* บรรทัดที่ 1 */
#include<conio.h> /* บรรทัดที่ 2 */
void main(void) /* บรรทัดที่ 3 */
{ /* บรรทัดที่ 4 */
struct simple /* บรรทัดที่ 5 */
{ /* บรรทัดที่ 6 */
int num; /* บรรทัดที่ 7 */
char ch; /* บรรทัดที่ 8 */
} a,b; /* บรรทัดที่ 9 */
clrscr(); /* บรรทัดที่ 10 */
a.num = 9; a.ch=’K’; /* บรรทัดที่ 11 */
b.num = a.num+6; b.ch=a.ch – 1; /* บรรทัดที่ 12 */
printf("Number a = %d, Char a = %c\n", a.num, ++a.ch); /* บรรทัดที่ 13 */
printf("Number b = %d, Char b = %c\n", b.num-6, b.ch); /* บรรทัดที่ 14 */
printf("\nPress any key back to program…"); /* บรรทัดที่ 15 */
getch(); /* บรรทัดที่ 16 */
} /* บรรทัดที่ 17 */

ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 8.2 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้

บรรทัดที่ 5 ประกาศข้อมูลแบบโครงสร้าง โดยที่ simple เป็นชื่อข้อมูลแบบโครงสร้าง
บรรทัดที่ 11 และ 12 เป็นการอ้างอิงตัวแปรภายในโครงสร้าง
บรรทัดที่ 13 นำค่าตัวแปร num, ch ภายในโครงสร้าง a แสดงออกที่จอภาพ
บรรทัดที่ 14 นำค่าตัวแปร num, ch ภายในโครงสร้าง b แสดงออกที่จอภาพ

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

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

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

/* ipstruc1.c */

#include <stdio.h> /* gets() in this file */ /* บรรทัดที่ 1 */
#include <stdlib.h> /* atoi(),atof() in this file */ /* บรรทัดที่ 2 */
#include <conio.h> /* บรรทัดที่ 4 */
void main(void) /* บรรทัดที่ 5 */
{ /* บรรทัดที่ 6 */
struct person /* บรรทัดที่ 7 */
{ /* บรรทัดที่ 8 */
char name[20]; /* บรรทัดที่ 9 */
float salary; /* บรรทัดที่ 10 */
int age; /* บรรทัดที่ 11 */
}; /* บรรทัดที่ 12 */
struct person one; /* บรรทัดที่ 13 */
char numstr[81]; /* บรรทัดที่ 14 */
clrscr(); /* บรรทัดที่ 15 */
printf("\n *** Person Data ***\n\n Enter name : "); /* บรรทัดที่ 16 */
gets(one.name); /* บรรทัดที่ 17 */
printf("Enter salary : "); /* บรรทัดที่ 18 */
gets(numstr); /* บรรทัดที่ 19 */
one.salary=atof(numstr); /* บรรทัดที่ 20 */
printf("Enter age : "); /* บรรทัดที่ 21 */
gets(numstr); /* บรรทัดที่ 22 */
one.age=atoi(numstr); /* บรรทัดที่ 23 */
printf("\n\nName = %s\n",one.name); /* บรรทัดที่ 24 */
printf("Salary = %f\n",one.salary); /* บรรทัดที่ 25 */
printf("Age = %d\n",one.age); /* บรรทัดที่ 26 */
printf("\n\nPress any key back to program…"); /* บรรทัดที่ 27 */
getch(); /* บรรทัดที่ 28 */
} /* บรรทัดที่ 29 */

ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 8.3 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้

บรรทัดที่ 7 ประกาศข้อมูลแบบโครงสร้าง โดยที่ person เป็นชื่อข้อมูลแบบโครงสร้าง
บรรทัดที่ 13 ประกาศตัวแปรโครงสร้างชื่อ one
บรรทัดที่ 17 รับข้อมูลที่ผู้ใช้เติมจากคีย์บอร์ด แล้วนำไปเก็บไว้ในตัวแปร name ภายในโครงสร้าง one
บรรทัดที่ 19 และ 20 รับข้อมูลที่ผู้ใช้เติมจากคีย์บอร์ด แล้วนำไปเก็บไว้ในตัวแปร numstr แล้วแปลงค่าที่รับเข้ามาเป็นจำนวนทศนิยม ไปเก็บไว้ในตัวแปร salary ภายในโครงสร้าง one
บรรทัดที่ 22 และ 23 รับข้อมูลที่ผู้ใช้เติมจากคีย์บอร์ด แล้วนำไปเก็บไว้ในตัวแปร numstr แล้วแปลงค่าที่รับเข้ามาเป็นจำนวนเต็ม ไปเก็บไว้ในตัวแปร age ภายในโครงสร้าง one
บรรทัดที่ 24 และ 26 นำค่าตัวแปร name, salary และ age ภายในโครงสร้าง one แสดงออกที่จอภาพ

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

* ipstru2.c */
#include <stdio.h> /* gets() in this file */ /* บรรทัดที่ 1 */
#include <stdlib.h> /* atoi(),atof() in this file */ /* บรรทัดที่ 2 */
#include <conio.h> /* บรรทัดที่ 3 */
void main(void) /* บรรทัดที่ 4 */
{ /* บรรทัดที่ 5 */
struct person /* บรรทัดที่ 6 */
{ /* บรรทัดที่ 7 */
char name[20]; /* บรรทัดที่ 8 */
float salary; /* บรรทัดที่ 9 */
int age; /* บรรทัดที่ 10 */
}; /* บรรทัดที่ 11 */
struct person one ,two; /* บรรทัดที่ 12 */
char numstr[81]; /* บรรทัดที่ 13 */
clrscr(); /* บรรทัดที่ 14 */
printf("\n *** Person Data ***\n\n Enter name : "); /* บรรทัดที่ 15 */
gets(one.name); /* บรรทัดที่ 16 */
printf("Enter salary : "); /* บรรทัดที่ 17 */
gets(numstr); /* บรรทัดที่ 18 */
one.salary=atof(numstr); /* บรรทัดที่ 19 */
printf("Enter age : "); /* บรรทัดที่ 20 */
gets(numstr); /* บรรทัดที่ 21 */
one.age=atoi(numstr); /* บรรทัดที่ 22 */
two = one; /*copy struct one to struct two*/ /* บรรทัดที่ 23 */
printf("\n\nName1 = %s\n",one.name); /* บรรทัดที่ 24 */
printf("Salary1 = %f\n",one.salary); /* บรรทัดที่ 25 */
printf("Age1 = %d\n",one.age); /* บรรทัดที่ 26 */
printf("\n\nName2 = %s\n",two.name); /* บรรทัดที่ 27 */
printf("Salary2 = %f\n",two.salary); /* บรรทัดที่ 28 */
printf("Age2 = %d\n",two.age); /* บรรทัดที่ 29 */
printf("\n\nPress any key back to program…"); /* บรรทัดที่ 30 */
getch(); /* บรรทัดที่ 31 */
} /* บรรทัดที่ 32 */

ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 8.4 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้

บรรทัดที่ 23 สำหรับคำสั่ง two = one; ที่อยู่ในโปรกรม ipstru2.c เป็นคำสั่งให้คัดลอกข้อมูลที่อยู่ในตัวแปรทุกตัวภายในโครงสร้าง one ไปเก็บไว้ในโครงสร้าง two โดยมีค่าข้อมูลเหมือนกันทุกประการ (ดูรูปที่ 8.3 ประกอบความเข้าใจ)

รูปที่ 8.3 แสดงผลการทำงานของคำสั่ง two = one;

8.5 ข้อมูลแบบโครงสร้างซ้อน (nested structures)

บางครั้งเราสามารถประกาศข้อมูลแบบโครงสร้างซ้อนอยู่ภายในโครงสร้างได้ดังโปรแกรมตัวอย่างต่อไปนี้

โปรแกรมตัวอย่างที่ 8.5 แสดงการประกาศข้อมูลแบบโครงสร้างซ้อนอยู่ภายในโครงสร้าง

/* neststru.c */

#include<stdio.h> /* บรรทัดที่ 1 */
#include<conio.h> /* บรรทัดที่ 2 */
struct student /* บรรทัดที่ 3 */
{ /* บรรทัดที่ 4 */
char name[20]; /* บรรทัดที่ 5 */
int age; /* บรรทัดที่ 6 */
}; /* บรรทัดที่ 7 */
struct group /* บรรทัดที่ 8 */
{ /* บรรทัดที่ 9 */
struct student one; /* nested structure one */ /* บรรทัดที่ 10 */
struct student two; /* nested structure two */ /* บรรทัดที่ 11 */
}; /* บรรทัดที่ 12 */

struct group x = { /* บรรทัดที่ 13 */
{"Kannikar",25}, /* บรรทัดที่ 14 */
{"Suraporn",32} /* บรรทัดที่ 15 */
}; /* บรรทัดที่ 16 */
void main(void) /* บรรทัดที่ 17 */
{ /* บรรทัดที่ 18 */
clrscr(); /* บรรทัดที่ 19 */
printf("\n Person One :\n"); /* บรรทัดที่ 20 */
printf("Name = %s\n", x.one.name); /* บรรทัดที่ 21 */
printf("Age = %d\n", x.one.age); /* บรรทัดที่ 22 */
printf("\n Person Two :\n"); /* บรรทัดที่ 23 */
printf("Name = %s\n", x.two.name); /* บรรทัดที่ 24 */
printf("Age = %d\n", x.two.age); /* บรรทัดที่ 25 */
printf("\n\nPress any key back to program…"); /* บรรทัดที่ 26 */
getch(); /* บรรทัดที่ 27*/
} /* บรรทัดที่ 28 */

ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างที่ 8.5 สามารถอธิบายการทำงานของโปรแกรมที่สำคัญ ๆ ได้ดังนี้
การอ้างอิงสมาชิกภายในข้อมูลแบบโครงสร้างซ้อนก็ใช้วิธีการอ้างอิงเหมือนกับข้อมูลแบบโครงสร้างธรรมดา
เช่น บรรทัดที่ 21 x.one.name หมายถึง การอ้างอิงถึงตัวแปร name ผ่านตัวแปรโครงสร้าง one และตัวแปรโครงสร้าง x ตามลำดับ
หรือ บรรทัดที่ 24 x.two.name หมายถึง การอ้างอิงถึงตัวแปร name ผ่านตัวแปรโครงสร้าง two และตัวแปรโครงสร้าง x ตามลำดับ

8.6 ข้อมูลชุดแบบโครงสร้าง (arrays of structures)
บางครั้งเราอาจจะต้องการตัวแปรโครงสร้างจำนวนมากกว่า 1 ตัว เราต้องการเก็บข้อมูลนักศึกษาจำนวน 10 คน หรือข้อมูลหนังสือ 20 เล่มก็สามารถใช้ความรู้เกี่ยวกับ arrays มาช่วยในการจัดการข้อมูลแบบโครงสร้างได้ดังนี้

8.6.1 การประกาศข้อมูลชุดแบบโครงสร้าง
ใช้คำสั่ง struct มาช่วยในการประกาศข้อมูลชุดแบบโครงสร้างโดยมีรูปแบบดังนี้

รูปแบบที่ 1

struct struct_name
{
type1 name1;
type2 name2;
……..
typeN nameN;
} struct_var[n];

รูปแบบที่ 2

struct struct_name
{
type1 name1;
type2 name2;
……..
typeN nameN;
};
struct struct_name struct_var[n];

โดยที่

struct เป็นคำสั่งที่ใช้ประกาศข้อมูลแบบโครงสร้าง
struct_name เป็นชื่อข้อมูลแบบโครงสร้าง ใช้สำหรับประกาศข้อมูลแบบโครงสร้างกลุ่มอื่นให้มีโครงสร้างเหมือนกลุ่มโครงสร้างที่เคยประกาศไว้แล้ว
struct_var เป็นชื่อตัวแปรโครงสร้างใช้สำหรับอ้างอิงข้อมูลภายใน โครงสร้าง
type1 name1, type2 name2, …., typeN nameN เป็นชนิดและชื่อตัวแปรตัวที่ 1, 2, 3, …, N ตามลำดับ บางครั้งอาจจะเรียก name1, name2, … nameN ว่า element 1 , element 2, … element N ตามลำดับ
n คือ ขนาดของตัวแปรชุดแบบโครงสร้าง มีค่าเริ่มต้นที่ 0,1, 2, …, n-1

ตัวอย่างที่ 8.3 แสดงการประกาศตัวแปรชุดแบบโครงสร้าง

เมื่อใช้คำสั่งประกาศข้างต้นภายในหน่วยความจำจะมีการจองเนื้อที่สำหรับข้อมูลชุดแบบโครงสร้าง employee[0],…, employee[9] ดังนี้ (ดูรูปที่ 8.4 ประกอบความเข้าใจ)

name salary age
employee[0] 25 bytes 4 bytes 2 bytes
employee[1] 25 bytes 4 bytes 2 bytes
…………….. ………… ……….. ………..
employee[9] 25 bytes 4 bytes 2 bytes

รูปที่ 8.4 แสดงการจองเนื้อที่ภายในหน่วยความจำให้กับตัวแปรชุดแบบโครงสร้าง

8.6.2 การอ้างอิงตัวแปรที่อยู่ภายในข้อมูลชุดแบบโครงสร้าง

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

struct_var[n].member_var

โดยที่

n คือขนาดของตัวแปรชุดแบบโครงสร้าง มีค่าตั้งแต่ 0,1, 2, …,n-1

ตัวอย่างที่ 8.4 ถ้าอ้างอิงว่า employee[3].salary หมายถึง เงินเดือนของพนักงานคนที่ 4

ตัวอย่างที่ 8.5 ถ้าอ้างอิงว่า employee[7].name หมายถึง ชื่อของพนักงานคนที่ 8

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

รูปแบบอ้างอิงโดยมีการกำหนดค่าให้ตัวแปร

struct_var[n].member_var = value;

โดยที่บางครั้งจะใช้ฟังก์ชัน strcpy (s2,s1) มาช่วยในการกำหนดค่าข้อมูลที่เป็นข้อความ

เช่น employee[0].age = 20;
strcpy(employee[0].name, “Kannikar”);

เพื่อความเข้าใจเกี่ยวกับการใช้งานตัวแปรชุดแบบโครงสร้างมากยิ่งขึ้น ให้ศึกษาจากโปรแกรมตัวอย่างดังต่อไปนี้

โปรแกรมตัวอย่างที่ 8.6 แสดงการใช้ตัวแปรชุดแบบโครงสร้าง

/* arrstru.c */

#include<stdio.h> /* printf(), getche(), gets() in this file */ /* บรรทัดที่ 1 */
#include<stdlib.h> /* atoi(), atof(), tolower() in this file */ /* บรรทัดที่ 2 */
#include<ctype.h> /* บรรทัดที่ 4 */
void newname(void); /* functions prototype of newname() */ /* บรรทัดที่ 5 */
void listall(void); /* functions prototype of listall() */ /* บรรทัดที่ 6 */
struct person /* บรรทัดที่ 7 */
{ /* บรรทัดที่ 8 */
char name[30]; /* บรรทัดที่ 9 */
int age; /* บรรทัดที่ 10 */
float salary; /* บรรทัดที่ 11 */
}; /* บรรทัดที่ 12 */
struct person employee[50]; /* array of 50 structures */ /* บรรทัดที่ 13 */
int n=0; /* บรรทัดที่ 14 */
void main(void) /* บรรทัดที่ 15 */
{ /* บรรทัดที่ 16 */
char ch; /* บรรทัดที่ 17 */
do { /* บรรทัดที่ 18 */
clrscr( ); /* บรรทัดที่ 19 */
printf(" ****************************\n"); /* บรรทัดที่ 20 */
printf(" * Main Menu *\n"); /* บรรทัดที่ 21 */
printf(" ****************************\n"); /* บรรทัดที่ 22 */
printf(" 1. Create a new employee\n"); /* บรรทัดที่ 23 */
printf(" 2. Display All employees\n"); /* บรรทัดที่ 24 */
printf(" 3. Exit Program\n\n"); /* บรรทัดที่ 25 */
printf(" Enter your choice ( 1 or 2 or 3 ) : "); /* บรรทัดที่ 26 */
ch=getche(); /* บรรทัดที่ 27 */
switch(tolower(ch)) /* บรรทัดที่ 28 */
{ /* บรรทัดที่ 29 */
case ‘1’: /* บรรทัดที่ 30 */
newname(); break; /* บรรทัดที่ 31 */
case ‘2’: /* บรรทัดที่ 32 */
listall(); break; /* บรรทัดที่ 33 */
case ‘3’: /* บรรทัดที่ 34 */
printf("\nExit Program."); exit(0); /* บรรทัดที่ 35 */
default: /* บรรทัดที่ 36 */
printf("\n Choice Error ! Please choice agian"); /* บรรทัดที่ 37 */
} /* บรรทัดที่ 38 */
}while(ch!=’3′); /* บรรทัดที่ 39 */
}/* end main */ /* บรรทัดที่ 40 */
/* newname() */ /* บรรทัดที่ 41 */
void newname() /* บรรทัดที่ 42 */
{ /* บรรทัดที่ 43 */
char numstr[81]; /* บรรทัดที่ 44 */
printf("\n Record %d.\n Enter name:", n+1); /* บรรทัดที่ 45 */
gets(employee[n].name); /* บรรทัดที่ 46 */
printf("Enter age :"); /* บรรทัดที่ 47 */
gets(numstr); /* บรรทัดที่ 48 */
employee[n].age = atoi(numstr); /* บรรทัดที่ 49 */
printf("Enter salary :"); /* บรรทัดที่ 50 */
gets(numstr); /* บรรทัดที่ 51 */
employee[n].salary = atof(numstr); /* บรรทัดที่ 52 */
n++; /* บรรทัดที่ 53 */
} /* บรรทัดที่ 54 */
/* listall() */ /* บรรทัดที่ 55 */
void listall() /* บรรทัดที่ 56 */
{ int j; /* บรรทัดที่ 57 */
if (n<1) printf("\n Empty list.\n"); /* บรรทัดที่ 58 */
for(j=0; j<n; j++) { /* บรรทัดที่ 59 */
printf("\n Record number %d\n", j+1); /* บรรทัดที่ 60 */
printf("Name : %s\n", employee[j].name); /* บรรทัดที่ 61 */
printf("Age : %d\n", employee[j].age); /* บรรทัดที่ 62 */
printf("Salary : %.2f\n", employee[j].salary); /* บรรทัดที่ 63 */
} /* บรรทัดที่ 64 */
getch(); /* บรรทัดที่ 65 */
} /* บรรทัดที่ 66 */

ผลลัพธ์ที่ได้จากโปรแกรม

กรณีเลือกตัวเลือกที่ 1 จะให้เติมข้อมูลลูกจ้าง

กรณีเลือกตัวเลือกที่ 2 จะนำข้อมูลลูกจ้างที่เติม ออกมาแสดง

กรณีเลือกตัวเลือกที่ 3 ออกจากโปรแกรม

8.7 พอยน์เตอร์กับข้อมูลแบบโครงสร้าง (pointer and structures)

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

รูปแบบการใช้พอยน์เตอร์อ้างอิงตัวแปรภายในข้อมูลแบบโครงสร้าง

(*ptr_name).member_var
หรือ
ptr_name->member_var

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

โปรแกรมตัวอย่างที่ 8.7 แสดงการใช้พอยน์เตอร์อ้างอิงตัวแปรภายในข้อมูลแบบโครงสร้าง

/* ptrstru.c */

#include<stdio.h> /* บรรทัดที่ 1 */
#include<conio.h> /* บรรทัดที่ 2 */
void main(void) /* บรรทัดที่ 3 */
{ /* บรรทัดที่ 4 */
struct x /* บรรทัดที่ 5 */
{ /* บรรทัดที่ 6 */
int num; /* บรรทัดที่ 7 */
char ch; /* บรรทัดที่ 8 */
}; /* บรรทัดที่ 9 */
struct x one; /* บรรทัดที่ 10 */
struct x *ptr; /* define pointer to structure */ /* บรรทัดที่ 11 */
clrscr(); /* บรรทัดที่ 12 */
ptr = &one; /* assign address of struc to ptr */ /* บรรทัดที่ 13 */
ptr->num = 230; /* or ptr.num = 230 */ /* บรรทัดที่ 14 */
ptr->ch = ‘K’; /* or ptr.ch = ‘K’ */ /* บรรทัดที่ 15 */
printf("\nNumber = %d\n",ptr->num); /* บรรทัดที่ 16 */
printf("Char = %c", ptr->ch); /* บรรทัดที่ 17 */
printf("\n\nPress any key back to program…"); /* บรรทัดที่ 18 */
getch(); /* บรรทัดที่ 19 */
} /* บรรทัดที่ 20 */

ผลลัพธ์ที่ได้จากโปรแกรม

8.8 ข้อมูลแบบยูเนียน (unions)

8.8.1 ความหมายและลักษณะของข้อมูลแบบยูเนียน

ยูเนียน คือ ข้อมูลแบบหนึ่งที่สามารถกำหนดให้ตัวแปรต่างชนิดกัน ใช้เนื้อที่ในหน่วยความจำของเครื่องร่วมกันได้ ทำให้การใช้เนื้อที่ภายในหน่วยความจำลดลง
เช่น สมมติว่าเรามีตัวแปรอยู่ 3 ตัว คือตัวแปร a, b และ c ตามลำดับ โดยที่ตัวแปร a เป็นชนิด integer, ตัวแปร b เป็นชนิด floating point และตัวแปร c เป็นชนิด single character และเราต้องการให้ตัวแปร a, b และ c ใช้เนื้อที่ภายในหน่วยความจำร่วมกัน

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

union {
int a;
float b;
char c;
} ShareArea;

8.8.2 การประกาศข้อมูลแบบยูเนียน
(declaration of an unions data type)
สามารถทำได้โดยใช้คำสั่ง union มาช่วยในการประกาศข้อมูลแบบยูเนียน โดยมีรูปแบบการประกาศดังนี้

รูปแบบที่ 1

union union_name
{
type1 name1;
type2 name2;
………
typeN nameN;
} union_var;

รูปแบบที่ 2

union union_name
{
type1 name1;
type2 name2;
………
typeN nameN;
};
union union_name union_var;

โดยที่

union เป็นคำสั่งที่ใช้ประกาศข้อมูลแบบยูเนียน
union_name เป็นชื่อข้อมูลแบบยูเนียน ใช้สำหรับการประกาศข้อมูลแบบยูเนียนกลุ่มอื่นให้มีโครงสร้างเหมือนกลุ่มยูเนียนที่เคยประกาศไว้แล้ว
union_var เป็นชื่อตัวแปรยูเนียนใช้สำหรับการอ้างอิงภายในยูเนียน
type1 name1, type2 name2,…, typeN nameN เป็นชนิดและชื่อตัวแปรตัวที่ 1, 2, 3, …, N ตามลำดับ บางครั้งอาจจะเรียก name1, name2,…, nameN ว่า element 1, element2, …, element N ตามลำดับ

ตัวอย่างที่ 8.6 แสดงการประกาศข้อมูลแบบยูเนียน

union same
{
int j;
char ch;
float a;
} one;

หรือใช้คำสั่ง

union same
{
int j;
char ch;
float a;
} ;
union same one;

เมื่อใช้คำสั่งประกาศข้อมูลแบบยูเนียนข้างต้น ภายในหน่วยความจำจะมีลักษณะการจองเนื้อที่ไว้ดังนี้

รูปที่ 8.5 แสดงการจองเนื้อที่ภายในหน่วยความจำของข้อมูลแบบยูเนียนชื่อ same

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

8.8.3 การอ้างอิงตัวแปรภายในข้อมูลแบบยูเนียน
(accessing union members)
การอ้างอิงสมาชิกหรือตัวแปรภายในข้อมูลแบบยูเนียน สามารถทำได้โดยเรียกชื่อตัวแปรยูเนียน (union_var) ตามด้วยเครื่องหมาย . (period) จากนั้นก็ตามด้วยชื่อตัวแปรภายในยูเนียน (element_name หรือ member_name) ซึ่งมีลักษณะการอ้างอิงทำนองเดียวกันกับข้อมูลแบบโครงสร้าง

รูปแบบการอ้างอิงตัวแปรภายในยูเนียน

union_var.member_name

เช่น จากตัวอย่างการประกาศยูเนียนที่ผ่านมา ถ้าต้องการอ้างอิงภายในยูเนียนสามารถ ทำได้ดังนี้
same.a หมายถึง ตัวแปร a ที่อยู่ในยูเนียน same
same.ch หมายถึง ตัวแปร ch ที่อยู่ในยูเนียน same
same.j หมายถึง ตัวแปร j ที่อยู่ในยูเนียน same
เพื่อความเข้าใจในการใช้ยูเนียนมากยิ่งขึ้น ให้ศึกษาจากโปรแกรมตัวอย่าง ดังต่อไปนี้

โปรแกรมตัวอย่างที่ 8.8 แสดงการใช้ยูเนียน

/* union1.c */

#include<stdio.h> /* บรรทัดที่ 1 */
#include<conio.h> /* บรรทัดที่ 2 */
void main(void) /* บรรทัดที่ 3 */
{ /* บรรทัดที่ 4 */
union intflo /* บรรทัดที่ 5 */
{ /* บรรทัดที่ 6 */
int num; /* บรรทัดที่ 7 */
float f; /* บรรทัดที่ 8 */
} unsame; /* บรรทัดที่ 9 */
clrscr(); /* บรรทัดที่ 10 */
printf("Size of union intflo = %d\n", sizeof(union intflo)); /* บรรทัดที่ 11 */
unsame.num = 25; /* บรรทัดที่ 12 */
printf("Number = %d\n", unsame.num); /* บรรทัดที่ 13 */
unsame.f = 1.2345; /* บรรทัดที่ 14 */
printf("F = %.4f\n", unsame.f); /* บรรทัดที่ 15 */
printf("\n\nPress any key back to program…"); /* บรรทัดที่ 16 */
getch(); /* บรรทัดที่ 17 */
} /* บรรทัดที่ 18 */

ผลลัพธ์ที่ได้จากโปรแกรม

คำอธิบายโปรแกรม
จากโปรแกรมตัวอย่างข้างต้น เพื่อความเข้าใจเกี่ยวกับข้อมูลแบบ union มากขึ้น (ดูรูปที่ 8.6 ประกอบความเข้าใจ)
unsame เป็นตัวแปรยูเนียน

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

โปรแกรมตัวอย่างที่ 8.9 แสดงการใช้ยูเนียน

/* union2.c */

#include<stdio.h> /* บรรทัดที่ 1 */
#include<conio.h> /* บรรทัดที่ 2 */
void main(void) /* บรรทัดที่ 3 */
{ /* บรรทัดที่ 4 */
struct twointeger /* บรรทัดที่ 5 */
{ /* บรรทัดที่ 6 */
int num1; /* บรรทัดที่ 7 */
int num2; /* บรรทัดที่ 8 */
} us; /* บรรทัดที่ 9 */
union intflo /* บรรทัดที่ 10 */
{ /* บรรทัดที่ 11 */
int num3; /* บรรทัดที่ 12 */
float f; /* บรรทัดที่ 13 */
} unsame; /* บรรทัดที่ 14 */
clrscr( ); /* บรรทัดที่ 15 */
printf("Size of Structure twointeger = %d\n", sizeof(struct twointeger)); /* บ. 16 */
us.num1 = 25; /* บรรทัดที่ 17 */
printf("Number1 = %d\n", us.num1); /* บรรทัดที่ 18 */
us.num2 = 70; /* บรรทัดที่ 19 */
printf("Number2 = %d\n", us.num2); /* บรรทัดที่ 20 */
printf("\nSize of Union intflo = %d\n", sizeof(union intflo)); /* บรรทัดที่ 21 */
unsame.num3 = 55; /* บรรทัดที่ 22 */
printf("Number3 = %d\n", unsame.num3); /* บรรทัดที่ 23 */
unsame.f = 9.8765; /* บรรทัดที่ 24 */
printf("F = %.4f\n", unsame.f); /* บรรทัดที่ 25 */
printf("\n\nPress any key back to program…"); /* บรรทัดที่ 26 */
getch(); /* บรรทัดที่ 27 */
} /* บรรทัดที่ 28 */

ผลลัพธ์ที่ได้จากโปรแกรม

8.8.4 ข้อควรระวังในการใช้ยูเนียน

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

.9 สรุปท้ายบท

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

การประกาศข้อมูลแบบโครงสร้าง (declaration of a structure data type)
สามารถทำได้โดยคำสั่ง struct มาช่วยในการประกาศข้อมูลแบบโครงสร้าง โดยมีรูปแบบการประกาศดังนี้

รูปแบบที่ 1

struct struct_name
{
type1 name1;
type2 name2;
……..
typeN nameN;
} struct_var;

รูปแบบที่ 2

struct struct_name

{
type1 name1;
type2 name2;
……..
typeN nameN;
} ;
struct struct_name struct_var;

โดยที่

struct เป็นคำสั่งที่ใช้ประกาศข้อมูลแบบโครงสร้าง
struct_name เป็นชื่อข้อมูลแบบโครงสร้าง ใช้สำหรับประกาศข้อมูลแบบโครงสร้างกลุ่มอื่นให้มีโครงสร้างเหมือนกลุ่มโครงสร้างที่เคยประกาศไว้แล้ว
struct_var เป็นชื่อตัวแปรโครงสร้างใช้สำหรับอ้างอิงข้อมูลภายในโครงสร้าง
type1 name1, type2 name2,…,typeN nameN เป็นชนิด และชื่อตัวแปรที่ 1, 2, 3, … , N ตามลำดับ บางครั้งอาจจะเรียก name1, name2,…,nameN ว่า element 1, element 2, … , element N ตามลำดับ

การอ้างอิงตัวแปรภายในข้อมูลแบบโครงสร้าง (accessing structure members)
การอ้างอิงสมาชิกหรือตัวแปรภายในข้อมูลแบบโครงสร้าง สามารถทำได้โดยเรียกชื่อตัวแปรโครงสร้าง (struct_var) ตามด้วยเครื่องหมาย . (period) จากนั้นก็ตามด้วยชื่อตัวแปรภายในโครงสร้าง (element_name) หรือบางครั้งเรียกว่า member_name
รูปแบบการอ้างอิงตัวแปรภายในโครงสร้าง

struct_var. member_name

ข้อมูลชุดแบบโครงสร้าง (arrays of structures) บางครั้งเราอาจจะต้องการตัวแปรโครงสร้างจำนวนมากกว่า 1 ตัว เราต้องการเก็บข้อมูลนักศึกษาจำนวน 10 คน หรือข้อมูลหนังสือ 20 เล่ม ก็สามารถใช้ความรู้เกี่ยวกับ arrays มาช่วยในการจัดการข้อมูลแบบโครงสร้างได้ดังนี้

การประกาศข้อมูลชุดแบบโครงสร้าง
ใช้คำสั่ง struct มาช่วยในการประกาศข้อมูลชุดแบบโครงสร้างโดยมีรูปแบบดังนี้

รูปแบบที่ 1

struct struct_name
{
type1 name1;
type2 name2;
……..
typeN nameN;
} struct_var[n];

รูปแบบที่ 2

struct struct_name
{
type1 name1;
type2 name2;
……..
typeN nameN;
};
struct struct_name struct_var[n];

โดยที่

struct เป็นคำสั่งที่ใช้ประกาศข้อมูลแบบโครงสร้าง
struct_name เป็นชื่อข้อมูลแบบโครงสร้าง ใช้สำหรับประกาศข้อมูลแบบโครงสร้างกลุ่มอื่นให้มีโครงสร้างเหมือนกลุ่มโครงสร้างที่เคยประกาศไว้แล้ว
struct_var เป็นชื่อตัวแปรโครงสร้างใช้สำหรับอ้างอิงข้อมูลภายใน โครงสร้าง
type1 name1, type2 name2, …., typeN nameN เป็นชนิดและชื่อตัวแปรตัวที่ 1, 2, 3, …, N ตามลำดับ บางครั้งอาจจะเรียก name1, name2, … nameN ว่า element 1 , element 2, … element N ตามลำดับ
n คือ ขนาดของตัวแปรชุดแบบโครงสร้าง มีค่าเริ่มต้นที่ 0,1, 2, …, n-1

การอ้างอิงตัวแปรที่อยู่ภายในข้อมูลชุดแบบโครงสร้าง

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

struct_var[n].member_var

โดยที่

n คือขนาดของตัวแปรชุดแบบโครงสร้าง มีค่าตั้งแต่ 0,1, 2, …,n-1

พอยน์เตอร์กับข้อมูลแบบโครงสร้าง (pointer and structures) เรื่องนี้จะมีประโยชน์มากเมื่อต้องการทำโครงสร้างข้อมูลแบบ linked list และ tree แบบต่าง ๆ การใช้พอยน์เตอร์อ้างอิงตัวแปรภายในข้อมูลแบบโครงสร้าง สามารถทำได้ดังนี้

รูปแบบการใช้พอยน์เตอร์อ้างอิงตัวแปรภายในข้อมูลแบบโครงสร้าง

(*ptr_name).member_var
หรือ
ptr_name->member_var

ข้อมูลแบบยูเนียน (unions)

ความหมายและลักษณะของข้อมูลแบบยูเนียน

ยูเนียน คือ ข้อมูลแบบหนึ่งที่สามารถกำหนดให้ตัวแปรต่างชนิดกัน ใช้เนื้อที่ในหน่วยความจำของเครื่องร่วมกันได้ ทำให้การใช้เนื้อที่ภายในหน่วยความจำลดลง
เช่น สมมติว่าเรามีตัวแปรอยู่ 3 ตัว คือตัวแปร a, b และ c ตามลำดับ โดยที่ตัวแปร a เป็นชนิด integer, ตัวแปร b เป็นชนิด floating point และตัวแปร c เป็นชนิด single character และเราต้องการให้ตัวแปร a, b และ c ใช้เนื้อที่ภายในหน่วยความจำร่วมกัน

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

union {
int a;
float b;
char c;
} ShareArea;

การประกาศข้อมูลแบบยูเนียน (declaration of an unions data type)
สามารถทำได้โดยใช้คำสั่ง union มาช่วยในการประกาศข้อมูลแบบยูเนียน โดยมีรูปแบบการประกาศดังนี้

รูปแบบที่ 1

union union_name
{
type1 name1;
type2 name2;
………
typeN nameN;
} union_var;

รูปแบบที่ 2

union union_name
{
type1 name1;
type2 name2;
………
typeN nameN;
};
union union_name union_var;

โดยที่

union เป็นคำสั่งที่ใช้ประกาศข้อมูลแบบยูเนียน
union_name เป็นชื่อข้อมูลแบบยูเนียน ใช้สำหรับการประกาศข้อมูลแบบยูเนียนกลุ่มอื่นให้มีโครงสร้างเหมือนกลุ่มยูเนียนที่เคยประกาศไว้แล้ว
union_var เป็นชื่อตัวแปรยูเนียนใช้สำหรับการอ้างอิงภายในยูเนียน
type1 name1, type2 name2,…, typeN nameN เป็นชนิดและชื่อตัวแปรตัวที่ 1, 2, 3, …, N ตามลำดับ บางครั้งอาจจะเรียก name1, name2,…, nameN ว่า element 1, element2, …, element N ตามลำดับ

การอ้างอิงตัวแปรภายในข้อมูลแบบยูเนียน (accessing union members)
การอ้างอิงสมาชิกหรือตัวแปรภายในข้อมูลแบบยูเนียน สามารถทำได้โดยเรียกชื่อตัวแปรยูเนียน (union_var) ตามด้วยเครื่องหมาย . (period) จากนั้นก็ตามด้วยชื่อตัวแปรภายในยูเนียน (element_name หรือ member_name) ซึ่งมีลักษณะการอ้างอิงทำนองเดียวกันกับข้อมูลแบบโครงสร้าง

รูปแบบการอ้างอิงตัวแปรภายในยูเนียน

union_var.member_name

อ้างอิง

http://e-learning.snru.ac.th/els/program1/lesson1/page1.html

ประเภทของโครงงานคอมพิวเตอร์

ประเภทของโครงงานคอมพิวเตอร์

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

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

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

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

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

ความหมายและคุณค่าของโครงงานคอมพิวเตอร์

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

1. สังคมโดยส่วนใหญ่เปลี่ยนจากสังคมอุตสาหกรรมเป็นสังคมสารสนเทศ

2. การตัดสินใจในเรื่องต่างๆ มักขึ้นอยู่กับข้อมูลซึ่งได้จากระบบคอมพิวเตอร์

3. คอมพิวเตอร์กลายเป็นเครื่องมือที่สำคัญแทนเครื่องมืออื่นๆ ในอดีต เช่น เครื่องพิมพ์ดีด เครื่องคิดเลข เป็นต้น

4. คอมพิวเตอร์ถูกใช้ในการออกแบบสถานการณ์หรือปัญหาที่ซับซ้อนต่างๆ

5. คอมพิวเตอร์เป็นอุปกรณ์หลักที่ใช้ในงานติดต่อสื่อสารของโลกปัจจุบัน

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

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

กิจกรรมที่จัดว่าเป็นโครงงานคอมพิวเตอร์ควรมีองค์ประกอบหลักดังต่อไปนี้

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

-เปิดโอกาสให้ผู้เรียนได้พัฒนาและแสดงความสามารถตามศักยภาพของตนเอง

-เปิดโอกาสให้ผู้เรียนได้ศึกษา ค้นคว้า และเรียนรู้ในเรื่องที่ผู้เรียนสนใจได้ลึกซึ้งกว่าการเรียนในห้องตามปกติ

-ส่งเสริมและพัฒนากระบวนการคิด การแก้ปัญหา การตัดสินใจ รวมทั้งการสื่อสารระหว่างกัน

-กระตุ้นให้ผู้เรียนมีความสนใจในการศึกษาด้านเทคโนโลยีสารสนเทศ และมีความสนใจที่จะประกอบอาชีพทางด้านนี้

-ส่งเสริมให้ผู้เรียนได้ใช้เวลาให้เป็นประโยชน์ในทางสร้างสรรค์

-สร้างความสัมพันธ์ระหว่างผู้เรียนกับผู้สอนและชุมชน รวมทั้งส่งเสริมให้ชุมชนสนใจคอมพิวเตอร์และเทคโนโลยีที่เกี่ยวข้องมากขึ้น

-สร้างสำนึกและความรับผิดชอบในการศึกษาและพัฒนาระบบด้วยตนเอง

Hello world!

Welcome to WordPress.com. After you read this, you should delete and write your own post, with a new title above. Or hit Add New on the left (of the admin dashboard) to start a fresh post.

Here are some suggestions for your first post.

1. You can find new ideas for what to blog about by reading the Daily Post.
2. Add PressThis to your browser. It creates a new blog post for you about any interesting  page you read on the web.
3. Make some changes to this page, and then hit preview on the right. You can always preview any post or edit it before you share it to the world.