พอยน์เตอร์พอยน์คืออะไร?

ฉันไม่ได้พูดถึงพอยน์เตอร์ให้เป็นค่าคงที่ แต่เป็นพอยต์พอยต์ของตัวเอง

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

ดังนั้นประเด็นของการมีส่วนหัวของฟังก์ชั่นที่บอกว่า:

void foo(int* const ptr);

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

void foo(int* ptr);

ทำงานได้ดีเช่นกัน! เนื่องจากตัวชี้ถูกคัดลอกแล้วและตัวชี้ในผู้โทรจะไม่ได้รับผลกระทบแม้ว่าคุณจะแก้ไขการคัดลอก ดังนั้นข้อดีของ const คืออะไร

const เป็นเครื่องมือที่คุณควรใช้ในการติดตามแนวคิด C ++ ที่สำคัญมาก:

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

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

void foo(int* ptr)
{
    ptr = 0;// oops, I meant *ptr = 0
}

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

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

ฉันไม่ค่อยนำตัวแปรมาใช้ซ้ำมันสะอาดกว่าในการสร้างตัวแปรใหม่เพื่อเก็บค่าใหม่ดังนั้นการประกาศตัวแปรทั้งหมดของฉันจึงเป็นสิ่งสำคัญconst(ยกเว้นในบางกรณีเช่นตัวแปรลูปที่constจะป้องกันไม่ให้โค้ดทำงาน)

โปรดทราบว่าสิ่งนี้เหมาะสมสำหรับนิยามของฟังก์ชันเท่านั้น มันไม่ได้อยู่ในการประกาศซึ่งเป็นสิ่งที่ผู้ใช้เห็น และผู้ใช้ไม่สนใจว่าฉันจะใช้constพารามิเตอร์ภายในฟังก์ชั่นหรือไม่

ตัวอย่าง:

// foo.h
int frob(int x);

// foo.cpp
int frob(int const x) {
   MyConfigType const config = get_the_config();
   return x * config.scaling;
}

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

คำถามของคุณสัมผัสกับบางสิ่งที่กว้างกว่านี้: อาร์กิวเมนต์ของฟังก์ชันควรเป็น const หรือไม่

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

void foo(T);

มันขึ้นอยู่กับผู้ใช้งานของฟังก์ชั่นไม่ว่าเธอต้องการใช้ตัวแปรอาร์กิวเมนต์ฟังก์ชั่นขอบเขตในการเปลี่ยนแปลงหรือในทางคงที่:

// implementation 1
void foo(T const x)
{
  // I won't touch x
  T y = x;
  // ...
}

// implementation 2
void foo(T x)
{
  // l33t coding skillz
  while (*x-- = zap()) { /* ... */ }
}

ดังนั้นทำตามกฎง่ายๆที่จะไม่ใส่constในการประกาศ (ส่วนหัว) และวางไว้ในคำนิยาม (การใช้งาน) หากคุณไม่ต้องการหรือต้องการแก้ไขตัวแปร

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

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

โดยพื้นฐานแล้วมันเหมือนกับการมีint const the_answer = 42โปรแกรมของคุณ

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

คำหลัก const เป็นที่เรียกว่า "ประเภทรอบคัดเลือก" คนอื่นและvolatile restrictอย่างน้อยผันผวนตามกฎ (สับสน) เช่นเดียวกับ const

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

แต่ยังมีวัตถุประสงค์อื่นในระบบใด ๆ ที่มีหน่วยความจำแบบอ่านอย่างเดียวคือเพื่อให้แน่ใจว่าตัวแปรบางตัวได้รับการจัดสรรภายในหน่วยความจำเช่น - มันอาจเป็น EEPROM หรือแฟลชเป็นต้น สิ่งเหล่านี้เรียกว่า NVM ความทรงจำที่ไม่ลบเลือน ตัวแปรที่จัดสรรใน NVM จะยังคงปฏิบัติตามกฎทั้งหมดของตัวแปร const

มีหลายวิธีในการใช้constคำหลัก:

