Tại sao các mảng tài liệu tham khảo bất hợp pháp?

Các mã sau không biên dịch.

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

Tiêu chuẩn C ++ nói gì về điều này?

Tôi biết tôi có thể khai báo một lớp có chứa một tham chiếu, sau đó tạo một mảng của lớp đó, như được hiển thị bên dưới. Nhưng tôi thực sự muốn biết tại sao đoạn mã trên không biên dịch đượ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};
}

Có thể sử dụng struct cintrefthay vì const int &mô phỏng một loạt các tài liệu tham khảo.

Trả lời câu hỏi của bạn về tiêu chuẩn Tôi có thể trích dẫn Tiêu chuẩn C ++ §8.3.2 / 4 :

Sẽ không có tài liệu tham khảo cho tài liệu tham khảo, không có mảng tài liệu tham khảo và không có con trỏ đến tài liệu tham khảo.

Tài liệu tham khảo không phải là đối tượng. Họ không có kho lưu trữ của riêng họ, họ chỉ tham chiếu các đối tượng hiện có. Vì lý do này, không có ý nghĩa gì khi có các mảng tham chiếu.

Nếu bạn muốn một đối tượng trọng lượng nhẹ tham chiếu đến một đối tượng khác thì bạn có thể sử dụng một con trỏ. Bạn sẽ chỉ có thể sử dụng một structthành viên tham chiếu làm đối tượng trong mảng nếu bạn cung cấp khởi tạo rõ ràng cho tất cả các thành viên tham chiếu cho tất cả các structtrường hợp. Tài liệu tham khảo không thể được mặc định initalized.

Chỉnh sửa: Như jia3ep lưu ý, trong phần tiêu chuẩn về khai báo có một lệnh cấm rõ ràng đối với mảng tham chiếu.

Đây là một cuộc thảo luận thú vị. Rõ ràng các mảng giới thiệu là hoàn toàn bất hợp pháp, nhưng IMHO lý do tại sao không đơn giản như nói 'chúng không phải là đối tượng' hoặc 'chúng không có kích thước'. Tôi đã chỉ ra rằng bản thân các mảng không phải là các đối tượng chính thức trong C / C ++ - nếu bạn phản đối điều đó, hãy thử khởi tạo một số lớp mẫu stl bằng cách sử dụng một mảng làm tham số mẫu 'lớp' và xem điều gì sẽ xảy ra. Bạn không thể trả lại chúng, gán chúng, chuyển chúng dưới dạng tham số. (một tham số mảng được coi là một con trỏ). Nhưng nó là hợp pháp để tạo ra các mảng của mảng. Các tham chiếu có một kích thước mà trình biên dịch có thể và phải tính toán - bạn không thể sizeof () một tham chiếu, nhưng bạn có thể tạo một cấu trúc không chứa gì ngoài các tham chiếu. Nó sẽ có kích thước đủ để chứa tất cả các con trỏ thực hiện các tham chiếu. Bạn có thể'

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

Trong thực tế, bạn có thể thêm dòng này vào định nghĩa struct

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

... và bây giờ tôi có một cái gì đó trông RẤT NHIỀU như một loạt các ref:

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

Bây giờ, đây không phải là một mảng thực sự, nó là một quá tải toán tử; chẳng hạn, nó sẽ không làm những thứ mà mảng thường làm như sizeof (mảng) / sizeof (Array [0]). Nhưng nó thực hiện chính xác những gì tôi muốn một loạt các tài liệu tham khảo để làm, với C ++ hoàn toàn hợp pháp. Ngoại trừ (a) thật khó để thiết lập hơn 3 hoặc 4 phần tử và (b) đó là thực hiện một phép tính bằng cách sử dụng một nhóm ?: Có thể được thực hiện bằng cách lập chỉ mục (không phải với lập chỉ mục ngữ nghĩa tính toán con trỏ C thông thường , nhưng dù sao chỉ mục). Tôi muốn thấy một loại 'tham chiếu' rất hạn chế có thể thực sự làm điều này. Tức là một mảng các tài liệu tham khảo sẽ không được coi là một mảng chung của những thứ là tài liệu tham khảo, mà nó sẽ là một 'tham chiếu' mới thực hiện với các mẫu).

điều này có thể sẽ hoạt động, nếu bạn không bận tâm đến loại khó chịu này: recast '* this' dưới dạng một mảng của int * 'và trả về một tham chiếu được tạo từ một: (không được đề xuất, nhưng nó cho thấy cách' mảng 'thích hợp sẽ làm việc):

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

Nhận xét để chỉnh sửa của bạn:

Giải pháp tốt hơn là std::reference_wrapper.

Chi tiết: http://www.cplusplus.com/reference/feftal/reference_wrapper/

Thí dụ:

#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;
}

Một mảng được chuyển đổi hoàn toàn thành một con trỏ và tham chiếu con trỏ là bất hợp pháp trong C ++

Cho int& arr[] = {a,b,c,8};, là sizeof(*arr)gì?

Ở mọi nơi khác, một tài liệu tham khảo được coi là đơn giản là chính nó, vì vậy sizeof(*arr)đơn giản nên có sizeof(int). Nhưng điều này sẽ làm cho số học con trỏ mảng trên mảng này sai (giả sử rằng các tham chiếu không có cùng độ rộng là ints). Để loại bỏ sự mơ hồ, nó bị cấm.

