C++ คลาสและวัตถุพร้อมตัวอย่าง
คลาสคืออะไร?
A C++ คลาสรวมข้อมูลและวิธีการจัดการข้อมูลให้เป็นหนึ่งเดียว ชั้นเรียนยังกำหนดรูปแบบของวัตถุอีกด้วย ข้อมูลและวิธีการที่มีอยู่ในชั้นเรียนเรียกว่าสมาชิกของชั้นเรียน คลาสเป็นประเภทข้อมูลที่ผู้ใช้กำหนด ในการเข้าถึงสมาชิกชั้นเรียน เราใช้อินสแตนซ์ของชั้นเรียน คุณสามารถเห็นคลาสเป็นแบบพิมพ์เขียวสำหรับออบเจ็กต์ได้
คลาสจะเป็นต้นแบบของบ้าน โดยจะแสดงตำแหน่งและขนาดของประตู หน้าต่าง พื้น ฯลฯ จากคำอธิบายเหล่านี้ เราสามารถสร้างบ้านได้ โดยบ้านจะกลายเป็นวัตถุ สามารถสร้างบ้านได้หลายหลังจากต้นแบบ นอกจากนี้ยังสามารถสร้างวัตถุได้หลายรายการจากคลาสอีกด้วย
ในรูปด้านบน เรามีแบบบ้านเดี่ยว จากต้นแบบนี้ เราได้สร้างบ้านสองหลังที่มีคุณสมบัติที่แตกต่างกัน
ประกาศชั้นเรียน
ใน C+ คลาสถูกกำหนดโดยใช้คีย์เวิร์ด class ควรตามด้วยชื่อคลาส จากนั้นเพิ่มเนื้อหาของคลาสระหว่างเครื่องหมายปีกกา { }
วากยสัมพันธ์
class class-name { // data // functions };
- ชื่อคลาสคือชื่อที่จะกำหนดให้กับชั้นเรียน
- data คือข้อมูลสำหรับคลาส ซึ่งปกติจะประกาศเป็นตัวแปร
- ฟังก์ชันคือฟังก์ชันของคลาส
คำหลักส่วนตัวและสาธารณะ
คุณต้องเจอคำหลักทั้งสองนี้ พวกมันเป็นตัวดัดแปลงการเข้าถึง
- ส่วนตัว:
เมื่อใช้คีย์เวิร์ดส่วนตัวเพื่อกำหนดฟังก์ชันหรือคลาส คำสำคัญจะกลายเป็นคีย์เวิร์ดส่วนตัว สามารถเข้าถึงได้จากภายในชั้นเรียนเท่านั้น
- สาธารณะ:
ในทางกลับกัน คีย์เวิร์ดสาธารณะจะทำให้ข้อมูล/ฟังก์ชันเป็นแบบสาธารณะ สิ่งเหล่านี้สามารถเข้าถึงได้จากนอกชั้นเรียน
นิยามวัตถุ
วัตถุถูกสร้างขึ้นจากคลาส คลาสอ็อบเจ็กต์ถูกประกาศในลักษณะเดียวกับการประกาศตัวแปร ชื่อคลาสต้องเริ่มต้น ตามด้วยชื่ออ็อบเจ็กต์ วัตถุประเภทชั้นเรียน
วากยสัมพันธ์
class-name object-name;
- ชื่อคลาสคือชื่อของคลาสที่จะสร้างวัตถุ
- ชื่อวัตถุคือชื่อที่จะกำหนดให้กับวัตถุใหม่
กระบวนการสร้างวัตถุจากคลาสนี้เรียกว่าการสร้างอินสแตนซ์
การเข้าถึงข้อมูลสมาชิก
ในการเข้าถึงสมาชิกสาธารณะของคลาส เราใช้ตัวดำเนินการ (.)dot สมาชิกเหล่านี้ถูกทำเครื่องหมายด้วยตัวปรับแต่งการเข้าถึงสาธารณะ
1 ตัวอย่าง
#include <iostream> using namespace std; class Phone { public: double cost; int slots; }; int main() { Phone Y6; Phone Y7; Y6.cost = 100.0; Y6.slots = 2; Y7.cost = 200.0; Y7.slots = 2; cout << "Cost of Huawei Y6 : " << Y6.cost << endl; cout << "Cost of Huawei Y7 : " << Y7.cost << endl; cout << "Number of card slots for Huawei Y6 : " << Y6.slots << endl; cout << "Number of card slots for Huawei Y7 : " << Y7.slots << endl; return 0; }
Output:
นี่คือภาพหน้าจอของรหัส:
คำอธิบายรหัส:
- รวมไฟล์ส่วนหัว iostream ไว้ในโค้ดของเราเพื่อใช้ฟังก์ชันต่างๆ
- รวมเนมสเปซมาตรฐานไว้ในโค้ดของเราเพื่อใช้คลาสโดยไม่ต้องเรียกมัน
- ประกาศคลาสชื่อ Phone
- การใช้ตัวแก้ไขการเข้าถึงสาธารณะเพื่อทำเครื่องหมายตัวแปรที่เรากำลังจะสร้างว่าเข้าถึงได้แบบสาธารณะ
- ประกาศต้นทุนตัวแปรของชนิดข้อมูล double
- ประกาศตัวแปรจำนวนเต็มชื่อสล็อต
- จุดสิ้นสุดของเนื้อหาชั้นเรียน
- การเรียกใช้ฟังก์ชัน main() ควรเพิ่มตรรกะของโปรแกรมภายในเนื้อหา
- สร้างวัตถุชื่อ Y6 ประเภท Phone สิ่งนี้เรียกว่าการสร้างอินสแตนซ์
- สร้างวัตถุชื่อ Y7 ประเภท Phone สิ่งนี้เรียกว่าการสร้างอินสแตนซ์
- เข้าถึงต้นทุนตัวแปร/สมาชิกของคลาส Phone โดยใช้อ็อบเจ็กต์ Y6 ค่านี้ตั้งไว้ที่ 100.0 ตอนนี้ราคาของ Y6 ตั้งไว้ที่ 100.0
- เข้าถึงสล็อตตัวแปร/สมาชิกของคลาส Phone โดยใช้อ็อบเจ็กต์ Y6 ค่านี้ตั้งไว้ที่ 2 ช่องสำหรับ Y6 ตอนนี้ตั้งเป็น 2
- เข้าถึงต้นทุนตัวแปร/สมาชิกของคลาส Phone โดยใช้อ็อบเจ็กต์ Y7 ค่านี้ตั้งไว้ที่ 200.0 ตอนนี้ราคาของ Y7 ตั้งไว้ที่ 200.0
- เข้าถึงสล็อตตัวแปร/สมาชิกของคลาส Phone โดยใช้อ็อบเจ็กต์ Y7 ค่านี้ตั้งไว้ที่ 2 ช่องสำหรับ Y7 ตอนนี้ตั้งเป็น 2
- พิมพ์ราคา Y6 บนคอนโซลพร้อมกับข้อความอื่นๆ
- พิมพ์ราคา Y7 บนคอนโซลพร้อมกับข้อความอื่นๆ
- พิมพ์จำนวนช่องสำหรับ Y6 ควบคู่ไปกับข้อความอื่น
- พิมพ์จำนวนช่องสำหรับ Y7 ควบคู่ไปกับข้อความอื่น
- โปรแกรมจะต้องส่งคืนค่าเมื่อดำเนินการเสร็จสิ้น
- ส่วนท้ายของฟังก์ชัน main()
ชั้นเรียนส่วนตัวคืออะไร?
สมาชิกคลาสที่ทำเครื่องหมายว่าเป็นส่วนตัวสามารถเข้าถึงได้โดยฟังก์ชันที่กำหนดไว้ภายในคลาสเท่านั้น วัตถุหรือฟังก์ชันใด ๆ ที่กำหนดไว้นอกคลาสไม่สามารถเข้าถึงสมาชิกดังกล่าวได้โดยตรง สมาชิกคลาสส่วนตัวสามารถเข้าถึงได้โดยฟังก์ชันสมาชิกและเพื่อนเท่านั้น
คลาสที่ได้รับการคุ้มครองคืออะไร?
สมาชิกชั้นเรียนที่ทำเครื่องหมายว่าได้รับการคุ้มครองจะมีข้อได้เปรียบเหนือสมาชิกชั้นเรียนที่ทำเครื่องหมายว่าเป็นส่วนตัว สามารถเข้าถึงได้โดยฟังก์ชันภายในคลาสของคำจำกัดความ นอกจากนี้ยังสามารถเข้าถึงได้จากคลาสที่ได้รับ
2 ตัวอย่าง
#include <iostream> using namespace std; class ClassA { public: void set_a(int val); int get_a(void); private: int a; }; int ClassA::get_a(void) { return a; } void ClassA::set_a(int val) { a = val; } int main() { ClassA a; a.set_a(20); cout << "Value of a is: " << a.get_a(); return 0; }
Output:
นี่คือภาพหน้าจอของรหัส:
คำอธิบายรหัส:
- รวมไฟล์ส่วนหัว iostream ไว้ในโค้ดของเราเพื่อใช้ฟังก์ชันต่างๆ
- รวมเนมสเปซมาตรฐานไว้ในโค้ดของเราเพื่อใช้คลาสโดยไม่ต้องเรียกมัน
- สร้างคลาสชื่อ ClassA
- ใช้ตัวแก้ไขการเข้าถึงสาธารณะเพื่อทำเครื่องหมายสมาชิกชั้นเรียนที่จะสร้างให้เข้าถึงได้แบบสาธารณะ
- สร้างฟังก์ชันชื่อ set_a() ที่รับค่า val จำนวนเต็มหนึ่งค่า
- สร้างฟังก์ชันชื่อ get_a()
- ใช้ตัวแก้ไขการเข้าถึงส่วนตัวเพื่อทำเครื่องหมายสมาชิกคลาสที่จะสร้างว่าสามารถเข้าถึงได้แบบส่วนตัว
- ประกาศตัวแปรจำนวนเต็มชื่อ a
- จุดสิ้นสุดของเนื้อหาชั้นเรียน
- ใช้ชื่อคลาสและตัวดำเนินการการแก้ไขขอบเขตเพื่อเข้าถึงฟังก์ชัน get_a() เราต้องการกำหนดว่าฟังก์ชันทำอะไรเมื่อเรียกใช้
- ฟังก์ชัน get_a() ควรส่งคืนค่าของตัวแปร a เมื่อถูกเรียกใช้
- สิ้นสุดคำจำกัดความของฟังก์ชัน get_a()
- ใช้ชื่อคลาสและตัวดำเนินการการแก้ไขขอบเขตเพื่อเข้าถึงฟังก์ชัน set_a() เราต้องการกำหนดว่าฟังก์ชันทำอะไรเมื่อเรียกใช้
- การกำหนดค่าของตัวแปร val ให้กับตัวแปร a
- สิ้นสุดคำจำกัดความของฟังก์ชัน set_a()
- เรียกใช้ฟังก์ชัน main() ควรเพิ่มตรรกะของโปรแกรมภายในเนื้อหาของฟังก์ชันนี้
- สร้างอินสแตนซ์ของ ClassA และตั้งชื่อให้ว่า a
- ใช้อินสแตนซ์คลาสด้านบนและฟังก์ชัน set_a() เพื่อกำหนดค่า 20 ให้กับตัวแปร a
- พิมพ์ข้อความข้างค่าของตัวแปร a บนคอนโซล ค่าของตัวแปร a ได้มาจากการเรียกใช้ฟังก์ชัน get_a()
- โปรแกรมจะต้องคืนค่าเมื่อเสร็จสิ้นสำเร็จ
- ส่วนท้ายของฟังก์ชัน main()
3 ตัวอย่าง
#include <iostream> using namespace std; class ParentClass { protected: int value; }; class ChildClass : public ParentClass { public: void setId(int x) { value = x; } void displayValue() { cout << "Value is: " << value << endl; } }; int main() { ChildClass c; c.setId(21); c.displayValue(); return 0; }
Output:
นี่คือภาพหน้าจอของรหัส:
คำอธิบายรหัส:
- รวมไฟล์ส่วนหัว iostream ไว้ในโค้ดของเราเพื่อใช้ฟังก์ชันต่างๆ
- รวมเนมสเปซมาตรฐานไว้ในโค้ดของเราเพื่อใช้คลาสโดยไม่ต้องเรียกมัน
- สร้างคลาสชื่อ ParentClass
- ใช้ตัวแก้ไขการเข้าถึงที่ได้รับการป้องกันเพื่อทำเครื่องหมายสมาชิกคลาสที่จะสร้างว่าได้รับการป้องกัน
- สร้างตัวแปรชื่อค่าจำนวนเต็ม
- จุดสิ้นสุดของเนื้อหาชั้นเรียน
- สร้างคลาสใหม่ชื่อ ChildClass ที่สืบทอด ParentClass
- ใช้ตัวแก้ไขการเข้าถึงที่ได้รับการป้องกันเพื่อทำเครื่องหมายสมาชิกคลาสที่จะสร้างให้เข้าถึงได้ในคลาสย่อย
- สร้างฟังก์ชันชื่อ setId() ซึ่งรับค่าจำนวนเต็ม x หนึ่งค่า
- การกำหนดค่าของตัวแปร x ให้กับค่าตัวแปร
- สิ้นสุดคำจำกัดความของฟังก์ชัน setId()
- สร้างฟังก์ชันชื่อ displayValue()
- พิมพ์ค่าของตัวแปรที่ระบุชื่อค่าบนคอนโซลควบคู่ไปกับข้อความอื่น
- ส่วนท้ายของฟังก์ชัน displayValue()
- ส่วนท้ายของคลาสชื่อ ChildClass
- เรียกใช้ฟังก์ชัน main() ควรเพิ่มตรรกะของโปรแกรมภายในเนื้อหาของฟังก์ชันนี้
- สร้างอินสแตนซ์ของ ChildClass และตั้งชื่อให้ว่า c
- ใช้อินสแตนซ์คลาสด้านบนและฟังก์ชัน setId() เพื่อกำหนดค่า 21 ให้กับตัวแปร x
- ใช้อินสแตนซ์คลาสข้างต้นเพื่อเรียกใช้ฟังก์ชันชื่อ displayValue()
- โปรแกรมจะต้องคืนค่าเมื่อเสร็จสิ้นสำเร็จ
- ส่วนท้ายของฟังก์ชัน main()
ฟังก์ชั่นสมาชิกชั้นเรียน
ฟังก์ชันช่วยให้เราจัดการข้อมูลได้ ฟังก์ชันสมาชิกของคลาสสามารถกำหนดได้สองวิธี:
- ภายในคำจำกัดความของชั้นเรียน
- นอกคำจำกัดความของชั้นเรียน
หากต้องกำหนดฟังก์ชันภายนอกคำจำกัดความของคลาส เราต้องใช้ตัวดำเนินการการแก้ไขขอบเขต (::) โดยควรมาพร้อมกับชื่อคลาสและฟังก์ชัน
2 ตัวอย่าง
#include <iostream> #include <string> using namespace std; class Guru99 { public: string tutorial_name; int id; void printname(); void printid() { cout << "Tutorial id is: "<< id; } }; void Guru99::printname() { cout << "Tutorial name is: " << tutorial_name; } int main() { Guru99 guru99; guru99.tutorial_name = "C++"; guru99.id = 1001; guru99.printname(); cout << endl; guru99.printid(); return 0; }
Output:
นี่คือภาพหน้าจอของรหัส:
คำอธิบายรหัส:
- รวมไฟล์ส่วนหัว iostream ไว้ในโปรแกรมของเราเพื่อใช้ฟังก์ชันต่างๆ
- รวมไฟล์ส่วนหัวของสตริงในโปรแกรมของเราเพื่อใช้ฟังก์ชันต่างๆ
- รวมเนมสเปซมาตรฐานไว้ในโค้ดของเราเพื่อใช้คลาสโดยไม่ต้องเรียกมัน
- สร้างคลาสชื่อ Guru99
- ใช้ตัวแก้ไขการเข้าถึงสาธารณะเพื่อทำเครื่องหมายสมาชิกชั้นเรียนที่เรากำลังจะสร้างว่าเข้าถึงได้แบบสาธารณะ
- สร้างตัวแปรสตริงชื่อ Tutorial_name
- สร้างตัวแปรจำนวนเต็มชื่อ id
- สร้างฟังก์ชันชื่อ printname() ฟังก์ชันนี้ไม่ได้ถูกกำหนดไว้ภายในคำจำกัดความของคลาส
- สร้างฟังก์ชันชื่อ print() ฟังก์ชันนี้ถูกกำหนดไว้ภายในคำจำกัดความของคลาส เนื้อความของมันถูกเพิ่มเข้าไปในคำจำกัดความของคลาส
- พิมพ์ค่าของตัวแปร id ควบคู่ไปกับข้อความอื่นๆ บนคอนโซล โปรดทราบว่าสิ่งนี้ได้ถูกเพิ่มเข้าไปในเนื้อหาของฟังก์ชัน printid() มันจะถูกดำเนินการเมื่อมีการเรียกใช้ฟังก์ชัน printid() เท่านั้น
- ส่วนท้ายของฟังก์ชัน printid()
- จบเนื้อหาคลาส Guru99
- จุดเริ่มต้นของคำจำกัดความของฟังก์ชัน printname()
- พิมพ์ค่าของตัวแปร Tutorial_name บนคอนโซลควบคู่ไปกับข้อความอื่นๆ โปรดทราบว่าสิ่งนี้ได้ถูกเพิ่มเข้าไปในเนื้อหาของฟังก์ชัน printname() มันจะถูกดำเนินการเมื่อมีการเรียกใช้ฟังก์ชัน printname() เท่านั้น
- สิ้นสุดคำจำกัดความของฟังก์ชัน printname()
- เรียกใช้ฟังก์ชัน main() ควรเพิ่มตรรกะของโปรแกรมภายในเนื้อหาของฟังก์ชันนี้
- สร้างอินสแตนซ์ของคลาส Guru99 และตั้งชื่อให้ว่า guru99
- ใช้ตัวอย่างข้างต้นเพื่อกำหนดค่าเป็น C++ ไปที่ตัวแปร Tutorial_name
- ใช้อินสแตนซ์ guru99 เพื่อกำหนดค่า 1001 ให้กับรหัสตัวแปร
- ใช้อินสแตนซ์ guru99 เพื่อเรียกใช้ฟังก์ชัน printname()
- เรียกคำสั่ง end (end line) เพื่อพิมพ์บรรทัดว่างใหม่บนคอนโซล
- ใช้อินสแตนซ์ guru99 เพื่อเรียกใช้ฟังก์ชัน printid()
- โปรแกรมจะต้องคืนค่าเมื่อเสร็จสิ้นสำเร็จ
- ส่วนท้ายของฟังก์ชัน main()
ตัวสร้างและผู้ทำลาย
คอนสตรัคเตอร์คืออะไร?
โครงสร้างเป็นฟังก์ชันพิเศษที่เริ่มต้นวัตถุ ที่ C++ คอมไพเลอร์ เรียก Constructor เมื่อสร้างวัตถุ ตัวสร้างช่วยในการกำหนดค่าให้กับสมาชิกชั้นเรียน แน่นอนว่านี่เป็นหลังจากที่จัดสรรพื้นที่หน่วยความจำบางส่วนแล้ว
Destructors คืออะไร?
ในทางกลับกัน Destructors ช่วยในการทำลายวัตถุของคลาส
ชื่อ Constructor ต้องคล้ายกับชื่อคลาส ตัวสร้างไม่มีประเภทการส่งคืน
ตัวสร้างสามารถกำหนดได้ภายในหรือภายนอกตัวคลาส หากกำหนดไว้ภายนอกตัวคลาส ควรกำหนดด้วยชื่อคลาสและตัวดำเนินการแก้ไขขอบเขต (::)
3 ตัวอย่าง
#include <iostream> using namespace std; class ClassA { public: ClassA() { cout << "Class constructor called"<<endl; } ~ClassA() { cout << "Class destructor called"<<endl; } }; int main() { ClassA a; int p = 1; if (p) { ClassA b; } }
Output:
นี่คือภาพหน้าจอของรหัส:
คำอธิบายรหัส:
- รวมไฟล์ส่วนหัว iostream ลงในโค้ดเพื่อใช้ฟังก์ชันต่างๆ
- รวมเนมสเปซมาตรฐานไว้ในโค้ดของเราเพื่อใช้คลาสโดยไม่ต้องเรียกมัน
- สร้างคลาสชื่อ ClassA
- ใช้ตัวแก้ไขการเข้าถึงสาธารณะเพื่อทำเครื่องหมายสมาชิกที่เรากำลังจะสร้างว่าเข้าถึงได้แบบสาธารณะ
- สร้าง Constructor สำหรับชั้นเรียน
- ข้อความที่จะพิมพ์บนคอนโซลเมื่อมีการเรียกตัวสร้าง จุดสิ้นสุดคือ a C++ คำสำคัญซึ่งหมายถึงบรรทัดสิ้นสุด มันเลื่อนเคอร์เซอร์ของเมาส์ไปที่บรรทัดถัดไป
- ส่วนท้ายของตัวสร้างคลาส
- สร้างตัวทำลายล้างสำหรับชั้นเรียน
- ข้อความที่จะพิมพ์บนคอนโซลเมื่อมีการเรียก destructor จุดสิ้นสุดคือ a C++ คำสำคัญซึ่งหมายถึงบรรทัดสิ้นสุด มันเลื่อนเคอร์เซอร์ของเมาส์ไปที่บรรทัดถัดไป
- ส่วนปลายของตัวผู้ทำลายล้าง
- จุดสิ้นสุดของเนื้อหาชั้นเรียน
- เรียกใช้ฟังก์ชัน main() ควรเพิ่มตรรกะของโปรแกรมภายในเนื้อหาของฟังก์ชันนี้
- สร้างคลาสอ็อบเจ็กต์และตั้งชื่อให้กับมันว่า a ตัวสร้างจะถูกเรียก
- สร้างตัวแปรจำนวนเต็มชื่อ p และกำหนดค่าเป็น 1
- สร้างบล็อกคำสั่ง if โดยใช้ตัวแปร p
- สร้างคลาสอ็อบเจ็กต์และตั้งชื่อให้ว่า b ผู้ทำลายล้างจะถูกเรียก
- ส่วนท้ายของคำสั่ง if
- ส่วนท้ายของฟังก์ชัน main()
สรุป
- C++ เป็นแบบเชิงวัตถุ
- ชั้นเรียนเป็นคุณสมบัติหลักของ C++ ที่ทำให้เป็นแบบเชิงวัตถุ
- A C++ คลาสรวมข้อมูลและวิธีการจัดการข้อมูลให้เป็นหนึ่งเดียว
- คลาสคือพิมพ์เขียวสำหรับวัตถุ
- คลาสกำหนดรูปแบบของวัตถุ
- ข้อมูลและวิธีการที่มีอยู่ในชั้นเรียนเรียกว่าสมาชิกของชั้นเรียน
- ในการเข้าถึงสมาชิกชั้นเรียน คุณควรใช้อินสแตนซ์ของชั้นเรียน
- ในการสร้างคลาส เราใช้คีย์เวิร์ด class
- ฟังก์ชั่นสมาชิกชั้นเรียนสามารถกำหนดภายในหรือภายนอกชั้นเรียน