ตัวระบุการเข้าถึง C++

C Access Specifiers



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

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







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



เนื้อหาบทความ

ตัวระบุสาธารณะและส่วนตัว

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



#รวม
โดยใช้ เนมสเปซชั่วโมง;

ระดับTheCla
{
ส่วนตัว:
intnum1;
intnum2;
สาธารณะ:
TheCla(intน1intn2)
{
num1=n1;num2=n2;
}
intกระบวนการ()
{
กลับnum1;
}
};

intหลัก()
{
TheCla obj(10,ยี่สิบ);
intno2=วัตถุกระบวนการ();
ค่าใช้จ่าย<<no2<<'NS';

// int no1 = obj.num1;

กลับ 0;
}

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





ในฟังก์ชัน main() คำสั่งแรกคือการสร้างอินสแตนซ์ที่เกี่ยวข้องกับฟังก์ชันคอนสตรัคเตอร์ ซึ่งเริ่มต้น num1 และ num2 คำสั่งถัดไปเรียกสมาชิกสาธารณะ method() ของคลาส

ตอนนี้ ในคำอธิบายคลาส (คำจำกัดความ) ฟังก์ชันสมาชิกสาธารณะ TheCla() จะเข้าถึงสมาชิกไพรเวต num1 และ num2 นอกจากนี้ ฟังก์ชันพับลิกเมธอด () เข้าถึงสมาชิกไพรเวต num1 สมาชิกคนใดก็ได้ในรายละเอียดของชั้นเรียนสามารถเข้าถึงสมาชิกคนอื่น ๆ ในคำอธิบายของชั้นเรียนเดียวกันได้ ไม่สำคัญว่าสมาชิกคนใดจะเป็นส่วนตัวหรือสาธารณะ



อย่างไรก็ตาม ฟังก์ชันหรือโอเปอเรเตอร์ที่ไม่ได้ประกาศในคำอธิบายคลาสและนอกคำอธิบายคลาส สามารถเข้าถึงเฉพาะสมาชิกสาธารณะของคลาสเท่านั้น ฟังก์ชัน main() เช่น เป็นฟังก์ชันที่ประกาศนอกคำอธิบายคลาส สามารถเข้าถึงเฉพาะสมาชิก method() และ TheCla() เท่านั้น ภายในฟังก์ชัน main() ฟังก์ชัน TheCla() คือ obj(10, 20)

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

ตัวระบุเริ่มต้น
ตัวระบุเริ่มต้นสำหรับคลาสเป็นแบบส่วนตัว ดังนั้น คำอธิบายคลาสข้างต้นจึงเหมือนกับคำอธิบายต่อไปนี้ เป็นส่วนตัว แต่ไม่มีตัวระบุ:

ระดับTheCla
{
intnum1;
intnum2;
สาธารณะ:
TheCla(intน1intn2)
{
num1=n1;num2=n2;
}
intกระบวนการ()
{
กลับnum1;
}
};

บันทึก : เลเบลตัวระบุการเข้าถึงเริ่มต้นด้วยตัวระบุ และตามด้วยโคลอน

ตัวระบุที่ได้รับการป้องกัน

ภายในคำอธิบายคลาส และจากฟังก์ชันภายนอกหรือตัวดำเนินการภายนอก ตัวระบุที่มีการป้องกันจะเหมือนกับตัวระบุส่วนตัว ตอนนี้ แทนที่ตัวระบุส่วนตัวในโปรแกรมด้านบนด้วยตัวระบุ ป้องกัน และลบตัวระบุความคิดเห็น // จากคำสั่ง last-but-one ในฟังก์ชัน main() หากคุณพยายามคอมไพล์โปรแกรม โปรดทราบว่าโปรแกรมจะไม่คอมไพล์ ทำให้เกิดข้อความแสดงข้อผิดพลาด

ปัญหาของตัวระบุที่มีการป้องกันเกิดขึ้นเมื่อสมาชิกของคลาสที่ได้รับ (สืบทอดมา) ต้องเข้าถึงสมาชิกของคลาสฐาน (พาเรนต์)

