C++ โครงสร้างพร้อมตัวอย่าง

ตัวอย่างเช่น:

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

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

เมื่อใดจึงควรใช้โครงสร้าง?

นี่คือเหตุผลบางประการในการใช้โครงสร้างมา C++.

• ใช้โครงสร้างเมื่อคุณต้องการจัดเก็บองค์ประกอบของข้อมูลประเภทต่างๆ ไว้ภายใต้ประเภทข้อมูลเดียว
• C++ structs เป็นประเภทค่าแทนที่จะเป็นประเภทอ้างอิง ใช้โครงสร้างหากคุณไม่ต้องการแก้ไขข้อมูลของคุณหลังจากการสร้าง

C++ การเริ่มต้นโครงสร้าง

เพื่อสร้าง C++ โครงสร้าง เราใช้คีย์เวิร์ด struct ตามด้วยตัวระบุ ตัวระบุจะกลายเป็นชื่อของโครงสร้าง นี่คือไวยากรณ์สำหรับการสร้าง C++ โครงสร้าง:

ไวยากรณ์:

struct struct_name  
{  
     // struct members
}   

ในรูปแบบข้างต้น เราได้ใช้คีย์เวิร์ด struct struct_name คือชื่อของโครงสร้าง

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

ตัวอย่างเช่น:

struct Person  
{  
    char name[30];  
     int citizenship;  
     int age;  
}  

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

การสร้างอินสแตนซ์โครงสร้าง

ในตัวอย่างข้างต้น เราได้สร้างโครงสร้างชื่อบุคคล เราสามารถสร้างตัวแปร struct ได้ดังนี้:

Person p;

p เป็นตัวแปรโครงสร้างประเภทบุคคล เราสามารถใช้ตัวแปรนี้เพื่อเข้าถึงสมาชิกของโครงสร้างได้

การเข้าถึงสมาชิกโครงสร้าง

ในการเข้าถึงสมาชิกโครงสร้าง เราใช้อินสแตนซ์ของโครงสร้างและตัวดำเนินการจุด (.) ตัวอย่างเช่น ในการเข้าถึงอายุของสมาชิกโครงสร้าง Person:

p.age = 27;

เราได้เข้าถึงอายุสมาชิกของ struct Person โดยใช้อินสแตนซ์ของ struct, p. จากนั้นเราได้กำหนดค่าอายุของสมาชิกเป็น 27 ปี

1 ตัวอย่าง:

#include <iostream>    
using namespace std;
struct Person
{
	int citizenship;
	int age;
};
int main(void) {
	struct Person p;
	p.citizenship = 1;
	p.age = 27;
	cout << "Person citizenship: " << p.citizenship << endl;
	cout << "Person age: " << p.age << endl;

	return 0;
}

Output:

นี่คือภาพหน้าจอของรหัส:

คำอธิบายรหัส:

1. รวมไฟล์ส่วนหัว iostream ไว้ในโปรแกรมของเราเพื่อใช้ฟังก์ชันที่กำหนดไว้
2. รวมเนมสเปซมาตรฐานเพื่อใช้คลาสโดยไม่ต้องเรียกมัน
3. สร้างโครงสร้างชื่อบุคคล
4. จุดเริ่มต้นของโครงสร้างร่างกาย
5. สร้างสมาชิก struct ชื่อความเป็นพลเมืองประเภทจำนวนเต็ม
6. สร้างสมาชิก struct ชื่ออายุประเภทจำนวนเต็ม
7. ส่วนท้ายของตัวโครงสร้าง
8. เรียกใช้ฟังก์ชัน main() ควรเพิ่มตรรกะของโปรแกรมภายในเนื้อหาของฟังก์ชันนี้
9. สร้างอินสแตนซ์ของ struct Person และตั้งชื่อให้ p
10. ตั้งค่าความเป็นพลเมืองของสมาชิก struct เป็น 1
11. ตั้งค่าอายุของสมาชิก struct เป็น 27
12. พิมพ์ค่าความเป็นพลเมืองของสมาชิก struct บนคอนโซลควบคู่ไปกับข้อความอื่นๆ
13. พิมพ์ค่าของอายุสมาชิก struct บนคอนโซลควบคู่ไปกับข้อความอื่นๆ
14. โปรแกรมควรส่งคืนค่าหากทำงานได้สำเร็จ
15. จุดสิ้นสุดของฟังก์ชัน main()