ประกาศตัวแปรคงที่

ซึ่งสามารถทำได้ทั้งแบบ

const int X=1; or
int const X=1;

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

เหตุผลที่แถวที่สองถือเป็นรูปแบบที่ไม่ดีอาจเป็นเพราะ "ตัวระบุระดับการจัดเก็บ" เช่นแบบคงที่และภายนอกยังสามารถประกาศได้หลังจากชนิดจริงint staticฯลฯ แต่การทำเช่นนั้นสำหรับตัวระบุระดับชั้นเก็บข้อมูลจะถูกระบุว่าเป็นคุณลักษณะที่ล้าสมัย โดยคณะกรรมการ C (ร่าง ISO 9899 N1539, 6.11.5) ดังนั้นเพื่อความมั่นคงเราไม่ควรเขียนตัวระบุประเภทในลักษณะนั้นเช่นกัน มันไม่มีจุดประสงค์อื่นนอกจากสร้างความสับสนให้ผู้อ่าน แต่อย่างใด

ประกาศตัวชี้ไปยังตัวแปรคงที่

const int* ptr = &X;

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

ประกาศตัวชี้คงที่

int* const ptr = &X;

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

void func (int*const* ptrptr)

ฉันสงสัยโปรแกรมเมอร์ C หลายคนสามารถรับค่า const และ * ได้จากที่นั่น ฉันรู้ว่าฉันทำไม่ได้ - ฉันต้องตรวจสอบกับ GCC ฉันคิดว่านั่นเป็นสาเหตุที่คุณไม่ค่อยได้เห็นไวยากรณ์นั้นสำหรับตัวชี้แบบตัวต่อตัวชี้ถึงแม้ว่ามันจะเป็นแบบฝึกหัดการเขียนโปรแกรมที่ดี

ตัวชี้คงที่สามารถใช้เพื่อให้แน่ใจว่าตัวแปรตัวชี้ถูกประกาศในหน่วยความจำแบบอ่านอย่างเดียวตัวอย่างเช่นคุณอาจต้องการประกาศตารางการค้นหาโดยใช้ตัวชี้บางประเภทและจัดสรรใน NVM

และแน่นอนตามที่ระบุโดยคำตอบอื่น ๆ ตัวชี้คงที่ยังสามารถใช้เพื่อบังคับใช้ "ความถูกต้อง const"

ประกาศตัวชี้ค่าคงที่กับข้อมูลคงที่

const int* const ptr=&X;

นี่เป็นประเภทพอยน์เตอร์สองแบบที่อธิบายไว้ข้างต้นรวมกันพร้อมกับคุณลักษณะทั้งหมดของทั้งคู่

ประกาศฟังก์ชันสมาชิกแบบอ่านอย่างเดียว (C ++)

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

void MyClass::func (void) const;

... วันนี้ฉันรู้ว่าพอยน์เตอร์ถูกส่งผ่านไปยังฟังก์ชั่นตามตัวอักษรซึ่งสมเหตุสมผล

(imo) มันไม่สมเหตุสมผลเลยที่จะเป็นค่าเริ่มต้น ค่าเริ่มต้นที่สมเหตุสมผลมากขึ้นคือการส่งผ่านเป็นตัวชี้ที่ไม่สามารถกำหนดใหม่ได้ ( int* const arg) นั่นคือฉันจะต้องให้พอยน์เตอร์ที่ส่งผ่านเป็นอาร์กิวเมนต์มีการประกาศโดยนัย const

ดังนั้นข้อดีของ const คืออะไร

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

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

void func(int* const arg) {
    int* a(arg);
    ...
    *a++ = value;
}

เพิ่มท้องถิ่นนั้นฟรีจริงและลดโอกาสสำหรับข้อผิดพลาดในขณะที่การปรับปรุงการอ่าน

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

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

