ฉันได้เรียนรู้ว่าฉันไม่สามารถเข้าถึงตัวแปรส่วนตัวได้โดยใช้ get-function ในคลาสเท่านั้น แต่ทำไมฉันถึงเข้าถึงได้ในตัวสร้างสำเนา
ตัวอย่าง:
Field::Field(const Field& f)
{
pFirst = new T[f.capacity()];
pLast = pFirst + (f.pLast - f.pFirst);
pEnd = pFirst + (f.pEnd - f.pFirst);
std::copy(f.pFirst, f.pLast, pFirst);
}
คำประกาศของฉัน:
private:
T *pFirst,*pLast,*pEnd;
const&หรือตามมูลค่าสำหรับแต่ละคน? จากนั้นพวกเขาจะ 'เขียนส่วนตัว' เท่านั้น & สำหรับค่าทรัพยากรที่สิ้นเปลืองและล้มเหลวสำหรับสมาชิกที่ไม่สามารถคัดลอกได้) ฉันรู้สึกงุนงงกับความสำเร็จของคำถามที่ว่างเปล่าเช่นนี้โดยถามเกี่ยวกับการสร้างสำเนาโดยไม่สนใจว่ามันหมายถึงอะไรและไม่มีคำตอบใดที่ใช้ตรรกะพื้นฐานในการหักล้างมัน พวกเขาอธิบายถึงเทคนิคแบบแห้ง แต่มีคำตอบที่ง่ายกว่ามากสำหรับคำถามนี้
คำตอบ:
IMHO คำตอบที่มีอยู่ทำงานได้ไม่ดีในการอธิบาย "ทำไม" ของสิ่งนี้ - เน้นย้ำมากเกินไปว่าพฤติกรรมใดถูกต้อง "ตัวปรับแต่งการเข้าถึงทำงานในระดับชั้นเรียนไม่ใช่ในระดับวัตถุ" - ใช้ แต่ทำไม?
แนวคิดที่ครอบคลุมในที่นี้คือโปรแกรมเมอร์ออกแบบเขียนและดูแลคลาสที่คาดว่าจะเข้าใจการห่อหุ้ม OO ที่ต้องการและได้รับอำนาจในการประสานการใช้งาน ดังนั้นหากคุณกำลังเขียนclass Xคุณกำลังเข้ารหัสไม่เพียง แต่วิธีการที่X xโค้ดสามารถใช้งานวัตถุแต่ละชิ้นได้ แต่ยังรวมถึงวิธีการ:
Xวัตถุที่แตกต่างร่วมมือกันเพื่อแสดงพฤติกรรมตามที่ตั้งใจไว้ในขณะที่ให้ความเคารพต่อเงื่อนไขหลังและสิ่งที่ไม่เปลี่ยนแปลงจากการออกแบบของคุณไม่ใช่แค่ตัวสร้างการคัดลอกเท่านั้น - การดำเนินการจำนวนมากที่ยอดเยี่ยมสามารถเกี่ยวข้องกับอินสแตนซ์ของชั้นเรียนของคุณตั้งแต่สองชุดขึ้นไป: หากคุณกำลังเปรียบเทียบการเพิ่ม / คูณ / หารการสร้างสำเนาการโคลนการกำหนดและอื่น ๆ มักจะเป็นกรณีที่คุณ ต้องมีการเข้าถึงข้อมูลส่วนตัวและ / หรือข้อมูลที่ได้รับการป้องกันในออบเจ็กต์อื่นหรือต้องการให้ใช้งานฟังก์ชันที่ง่ายขึ้นเร็วขึ้นหรือดีขึ้นโดยทั่วไป
โดยเฉพาะอย่างยิ่งการดำเนินการเหล่านี้อาจต้องการใช้ประโยชน์จากการเข้าถึงแบบส่วนตัวเพื่อทำสิ่งต่างๆเช่น:
shared_ptrเพื่ออ้างอิงข้อมูลเป็นต้นauto_ptr<>"ย้าย" ความเป็นเจ้าของไปยังวัตถุที่กำลังก่อสร้างunordered_mapสมาชิก แต่เปิดเผยต่อสาธารณะเท่านั้นbegin()และตัวทำend()ซ้ำ - ด้วยการเข้าถึงโดยตรงเพื่อให้size()คุณสามารถreserveคัดลอกได้เร็วขึ้น แย่ลงยังคงถ้าพวกเขาเท่านั้นที่เปิดเผยat()และinsert()และอื่น ๆthrow....this == otherทุกครั้งที่คุณเข้าถึงother.xซึ่งคุณจะต้องทำหากตัวปรับการเข้าถึงทำงานในระดับวัตถุ
this == otherทุกครั้งที่คุณเข้าถึงother.x" - พลาดประเด็น - ถ้าother.xได้รับการยอมรับเฉพาะที่รันไทม์เมื่อเทียบเท่าthis.xจะไม่มีการเขียนตัวชี้มากนักother.xในตอนแรก คอมไพเลอร์อาจบังคับให้คุณเขียนif (this == other) ...this.x...สิ่งที่คุณกำลังจะทำ ของคุณ"ความสะดวกสบาย (มากยิ่งขึ้นหากตัวแปรเอกชนสาธารณะ)"คิดยังคิดถึงจุด - วิธีการมาตรฐานของการกำหนดข้อ จำกัด ก็พอที่จะอนุญาตให้เหมาะสม encapsulation แต่ไม่สะดวกไม่ได้โดยไม่จำเป็น
ปรับเปลี่ยนการเข้าถึงทำงานในระดับชั้นเรียนและไม่ได้อยู่ในระดับวัตถุ
นั่นคือสองวัตถุในคลาสเดียวกันสามารถเข้าถึงข้อมูลส่วนตัวของกันและกันได้
สาเหตุหลักมาจากประสิทธิภาพ มันจะเป็นค่าใช้จ่ายรันไทม์ที่ไม่สำคัญเพื่อตรวจสอบว่าthis == otherทุกครั้งที่คุณเข้าถึงother.xซึ่งคุณจะต้องทำหากตัวปรับการเข้าถึงทำงานในระดับวัตถุ
นอกจากนี้ยังเป็นเหตุผลเชิงความหมายหากคุณคิดในแง่ของการกำหนดขอบเขต: "ฉันต้องคำนึงถึงส่วนสำคัญของโค้ดเพียงใดเมื่อแก้ไขตัวแปรส่วนตัว" - คุณต้องคำนึงถึงรหัสของทั้งคลาสและนี่คือมุมฉากกับวัตถุที่มีอยู่ในรันไทม์
และสะดวกอย่างเหลือเชื่อเมื่อเขียนตัวสร้างสำเนาและตัวดำเนินการกำหนด
คุณสามารถเข้าถึงสมาชิกส่วนตัวของชั้นเรียนได้จากในชั้นเรียนแม้กระทั่งสมาชิกของชั้นเรียนอื่น
เพื่อให้เข้าใจคำตอบฉันอยากจะเตือนคุณเกี่ยวกับแนวคิดบางประการ
this ตัวชี้จะถูกส่งผ่านไปยังทุกฟังก์ชันเมื่อเรียกใช้ตอนนี้เป็นเพราะthisตัวชี้ฟังก์ชันจึงสามารถค้นหาตัวแปรของอินสแตนซ์นั้น ๆ ได้ ไม่ว่าจะเป็นส่วนตัวของสาธารณะก็ตาม สามารถเข้าถึงได้จากฟังก์ชันนั้น ทีนี้ถ้าเราส่งตัวชี้ไปยังวัตถุอื่นในคลาสเดียวกัน เมื่อใช้ตัวชี้ที่สองนี้เราจะสามารถเข้าถึงสมาชิกส่วนตัวได้
หวังว่านี่จะตอบคำถามของคุณ
ตัวสร้างการคัดลอกเป็นฟังก์ชันสมาชิกของคลาสและด้วยเหตุนี้จึงสามารถเข้าถึงสมาชิกข้อมูลคลาสได้แม้กระทั่งผู้ที่ประกาศว่าเป็น 'ส่วนตัว'