คลาสที่ได้รับจากสาธารณะ กับสมาชิกสาธารณะ
พิจารณาโปรแกรมต่อไปนี้:

#รวม
โดยใช้ เนมสเปซชั่วโมง;

ระดับTheCla
{
สาธารณะ:
intnum1= 10;
มีการป้องกัน:
intnum2= ยี่สิบ;
ส่วนตัว:
intnum3= 30;
};

ระดับเด็กCla: สาธารณะTheCla
{
สาธารณะ:
intวิธี1()
{
กลับnum1;
}
intวิธีที่2()
{
กลับnum2;
}
/*int method3()
{
ส่งคืน num3;
} * /

};

intหลัก()
{
ChildCla เด็กObj;
intno1=เด็กObj.วิธี1();
ค่าใช้จ่าย<<no1<<'NS';

intno2=เด็กObj.วิธีที่2();
ค่าใช้จ่าย<<no2<<'NS';

กลับ 0;
}

ผลลัพธ์คือ:
10
ยี่สิบ

ในคลาสพื้นฐาน num1 เป็นสาธารณะ num2 ได้รับการป้องกัน และ num3 เป็นไพรเวต ในคลาสที่ได้รับ ฟังก์ชันสมาชิกทั้งหมดเป็นแบบสาธารณะ ฟังก์ชันแรก method1() เข้าถึงสมาชิกข้อมูลสาธารณะ num1 ฟังก์ชันที่สอง method2() เข้าถึงสมาชิกข้อมูลที่ได้รับการป้องกัน num2 ฟังก์ชันที่สาม method3() แม้ว่าจะแสดงความคิดเห็นไปแล้ว ควรเข้าถึงสมาชิกข้อมูลส่วนตัว num3

คลาสที่ได้รับจะไม่ถูกประกาศโดยไม่มีตัวระบุการเข้าถึง (สาธารณะ ป้องกัน หรือส่วนตัว) ด้านบน คลาสที่ได้รับจะถูกประกาศด้วยตัวระบุสาธารณะ นั่นคือ:

ระดับเด็กCla: สาธารณะTheCla{}

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

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

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

ตัวระบุคลาสที่ได้รับและตัวระบุสมาชิก

คลาสที่ได้รับการคุ้มครองกับสมาชิกสาธารณะ
แทนที่ตัวระบุสาธารณะด้วยการป้องกันในการประกาศคลาสที่ได้รับข้างต้นดังนี้:

ระดับเด็กCla: มีการป้องกันTheCla{}

คอมไพล์และรันโปรแกรมและสังเกตว่าผลลัพธ์จะเหมือนเดิม

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

บันทึก : สมาชิกที่ได้รับการป้องกันของคลาสที่ได้รับสาธารณะสามารถเข้าถึงสมาชิกที่ได้รับการป้องกันของคลาสฐาน

ชั้นเรียนที่ได้รับส่วนตัวพร้อมสมาชิกสาธารณะ
แทนที่ตัวระบุที่ได้รับการป้องกันด้วยไพรเวตในการประกาศคลาสที่ได้รับด้านบนดังนี้:

ระดับเด็กCla: ส่วนตัวTheCla{}

คอมไพล์และรันโปรแกรมและสังเกตว่าผลลัพธ์จะเหมือนเดิม

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

คลาสที่ได้รับจากสาธารณะพร้อมสมาชิกที่ได้รับการคุ้มครอง
พิมพ์ คอมไพล์ และรันโปรแกรมต่อไปนี้ ซึ่งคลาสที่ได้รับทั้งหมดได้รับการปกป้อง และสมาชิกของคลาสก็ได้รับการปกป้องด้วย ส่วนรหัสบางส่วนมีดังนี้:

#รวม
โดยใช้ เนมสเปซชั่วโมง;

ระดับTheCla
{
สาธารณะ:
intnum1= 10;
มีการป้องกัน:
intnum2= ยี่สิบ;
ส่วนตัว:
intnum3= 30;
};

ระดับเด็กCla: สาธารณะTheCla
{
มีการป้องกัน:
intวิธี1()
{
กลับnum1;
}
intวิธีที่2()
{
กลับnum2;
}
/*int method3()
{
ส่งคืน num3;
} * /

};

intหลัก()
{
/*ChildCla childObj;
int no1 = childObj.method1();
ค่าใช้จ่าย<
/*int no2 = childObj.method2();
ค่าใช้จ่าย<
กลับ 0;
}

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

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

บันทึก : สมาชิกที่ได้รับการป้องกันของคลาสที่ได้รับการป้องกันสามารถเข้าถึงสมาชิกที่ได้รับการป้องกันของคลาสฐาน

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

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

คลาสที่ได้รับการคุ้มครองพร้อมสมาชิกที่ได้รับการคุ้มครอง
แทนที่ตัวระบุสาธารณะด้วยการป้องกันในการประกาศคลาสที่ได้รับข้างต้นดังนี้:

ระดับเด็กCla: มีการป้องกันTheCla{}

ใส่ความคิดเห็นของโค้ดเซกเมนต์กลับเข้าไปในฟังก์ชัน main() หากยังไม่ได้ดำเนินการ คอมไพล์และรันโปรแกรมและสังเกตว่าผลลัพธ์ก็เหมือนเดิม

ชั้นเรียนที่ได้รับส่วนตัวพร้อมสมาชิกที่ได้รับการคุ้มครอง
แทนที่ตัวระบุที่ได้รับการป้องกันด้วยไพรเวตในการประกาศคลาสที่ได้รับด้านบนดังนี้:

ระดับเด็กCla: ส่วนตัวTheCla

คอมไพล์และรันโปรแกรมและสังเกตว่าผลลัพธ์จะเป็นเช่นเดิม

ชั้นเรียนที่ได้รับจากสาธารณะกับสมาชิกส่วนตัว
แทนที่ตัวระบุไพรเวตเป็นสาธารณะในการประกาศคลาสที่ได้รับด้านบนดังนี้:

ระดับเด็กCla: สาธารณะTheCla{}

ทำให้สมาชิกของคลาสที่ได้รับเป็นส่วนตัว รวบรวมและเรียกใช้โปรแกรม ผลลัพธ์ไม่แตกต่างจากกรณี Public Derived Class with Protected Members

คลาสที่ได้รับการคุ้มครองพร้อมสมาชิกส่วนตัว
แทนที่ตัวระบุสาธารณะด้วยการป้องกันในการประกาศคลาสที่ได้รับข้างต้นดังนี้:

ระดับเด็กCla: มีการป้องกันTheCla{}

รวบรวมและเรียกใช้โปรแกรม ผลลัพธ์นี้ไม่แตกต่างจากกรณี Protected Derived Class with Protected Members

Private Derived Class กับสมาชิกส่วนตัว
แทนที่ตัวระบุที่ได้รับการป้องกันด้วยไพรเวตในการประกาศคลาสที่ได้รับด้านบนดังนี้:

ระดับเด็กCla: ส่วนตัวTheCla{}

รวบรวมและเรียกใช้โปรแกรม ผลลัพธ์นี้ไม่แตกต่างจากกรณี Private Derived Class with Protected Members

บทสรุป

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

สมาชิกของคลาสฐานต้องได้รับการปกป้องเพื่อให้สมาชิกส่วนตัวของคลาสฐานสามารถเข้าถึงได้โดยสมาชิกของคลาสที่ได้รับ สมาชิกที่มีการป้องกันของคลาสฐานนี้ถูกมองว่าเป็นสมาชิกส่วนตัวของคลาสฐานโดยฟังก์ชันภายนอกหรือตัวดำเนินการภายนอก

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

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

ข้อมูลอ้างอิงที่ใช้ในงานนี้