ตัวชี้ไปยังโครงสร้าง

เป็นไปได้ที่จะสร้างตัวชี้ที่ชี้ไปยังโครงสร้าง ซึ่งคล้ายกับวิธีการสร้างตัวชี้ที่ชี้ไปยังชนิดข้อมูลดั้งเดิม เช่น int, float, double เป็นต้น โปรดทราบว่าตัวชี้ใน C++ จะเก็บตำแหน่งหน่วยความจำ

2 ตัวอย่าง:

#include <iostream>
using namespace std;

struct Length
{
	int meters;
	float centimeters;
};

int main()
{
	Length *ptr, l;

	ptr = &l;

	cout << "Enter meters: ";
	cin >> (*ptr).meters;
	cout << "Enter centimeters: ";
	cin >> (*ptr).centimeters;
	cout << "Length = " << (*ptr).meters << " meters " << (*ptr).centimeters << " centimeters";

	return 0;
}

Output:

นี่คือภาพหน้าจอของรหัส:

คำอธิบายรหัส:

1. รวมไฟล์ส่วนหัว iostream ไว้ในโปรแกรมของเราเพื่อใช้ฟังก์ชันต่างๆ
2. รวมเนมสเปซมาตรฐานในโปรแกรมของเราเพื่อใช้คลาสโดยไม่ต้องเรียกมัน
3. สร้างโครงสร้างชื่อความยาว
4. จุดเริ่มต้นของตัวโครงสร้างความยาว
5. สร้างสมาชิก struct ชื่อเมตรของชนิดข้อมูลจำนวนเต็ม
6. สร้างสมาชิก struct ชื่อเซนติเมตรชนิดจำนวนเต็ม
7. ส่วนปลายของโครงสร้างความยาว
8. เรียกใช้ฟังก์ชัน main()
9. จุดเริ่มต้นของฟังก์ชัน main()
10. สร้างตัวแปรตัวชี้ *ptr และตัวแปรปกติ l ประเภทความยาว
11. เก็บที่อยู่ของตัวแปร l ไว้ในของเรา ตัวแปรตัวชี้.
12. แสดงข้อความบนคอนโซลโดยขอให้ผู้ใช้ป้อนค่ามิเตอร์ตัวแปร
13. อ่านค่าที่ผู้ใช้ป้อนผ่านแป้นพิมพ์ เข้าถึงมิเตอร์ฟังก์ชันสมาชิกได้ที่นี่โดยใช้ตัวแปรพอยน์เตอร์
14. แสดงข้อความบนคอนโซลโดยขอให้ผู้ใช้ป้อนค่าสำหรับตัวแปรเซนติเมตร
15. อ่านค่าที่ผู้ใช้ป้อนผ่านแป้นพิมพ์ หน่วยเซนติเมตรของฟังก์ชันสมาชิกเข้าถึงได้โดยใช้ตัวแปรพอยน์เตอร์
16. แสดงค่าที่อ่านจากผู้ใช้บนคอนโซลควบคู่ไปกับข้อความอื่นๆ
17. โปรแกรมจะต้องคืนค่าเมื่อดำเนินการสำเร็จ
18. ส่วนท้ายของฟังก์ชัน main()

โครงสร้างเป็นอาร์กิวเมนต์ของฟังก์ชัน

คุณสามารถส่งผ่านโครงสร้างไปยังฟังก์ชันเป็นอาร์กิวเมนต์ได้ สิ่งนี้ทำในลักษณะเดียวกับการโต้แย้งปกติ ตัวแปร struct ยังสามารถส่งผ่านไปยังฟังก์ชันได้ ตัวอย่างที่ดีคือเมื่อคุณต้องการแสดงค่าของสมาชิก struct มาสาธิตสิ่งนี้กัน:

3 ตัวอย่าง:

#include<iostream>
using namespace std;

struct Person
{
	int citizenship;
	int age;
};

void func(struct Person p);

int main()
{
	struct Person p;

	p.citizenship = 1;
	p.age = 27;

	func(p);
	return 0;
}
void func(struct Person p)
{
	cout << " Person citizenship: " << p.citizenship<<endl;
	cout << " Person age: " << p.age;
}

Output:

นี่คือภาพหน้าจอของรหัส:

คำอธิบายรหัส:

1. รวมไฟล์ส่วนหัว iostream ลงในไฟล์ของเรา จากนั้นเราจะใช้ฟังก์ชันของมันโดยไม่ได้รับข้อผิดพลาด
2. รวมเนมสเปซมาตรฐานในโปรแกรมของเราเพื่อใช้คลาสของมัน เราไม่จำเป็นต้องเรียกเนมสเปซเพื่อใช้คลาสของมัน
3. สร้างโครงสร้างชื่อบุคคล
4. จุดเริ่มต้นของเนื้อความของโครงสร้างบุคคล
5. สร้างสมาชิกของ struct Person สมาชิกมีชื่อว่าความเป็นพลเมืองและเป็นประเภทจำนวนเต็ม
6. สร้างสมาชิกของ struct Person สมาชิกชื่ออายุและเป็นประเภทจำนวนเต็ม
7. ส่วนท้ายของโครงสร้างบุคคล
8. สร้างฟังก์ชันที่รับอินสแตนซ์ของ struct Person, p เป็นอาร์กิวเมนต์
9. เรียกใช้ฟังก์ชันหลัก { เป็นจุดเริ่มต้นของส่วนเนื้อหาของฟังก์ชัน main()
10. สร้างอินสแตนซ์ของ struct Person และตั้งชื่อให้ p
11. เข้าถึงความเป็นพลเมืองตัวแปรของสมาชิก struct โดยใช้อินสแตนซ์ของ struct, p และกำหนดค่า 1
12. เข้าถึงอายุตัวแปรของสมาชิก struct โดยใช้อินสแตนซ์ของ struct, p และกำหนดค่า 27
13. เรียกใช้ฟังก์ชันและส่งผ่านไปยังอินสแตนซ์ของ struct Person, p ซึ่งเป็นอาร์กิวเมนต์
14. ฟังก์ชันจะต้องคืนค่าเมื่อดำเนินการสำเร็จ
15. ส่วนท้ายของฟังก์ชัน main()
16. สร้างเนื้อความของฟังก์ชัน
17. จุดเริ่มต้นของเนื้อความของฟังก์ชัน
18. เข้าถึงค่าความเป็นพลเมืองของสมาชิก struct และพิมพ์บนคอนโซลควบคู่ไปกับข้อความอื่น
19. เข้าถึงค่าอายุของสมาชิก struct และพิมพ์บนคอนโซลควบคู่ไปกับข้อความอื่น
20. จุดสิ้นสุดของเนื้อหาฟังก์ชัน

ข้อจำกัดของก C++ โครงสร้าง

ข้อจำกัดของโครงสร้างมีดังนี้:

• ประเภทข้อมูล struct ไม่สามารถถือเป็นประเภทข้อมูลในตัวได้
• OperaTor เช่น + - และอื่นๆ ไม่สามารถใช้กับได้ ตัวแปรโครงสร้าง.
• โครงสร้างไม่รองรับการซ่อนข้อมูล สมาชิกของโครงสร้างสามารถเข้าถึงได้โดยฟังก์ชันใดๆ โดยไม่คำนึงถึงขอบเขต
• ไม่สามารถประกาศสมาชิกแบบคงที่ภายในเนื้อหาโครงสร้างได้
• ไม่สามารถสร้างตัวสร้างภายในโครงสร้างได้

สรุป

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