ฟังก์ชั่นสมาชิกแบบคงที่ใน C++ (ตัวอย่าง)

ฟังก์ชันคงที่คืออะไร C++?

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

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

เหตุใดจึงต้องใช้ฟังก์ชันคงที่

แตกต่าง C++ ฟังก์ชันโกลบอล ฟังก์ชันสแตติกสามารถเข้าถึงได้จากไฟล์การประกาศเท่านั้น หากจำเป็นต้องจำกัดการเข้าถึงฟังก์ชัน ให้ทำให้เป็นฟังก์ชันคงที่

ใช้ฟังก์ชันคงที่เพื่อจำกัดการใช้ชื่อฟังก์ชันเดียวกันซ้ำในไฟล์อื่น

การกำหนดฟังก์ชันคงที่ใน C++

ไวยากรณ์:

static int myfunc(void)
{
    cout("Example of C++ static function ");
}

ในตัวอย่างข้างต้น เรากำลังกำหนดฟังก์ชันคงที่ชื่อ myfunc สังเกตการใช้คำหลักแบบคงที่ในคำจำกัดความ คำหลักอยู่หน้าชื่อฟังก์ชัน

ฟังก์ชั่นสมาชิกแบบคงที่ใน C++

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

ในการเข้าถึงชื่อคลาส คุณควรใช้ชื่อของคลาสและตัวดำเนินการแก้ไขขอบเขต (::)- ฟังก์ชันแบบคงที่สามารถเข้าถึงฟังก์ชันแบบคงที่อื่นๆ สมาชิกข้อมูลแบบคงที่ และฟังก์ชันอื่นๆ ภายนอกคลาสเท่านั้น ขอบเขตของฟังก์ชันสมาชิกแบบคงที่อยู่ภายในคลาส และไม่สามารถเข้าถึงตัวชี้คลาสนี้ได้

1 ตัวอย่าง

#include<iostream>
using namespace std;
class BoxClass {
public:
	static int count;
	BoxClass(double l = 2.0, double b = 2.0, double h = 2.0) {
		cout << "Class constructor called." << endl;
		length = l;
		breadth = b;
		height = h;
		count++;
	}
	double getVolume() {
		return length * breadth * height;
	}
	static int getCount() {
		return count;
	}
private:
	double length;     
	double breadth;    
	double height;     
};
int BoxClass::count = 0;
int main(void) {
	cout << "Inital value of count is : " << BoxClass::getCount() << endl;
	BoxClass Box1(3.2, 1.4, 1.8);    
	BoxClass Box2(7.5, 4.0, 4.0);   
	cout << "Final value of count is : " << BoxClass::getCount() << endl;
	return 0;
}

Output:

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

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

1. รวมถึงไฟล์ส่วนหัว iostream ในของเรา C++ โปรแกรมที่จะใช้มัน ฟังก์ชั่น.
2. รวมเนมสเปซมาตรฐานในโค้ดเพื่อใช้คลาสโดยไม่ต้องเรียกมัน
3. สร้างคลาสชื่อ Boxชั้น
4. ใช้ตัวแก้ไขการเข้าถึงสาธารณะเพื่อทำเครื่องหมายสมาชิกของคลาสที่สามารถเข้าถึงได้โดยสาธารณะ
5. ประกาศสมาชิกคลาสแบบคงที่ชื่อนับ
6. ใช้ตัวสร้างคลาสเพื่อเริ่มต้นตัวแปรสามตัวที่มีประเภท double
7. พิมพ์ข้อความบนคอนโซล ฟังก์ชั่น endl (end line) เลื่อนเคอร์เซอร์ของเมาส์ไปยังบรรทัดถัดไป
8. เริ่มต้นค่าของ l ให้มีความยาวผันแปรได้
9. เริ่มต้นค่าของ b เป็นความกว้างของตัวแปร
10. กำหนดค่าเริ่มต้นของ h เป็นความสูงที่แปรผันได้
11. จากนั้นเพิ่มค่าของจำนวนตัวแปรทีละ 1 ทุกครั้งที่สร้างออบเจ็กต์ใหม่
12. จุดสิ้นสุดของตัวสร้าง
13. สร้างฟังก์ชันชื่อ doublevolume()
14. กำหนดว่าฟังก์ชัน doubleVolume() จะส่งคืนอะไร โดยควรส่งคืนตัวแปรคูณความยาว ความกว้าง และความสูง
15. จุดสิ้นสุดของฟังก์ชัน doubleVolume()
16. ประกาศฟังก์ชันคงที่ชื่อ getCount()
17. ฟังก์ชัน getCount() ควรส่งคืนค่าของตัวแปรนับ
18. ส่วนท้ายของฟังก์ชัน getCount()
19. ใช้ตัวแก้ไขการเข้าถึงส่วนตัวเพื่อทำเครื่องหมายสมาชิกชั้นเรียนว่าเข้าถึงได้แบบสาธารณะ
20. การประกาศสมาชิกคลาสที่ชื่อความยาวเป็นชนิดข้อมูลแบบ double ซึ่งจะสามารถเข้าถึงได้แบบส่วนตัว
21. ประกาศคลาสเมมเบอร์อีกตัวชื่อ width ของชนิดข้อมูล double ซึ่งจะสามารถเข้าถึงได้แบบส่วนตัว
22. ประกาศสมาชิกคลาสชื่อ height ของชนิดข้อมูล double ซึ่งจะสามารถเข้าถึงได้แบบส่วนตัว
23. ส่วนปลายของลำตัว Boxคลาสเรียน.
24. จากนั้นเตรียมใช้งานสมาชิกแบบคงที่ของ Boxคลาสเรียน.
25. การเรียกใช้ฟังก์ชัน main() ที่ C++ ควรเพิ่มตรรกะของโปรแกรมภายในเนื้อหาของฟังก์ชันนั้น
26. พิมพ์ข้อความบนคอนโซลโดยระบุจำนวนวัตถุปัจจุบันก่อนที่จะสร้างวัตถุใหม่
27. ประกาศวัตถุชื่อ Box1 ซึ่งเป็นตัวอย่างหนึ่งของชั้นเรียน Boxระดับ. ควรระบุค่าความกว้าง ความยาว และความสูงภายในวงเล็บ
28. ประกาศวัตถุชื่อ Box2 ซึ่งเป็นตัวอย่างของชั้นเรียน Boxระดับ. มีการระบุค่าความกว้าง ความยาว และความสูงไว้ในวงเล็บ
29. พิมพ์ข้อความบนคอนโซลโดยระบุจำนวนอ็อบเจ็กต์ปัจจุบันหลังจากการสร้างอ็อบเจ็กต์ใหม่
30. รางวัล C++ โครงการ ต้องส่งคืนค่าเมื่อดำเนินการเสร็จสิ้น
31. ส่วนท้ายของฟังก์ชัน main()

