เหตุใดอาร์เรย์ของการอ้างอิงที่ผิดกฎหมาย

รหัสต่อไปนี้ไม่ได้รวบรวม

int a = 1, b = 2, c = 3;
int& arr[] = {a,b,c,8};

มาตรฐาน C ++ พูดถึงอะไรเกี่ยวกับเรื่องนี้

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

struct cintref
{
    cintref(const int & ref) : ref(ref) {}
    operator const int &() { return ref; }
private:
    const int & ref;
    void operator=(const cintref &);
};

int main() 
{
  int a=1,b=2,c=3;
  //typedef const int &  cintref;
  cintref arr[] = {a,b,c,8};
}

มันเป็นไปได้ที่จะใช้struct cintrefแทนconst int &การจำลองอาร์เรย์ของการอ้างอิง

ตอบคำถามของคุณเกี่ยวกับมาตรฐานฉันสามารถอ้างอิงมาตรฐาน C ++ §8.3.2 / 4 :

จะไม่มีการอ้างอิงถึงการอ้างอิงไม่มีอาร์เรย์ของการอ้างอิงและไม่มีตัวชี้ไปยังการอ้างอิง

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

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

แก้ไข:ในฐานะที่เป็นบันทึก jia3ep ในส่วนมาตรฐานในการประกาศมีข้อห้ามที่ชัดเจนเกี่ยวกับอาร์เรย์ของการอ้างอิง

นี่คือการสนทนาที่น่าสนใจ การเรียงลำดับของการอ้างอิงอย่างชัดเจนนั้นผิดกฎหมายโดยสิ้นเชิง แต่ IMHO เป็นสาเหตุที่ทำให้ไม่ง่ายเหมือนกับการพูดว่า "ไม่ใช่วัตถุ" หรือ "ไม่มีขนาด" ฉันจะชี้ให้เห็นว่าอาร์เรย์ตัวเองไม่ใช่วัตถุที่เต็มเปี่ยมใน C / C ++ - ถ้าคุณคัดค้านลองใช้แม่แบบ stl บางคลาสโดยใช้อาร์เรย์เป็นพารามิเตอร์แม่แบบ 'class' และดูว่าเกิดอะไรขึ้น คุณไม่สามารถคืนค่ากำหนดส่งผ่านเป็นพารามิเตอร์ได้ (อาร์เรย์ param ถือเป็นตัวชี้) แต่มันถูกกฎหมายที่จะทำให้อาร์เรย์ของอาร์เรย์ การอ้างอิงมีขนาดที่คอมไพเลอร์สามารถและต้องคำนวณ - คุณไม่สามารถกำหนดขนาดของการอ้างอิงได้ แต่คุณสามารถสร้างโครงสร้างที่ไม่มีอะไรนอกจากการอ้างอิง มันจะมีขนาดเพียงพอที่จะมีตัวชี้ทั้งหมดที่ใช้การอ้างอิง คุณสามารถ'

struct mys {
 int & a;
 int & b;
 int & c;
};
...
int ivar1, ivar2, arr[200];
mys my_refs = { ivar1, ivar2, arr[12] };

my_refs.a += 3  ;  // add 3 to ivar1

ในความเป็นจริงคุณสามารถเพิ่มบรรทัดนี้ในนิยาม struct

struct mys {
 ...
 int & operator[]( int i ) { return i==0?a : i==1? b : c; }
};

... และตอนนี้ฉันมีบางอย่างที่ดูเหมือนเป็นจำนวนมาก:

int ivar1, ivar2, arr[200];
mys my_refs = { ivar1, ivar2, arr[12] };

my_refs[1] = my_refs[2]  ;  // copy arr[12] to ivar2
&my_refs[0];               // gives &my_refs.a == &ivar1

ทีนี้นี่ไม่ใช่อาเรย์จริงมันเป็นโอเปอเรเตอร์ที่เกินกำลัง มันจะไม่ทำสิ่งต่าง ๆ ที่อาร์เรย์ทำตามปกติเช่น sizeof (arr) / sizeof (arr [0]) เป็นต้น แต่มันก็เป็นสิ่งที่ฉันต้องการให้มีการอ้างอิงมากมายที่ต้องทำด้วยกฎหมาย C ++ ที่สมบูรณ์แบบ ยกเว้น (a) เป็นความเจ็บปวดในการตั้งค่าสำหรับองค์ประกอบมากกว่า 3 หรือ 4 รายการและ (b) กำลังทำการคำนวณโดยใช้กลุ่ม?: ซึ่งสามารถทำได้โดยใช้การจัดทำดัชนี (ไม่ใช่การสร้างดัชนี C-pointer-calcul-semantics ปกติ แต่การจัดทำดัชนียังคงมีอยู่) ฉันต้องการดู 'อาร์เรย์ของการอ้างอิง' ที่ จำกัด มากซึ่งสามารถทำได้จริง เช่นอาร์เรย์ของการอ้างอิงจะไม่ถือว่าเป็นอาร์เรย์ทั่วไปของสิ่งต่าง ๆ ที่เป็นการอ้างอิง แต่มันจะเป็น 'อาร์เรย์ของการอ้างอิง' ใหม่ ทำกับแม่แบบ)

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

 int & operator[]( int i ) { return *(reinterpret_cast<int**>(this)[i]); }

ความคิดเห็นต่อการแก้ไขของคุณ:

std::reference_wrapperทางออกที่ดีคือ