Bởi vì giống như nhiều người đã nói ở đây, tài liệu tham khảo không phải là đối tượng. chúng chỉ đơn giản là bí danh. Đúng một số trình biên dịch có thể thực hiện chúng như các con trỏ, nhưng tiêu chuẩn không bắt buộc / chỉ định điều đó. Và bởi vì tài liệu tham khảo không phải là đối tượng, bạn không thể chỉ ra chúng. Lưu trữ các phần tử trong một mảng có nghĩa là có một số loại địa chỉ chỉ mục (nghĩa là chỉ đến các phần tử tại một chỉ mục nhất định); và đó là lý do tại sao bạn không thể có các mảng tham chiếu, bởi vì bạn không thể trỏ đến chúng.

Sử dụng boost :: Reference_wrapper hoặc boost :: tuple thay thế; hoặc chỉ con trỏ.

Tôi tin rằng câu trả lời rất đơn giản và nó phải được thực hiện với các quy tắc ngữ nghĩa của các tham chiếu và cách các mảng được xử lý trong C ++.

Tóm lại: Các tài liệu tham khảo có thể được coi là các cấu trúc không có hàm tạo mặc định, vì vậy tất cả các quy tắc tương tự đều được áp dụng.

1) Về mặt ngữ nghĩa, tài liệu tham khảo không có giá trị mặc định. Tài liệu tham khảo chỉ có thể được tạo ra bằng cách tham khảo một cái gì đó. Tài liệu tham khảo không có giá trị để thể hiện sự vắng mặt của tài liệu tham khảo.

2) Khi phân bổ một mảng có kích thước X, chương trình sẽ tạo ra một tập hợp các đối tượng được khởi tạo mặc định. Vì tham chiếu không có giá trị mặc định, việc tạo một mảng như vậy là bất hợp pháp về mặt ngữ nghĩa.

Quy tắc này cũng áp dụng cho các cấu trúc / lớp không có hàm tạo mặc định. Mẫu mã sau không biên dịch:

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

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

Bạn có thể khá gần với cấu trúc mẫu này. Tuy nhiên, bạn cần khởi tạo với các biểu thức là con trỏ tới T, thay vì T; và do đó, mặc dù bạn có thể dễ dàng tạo một 'fake_constref_array' tương tự, bạn sẽ không thể liên kết nó với các giá trị như được thực hiện trong ví dụ của 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}

Một đối tượng tham chiếu không có kích thước. Nếu bạn viết sizeof(referenceVariable), nó sẽ cung cấp cho bạn kích thước của đối tượng được tham chiếu bởi referenceVariable, không phải của tham chiếu. Nó không có kích thước của riêng nó, đó là lý do tại sao trình biên dịch không thể tính được kích thước của mảng sẽ yêu cầu.

Khi bạn lưu trữ một cái gì đó trong một mảng, kích thước của nó cần phải được biết (vì việc lập chỉ mục mảng phụ thuộc vào kích thước). Theo tiêu chuẩn C ++ Không xác định được liệu tham chiếu có yêu cầu lưu trữ hay không, do đó, việc lập chỉ mục một mảng các tham chiếu sẽ không thể thực hiện được.

Chỉ để thêm vào tất cả các cuộc trò chuyện. Do các mảng yêu cầu các vị trí bộ nhớ liên tiếp để lưu trữ mục, vì vậy nếu chúng ta tạo một mảng các tham chiếu thì không đảm bảo rằng chúng sẽ ở vị trí bộ nhớ liên tiếp nên việc truy cập sẽ là một vấn đề và do đó chúng ta thậm chí không thể áp dụng tất cả các hoạt động toán học trên mảng.

Hãy xem xét một loạt các con trỏ. Một con trỏ thực sự là một địa chỉ; Vì vậy, khi bạn khởi tạo mảng, bạn đang nói với máy tính một cách tương tự, "phân bổ khối bộ nhớ này để giữ các số X này (là địa chỉ của các mục khác)." Sau đó, nếu bạn thay đổi một trong những con trỏ, bạn chỉ thay đổi những gì nó trỏ đến; nó vẫn là một địa chỉ số mà chính nó đang ngồi ở cùng một chỗ.

Một tài liệu tham khảo tương tự như một bí danh. Nếu bạn đã khai báo một loạt các tài liệu tham khảo, về cơ bản bạn sẽ nói với máy tính, "phân bổ đốm bộ nhớ vô định hình này bao gồm tất cả các mục khác nhau nằm rải rác xung quanh."

Trên thực tế, đây là một hỗn hợp của cú pháp C và C ++.

Bạn nên hoặc là sử dụng mảng C tinh khiết, mà không thể được tài liệu tham khảo, vì tài liệu tham khảo là một phần của C ++ chỉ. Hoặc bạn đi theo cách C ++ và sử dụng std::vectorhoặc std::arraylớp cho mục đích của bạn.

Đối với phần được chỉnh sửa: Mặc dù structlà một phần tử từ C, bạn xác định hàm xây dựng và hàm toán tử, làm cho nó trở thành C ++ class. Do đó, của bạnstruct sẽ không biên dịch trong C thuần túy!