หากคุณใช้ระบบฝังตัวหรือการเขียนโปรแกรมไดรเวอร์อุปกรณ์ที่คุณมีอุปกรณ์ที่แมปหน่วยความจำแล้วมักจะใช้ 'const' ทั้งสองรูปแบบรูปแบบหนึ่งเพื่อป้องกันไม่ให้ตัวชี้ถูกกำหนดใหม่ (เนื่องจากชี้ไปยังที่อยู่ฮาร์ดแวร์ถาวร) และหากอุปกรณ์ต่อพ่วง register it ชี้ไปที่การลงทะเบียนฮาร์ดแวร์แบบอ่านอย่างเดียวจากนั้น const อื่นจะตรวจพบข้อผิดพลาดจำนวนมากในเวลารวบรวมมากกว่ารันไทม์

การลงทะเบียนชิปต่อพ่วงแบบ 16 บิตแบบอ่านอย่างเดียวอาจมีลักษณะดังนี้:

static const unsigned short *const peripheral = (unsigned short *)0xfe0000UL;

จากนั้นคุณสามารถอ่านการลงทะเบียนฮาร์ดแวร์ได้โดยไม่ต้องใช้ภาษาแอสเซมบลี:

input_word = *peripheral;

int iVal = 10; int * const ipPtr = & iVal;

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

ซึ่งหมายความว่าตัวชี้ const จะชี้ไปที่ค่าเดียวกันเสมอ ในกรณีข้างต้น ipPtr จะชี้ไปยังที่อยู่ของ iVal เสมอ อย่างไรก็ตามเนื่องจากค่าที่ชี้ไปยังคงไม่ใช่ค่าคงที่จึงเป็นไปได้ที่จะเปลี่ยนค่าที่ชี้ไปโดยใช้การยกเลิกการลงทะเบียนตัวชี้:

* ipPtr = 6; // ได้รับอนุญาตเนื่องจาก pnPtr ชี้ไปที่ int ไม่ใช่ค่าคงที่

คำถามเดียวกันสามารถถามเกี่ยวกับประเภทอื่น ๆ (ไม่เพียงตัวชี้):

/* Why is n const? */
const char *expand(const int n) {
    if (n == 1) return "one";
    if (n == 2) return "two";
    if (n == 3) return "three";
    return "many";
}

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

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

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

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

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

นอกจากนี้ยังหลีกเลี่ยงเช่น ผ่านตัวชี้นี้ไปยังฟังก์ชั่นย่อยซึ่งยอมรับการอ้างอิงตัวชี้ที่ไม่ใช่ const (และสามารถเปลี่ยนตัวชี้เช่นvoid f(int *&p)) ได้ แต่ฉันเห็นด้วยว่ามีประโยชน์ค่อนข้าง จำกัด ในกรณีนี้

ตัวอย่างของตำแหน่งที่ตัวชี้ const สามารถใช้งานได้สูง พิจารณาว่าคุณมีคลาสที่มีอาร์เรย์แบบไดนามิกอยู่ภายในและคุณต้องการส่งการเข้าถึงของผู้ใช้ไปยังอาร์เรย์ แต่ไม่ได้ให้สิทธิ์ในการเปลี่ยนพอยน์เตอร์ พิจารณา:

#include <new>
#include <string.h>

class TestA
{
    private:
        char *Array;
    public:
        TestA(){Array = NULL; Array = new (std::nothrow) char[20]; if(Array != NULL){ strcpy(Array,"Input data"); } }
        ~TestA(){if(Array != NULL){ delete [] Array;} }

        char * const GetArray(){ return Array; }
};

int main()
{
    TestA Temp;
    printf("%s\n",Temp.GetArray());
    Temp.GetArray()[0] = ' '; //You can still modify the chars in the array, user has access
    Temp.GetArray()[1] = ' '; 
    printf("%s\n",Temp.GetArray());
}

ซึ่งผลิต:

ใส่ข้อมูล
ใส่ข้อมูล

แต่ถ้าเราลองทำสิ่งนี้:

int main()
{
    TestA Temp;
    printf("%s\n",Temp.GetArray());
    Temp.GetArray()[0] = ' ';
    Temp.GetArray()[1] = ' ';
    printf("%s\n",Temp.GetArray());
    Temp.GetArray() = NULL; //Bwuahahahaa attempt to set it to null
}

เราได้รับ:

ข้อผิดพลาด: lvalue จำเป็นต้องเป็น operand ด้านซ้ายของการมอบหมาย // Drat แพ้รู้อีกครั้ง!

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

int main()
{
    TestA Temp;
    printf("%s\n",Temp.GetArray());
    Temp.GetArray()[0] = ' ';
    Temp.GetArray()[1] = ' ';
    printf("%s\n",Temp.GetArray());
    delete [] Temp.GetArray(); //Bwuahaha this actually works!
}

เรายังสามารถลบการอ้างอิงหน่วยความจำของตัวชี้แม้ว่าเราจะไม่สามารถปรับเปลี่ยนตัวชี้ได้

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

แก้ไข:

หลังจากสังเกต okorz001 ความคิดเห็นที่ไม่สามารถกำหนดได้เนื่องจาก GetArray () เป็นตัวถูกดำเนินการค่าความคิดเห็นของเขาถูกต้องทั้งหมด แต่ข้างต้นยังคงใช้ถ้าคุณจะกลับการอ้างอิงไปยังตัวชี้ (ฉันคิดว่าฉันสมมติว่า GetArray คือ อ้างอิงการอ้างอิง) ตัวอย่างเช่น:

class TestA
{
    private:
        char *Array;
    public:
        TestA(){Array = NULL; Array = new (std::nothrow) char[20]; if(Array != NULL){ strcpy(Array,"Input data"); } }
        ~TestA(){if(Array != NULL){ delete [] Array;} }

        char * const &GetArray(){ return Array; } //Note & reference operator
        char * &GetNonConstArray(){ return Array; } //Note non-const
};

int main()
{
    TestA Temp;
    Temp.GetArray() = NULL; //Returns error
    Temp.GetNonConstArray() = NULL; //Returns no error
}

จะกลับมาเป็นครั้งแรกที่ทำให้เกิดข้อผิดพลาด:

ข้อผิดพลาด: การกำหนดตำแหน่งแบบอ่านอย่างเดียว 'Temp.TestA :: GetArray ()'

แต่ครั้งที่สองจะเกิดขึ้นอย่างสนุกสนานแม้จะมีผลกระทบที่อาจเกิดขึ้นภายใต้

เห็นได้ชัดว่าคำถามจะถูกยก 'ทำไมคุณต้องการกลับไปอ้างอิงถึงตัวชี้' มีอินสแตนซ์ที่หายากซึ่งคุณจำเป็นต้องกำหนดหน่วยความจำ (หรือข้อมูล) ให้กับตัวชี้ดั้งเดิมที่เป็นปัญหาโดยตรง (ตัวอย่างเช่นการสร้าง malloc / free หรือ new / free front-end) ของคุณเอง แต่ในกรณีเหล่านั้นเป็นการอ้างอิงที่ไม่ใช่แบบ const . การอ้างอิงถึงตัวชี้ const ฉันไม่เจอสถานการณ์ที่จะรับประกันได้ (เว้นแต่ว่าอาจจะเป็นตัวแปรอ้างอิง const ที่ประกาศไว้แทนที่จะเป็นประเภทการส่งคืนหรือไม่)

พิจารณาว่าเรามีฟังก์ชั่นที่ใช้ตัวชี้ const (หรืออันที่ไม่ใช่):

class TestA
{
    private:
        char *Array;
    public:
        TestA(){Array = NULL; Array = new (std::nothrow) char[20]; if(Array != NULL){ strcpy(Array,"Input data"); } }
        ~TestA(){if(Array != NULL){ delete [] Array;} }

        char * const &GetArray(){ return Array; }

        void ModifyArrayConst(char * const Data)
        {
            Data[1]; //This is okay, this refers to Data[1]
            Data--; //Produces an error. Don't want to Decrement that.
            printf("Const: %c\n",Data[1]);
        }