รายละเอียด: http://www.cplusplus.com/reference/functional/reference_wrapper/

ตัวอย่าง:

#include <iostream>
#include <functional>
using namespace std;

int main() {
    int a=1,b=2,c=3,d=4;
    using intlink = std::reference_wrapper<int>;
    intlink arr[] = {a,b,c,d};
    return 0;
}

อาร์เรย์สามารถแปลงเป็นตัวชี้ได้โดยปริยายและตัวชี้ไปยังการอ้างอิงนั้นผิดกฎหมายใน C ++

ให้int& arr[] = {a,b,c,8};ไว้คือsizeof(*arr)อะไร

ทุกที่อื่นอ้างอิงได้รับการปฏิบัติในฐานะที่เป็นเพียงแค่สิ่งที่ตัวเองดังนั้นก็ควรจะsizeof(*arr) sizeof(int)แต่นี่จะทำให้ตัวคำนวณอาร์เรย์ของอาเรย์ทางคณิตศาสตร์นั้นผิด (โดยสมมติว่าการอ้างอิงนั้นไม่ใช่ความกว้างเท่ากันคือ ints) เพื่อกำจัดความกำกวมมันเป็นสิ่งต้องห้าม

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

ใช้เพิ่ม :: reference_wrapper หรือเพิ่ม :: tuple แทน หรือเพียงแค่พอยน์เตอร์

ฉันเชื่อว่าคำตอบนั้นง่ายมากและเกี่ยวข้องกับกฎความหมายของการอ้างอิงและวิธีจัดการอาร์เรย์ใน C ++

กล่าวโดยย่อ: การอ้างอิงสามารถพิจารณาได้ว่าเป็นโครงสร้างที่ไม่มีตัวสร้างเริ่มต้นดังนั้นจึงใช้กฎเดียวกันทั้งหมด

1) ความหมายการอ้างอิงไม่มีค่าเริ่มต้น การอ้างอิงสามารถสร้างได้โดยการอ้างอิงบางสิ่งเท่านั้น การอ้างอิงไม่มีค่าที่จะแสดงถึงการขาดการอ้างอิง

2) เมื่อจัดสรรอาเรย์ขนาด X โปรแกรมจะสร้างคอลเลกชันของออบเจ็กต์ที่เริ่มต้น เนื่องจากการอ้างอิงไม่มีค่าเริ่มต้นการสร้างอาร์เรย์ดังกล่าวจึงผิดกฎหมาย

กฎนี้ใช้กับโครงสร้าง / คลาสที่ไม่มีคอนสตรัคเตอร์เริ่มต้นด้วย ตัวอย่างโค้ดต่อไปนี้ไม่ได้รวบรวม:

struct Object
{
    Object(int value) { }
};

Object objects[1]; // Error: no appropriate default constructor available

คุณสามารถเข้าใกล้กับโครงสร้างเทมเพลตนี้ได้พอสมควร อย่างไรก็ตามคุณต้องเริ่มต้นด้วยนิพจน์ที่เป็นตัวชี้ไปยัง T แทนที่จะเป็น T และถึงแม้ว่าคุณสามารถสร้าง 'fake_constref_array' ได้อย่างง่ายดายในทำนองเดียวกันคุณจะไม่สามารถผูกค่าดังกล่าวกับค่า rvalues ​​เช่นเดียวกับในตัวอย่างของ OP ('8');

#include <stdio.h>

template<class T, int N> 
struct fake_ref_array {
   T * ptrs[N];
  T & operator [] ( int i ){ return *ptrs[i]; }
};

int A,B,X[3];

void func( int j, int k)
{
  fake_ref_array<int,3> refarr = { &A, &B, &X[1] };
  refarr[j] = k;  // :-) 
   // You could probably make the following work using an overload of + that returns
   // a proxy that overloads *. Still not a real array though, so it would just be
   // stunt programming at that point.
   // *(refarr + j) = k  
}

int
main()
{
    func(1,7);  //B = 7
    func(2,8);     // X[1] = 8
    printf("A=%d B=%d X = {%d,%d,%d}\n", A,B,X[0],X[1],X[2]);
        return 0;
}

-> A = 0 B = 7 X = {0,8,0}

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

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

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

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

การอ้างอิงคล้ายคลึงกับนามแฝง ถ้าคุณต้องประกาศอาร์เรย์ของการอ้างอิงคุณจะต้องบอกคอมพิวเตอร์ว่า "จัดสรรความทรงจำหยดนี้ที่ประกอบด้วยรายการต่าง ๆ เหล่านี้กระจัดกระจาย"

จริงๆแล้วนี่คือการผสมผสานของไวยากรณ์ C และ C ++

คุณควรอย่างใดอย่างหนึ่งใช้อาร์เรย์ C บริสุทธิ์ซึ่งไม่สามารถอ้างอิงตั้งแต่อ้างอิงเป็นส่วนหนึ่งของภาษา C ++ เท่านั้น หรือคุณใช้วิธี C ++ และใช้std::vectorหรือstd::arrayclass เพื่อจุดประสงค์ของคุณ

ในฐานะที่เป็นส่วนหนึ่งของการแก้ไข: แม้ว่าจะstructเป็นองค์ประกอบจาก C, คุณกำหนดตัวสร้างฟังก์ชั่นและผู้ประกอบการซึ่งทำให้มันเป็น classC ดังนั้นคุณstructจะไม่รวบรวมใน C บริสุทธิ์!