การเข้าถึงฟังก์ชันแบบคงที่

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

ไวยากรณ์:

className::funcName

ด้านบน className คือชื่อของคลาสที่มีการกำหนดฟังก์ชันคงที่ funcName คือชื่อที่กำหนดให้กับฟังก์ชันคงที่

2 ตัวอย่าง

#include<iostream> 
using namespace std;
class MyClass {
public:
	static void msgFunc() {
		cout << "Welcome to Guru99!";
	}
};
int main() {
	MyClass::msgFunc();
}

Output:

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

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

1. รวมไฟล์ส่วนหัว iostream ไว้ในโปรแกรมของเราเพื่อใช้ฟังก์ชันต่างๆ
2. รวมเนมสเปซมาตรฐานในโค้ดของคุณเพื่อใช้คลาสโดยไม่ต้องเรียกมัน
3. สร้างคลาสชื่อ MyClass
4. ใช้ตัวแก้ไขการเข้าถึงสาธารณะเพื่อทำเครื่องหมายสมาชิกชั้นเรียนว่าเข้าถึงได้แบบสาธารณะ
5. การประกาศฟังก์ชันคงที่ชื่อ msgFunc() คำหลักแบบคงที่ทำให้ฟังก์ชันคงที่
6. ระบุข้อความที่จะพิมพ์บนคอนโซลเมื่อมีการเรียกใช้/เรียกใช้ฟังก์ชันข้างต้น
7. ส่วนท้ายของฟังก์ชัน msgFunc()
8. จบเนื้อหาของชั้นเรียน
9. การเรียกใช้ฟังก์ชัน main()
10. เรียกใช้ฟังก์ชันคงที่ชื่อ msgFunc()
11. ส่วนท้ายของฟังก์ชัน main()

การเข้าถึงตัวแปรแบบคงที่

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

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

ตัวอย่างที่ 3: ตัวแปรคงที่ใน C++ ชั้น

#include<iostream> 
using namespace std;
class AClass {
private:
	static int myvar;
public:
	static int getVar() { 
		return myvar; 
		} 
};
int AClass::myvar = 23; 
int main() {
	cout <<"The value of myvar is: "<< AClass::getVar() << '\n';
}

Output:

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

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

1. รวมถึงไฟล์ส่วนหัว iostream ในโปรแกรมของเราด้วย
2. รวมเนมสเปซมาตรฐานในโปรแกรมนี้เพื่อใช้คลาสโดยไม่ต้องโทร
3. สร้างคลาสชื่อ AClass
4. ใช้ตัวแก้ไขการเข้าถึงส่วนตัวเพื่อทำให้ตัวแปร myvar สามารถเข้าถึงได้แบบส่วนตัว
5. สร้างตัวแปรจำนวนเต็มคงที่ชื่อ myvar
6. ใช้ตัวแก้ไขการเข้าถึงสาธารณะซึ่งทำเครื่องหมายฟังก์ชัน getVar() ว่าสามารถเข้าถึงได้โดยสาธารณะ
7. การสร้างฟังก์ชันคงที่ชื่อ getVar()
8. ฟังก์ชัน getVar() ควรสามารถคืนค่าของตัวแปร myvar ได้
9. ส่วนท้ายของฟังก์ชัน getVar()
10. ส่วนท้ายของคลาส AClass
11. กำหนดค่าตัวแปร myvar เป็น 23 เราได้ใช้ชื่อคลาสและตัวดำเนินการการแก้ไขขอบเขตสำหรับสิ่งนี้
12. การเรียกใช้ฟังก์ชัน main()
13. พิมพ์ค่าของตัวแปร myVar บนคอนโซลพร้อมกับข้อความอื่นๆ เราได้ใช้ชื่อคลาส ฟังก์ชันคงที่ และตัวดำเนินการแก้ไขขอบเขตเพื่อเข้าถึงค่าของตัวแปรนี้
14. ส่วนท้ายของส่วนฟังก์ชัน main()

ตัวชี้นี้ในฟังก์ชันแบบคงที่

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

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

4 ตัวอย่าง

เป็นไปได้ที่จะกำหนดฟังก์ชันคงที่นอกการประกาศคลาส ให้เราสาธิตสิ่งนี้:

#include<iostream> 
using namespace std;
class NumGenerator {
private:
	static int nextNum; 
public:
	static int getNextNum();
};
int NumGenerator::nextNum = 1;
int NumGenerator::getNextNum() {
	return nextNum++; 
}
int main() {
	for (int count = 0; count < 5; ++count)
		std::cout << "The next number is: " << NumGenerator::getNextNum() << '\n';
	return 0;
}

Output:

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

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

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

สรุป

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