        void ModifyArrayNonConst(char * Data)
        {
            Data--; //Argh noo what are you doing?!
            Data[1]; //This is actually the same as 'Data[0]' because it's relative to Data's position
            printf("NonConst: %c\n",Data[1]);
        }
};

int main()
{
    TestA Temp;
    Temp.ModifyArrayNonConst("ABCD");
    Temp.ModifyArrayConst("ABCD");
}

ข้อผิดพลาดใน const สร้างข้อความดังนั้น:

ข้อผิดพลาด: การลดลงของพารามิเตอร์แบบอ่านอย่างเดียว 'ข้อมูล'

ซึ่งเป็นสิ่งที่ดีเพราะเราอาจไม่ต้องการทำเช่นนั้นเว้นแต่ว่าเราต้องการทำให้เกิดปัญหาในการแสดงความคิดเห็น หากเราแก้ไขการลดลงของฟังก์ชัน const จะเกิดสิ่งต่อไปนี้:

NonConst: A
Const: B

เห็นได้ชัดแม้ว่า A คือ 'Data [1]' มันจะถูกใช้เป็น 'Data [0]' เพราะตัวชี้ NonConst อนุญาตการดำเนินการลดลง เมื่อ const ดำเนินการตามที่คนอื่นเขียนเราจับข้อบกพร่องที่อาจเกิดขึ้นก่อนที่มันจะเกิดขึ้น

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

int main()
{
    int A = 10;
    int * const B = &A;
    *B = 20; //This is permitted
    printf("%d\n",A);
    B = NULL; //This produces an error
}

เมื่อพยายามรวบรวมให้สร้างข้อผิดพลาดต่อไปนี้:

ข้อผิดพลาด: การกำหนดตัวแปรแบบอ่านอย่างเดียว 'B'

ซึ่งน่าจะเป็นสิ่งที่ไม่ดีหากต้องการอ้างอิงอย่างต่อเนื่องกับ A ถ้าB = NULLถูกคอมเม้นท์คอมไพเลอร์จะให้เราแก้ไขอย่างมีความสุข*Bและดังนั้น A. สิ่งนี้อาจดูเหมือนไม่เป็นประโยชน์กับ ints แต่ให้พิจารณาว่าคุณมีจุดยืนเดียวของแอปพลิเคชั่นกราฟิกที่คุณต้องการตัวชี้ที่ไม่สามารถแก้ไขได้ รอบ

มันใช้เป็นตัวแปร (แก้ตัวโดยไม่ตั้งใจปุน) แต่ใช้อย่างถูกต้องมันเป็นเครื่องมืออื่นในกล่องเพื่อช่วยในการเขียนโปรแกรม

ไม่มีอะไรพิเศษเกี่ยวกับพอยน์เตอร์ที่คุณจะไม่ต้องการให้มันเป็น เช่นเดียวกับที่คุณมีintค่าคงที่ของสมาชิกคลาสคุณสามารถมีตัวชี้คงที่ด้วยเหตุผลที่คล้ายกัน: คุณต้องการตรวจสอบให้แน่ใจว่าไม่มีใครเปลี่ยนแปลงสิ่งที่ชี้ไป การอ้างอิง C ++ ค่อนข้างที่อยู่นี้ แต่พฤติกรรมของตัวชี้ที่สืบทอดมาจาก C.

ฉันเชื่อว่าสิ่งนี้จะป้องกันโค้ดจากการเพิ่มหรือลดตัวชี้ภายในเนื้อหาของฟังก์ชัน

ประเภทของการประกาศตัวแปรใด ๆ เช่น -
(1) การประกาศตัวแปรคงที่
DataType const varibleName;


 int const x;
    x=4; //you can assign its value only One time

 const int* ptr = &X;
     //Here pointer variable refer contents of 'X' that is const Such that its cannot be modified

 int* const ptr = &X;
     //Here pointer variable itself is constant  Such that value of 'X'  can be modified But pointer can't be modified