Referans dizileri neden yasadışı?

Aşağıdaki kod derlenmez.

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

C ++ standardı bu konuda ne diyor?

Bir referans içeren bir sınıf tanımlayabileceğimi ve daha sonra aşağıda gösterildiği gibi bu sınıfın bir dizisini oluşturabileceğimi biliyorum. Ama yukarıdaki kodun neden derlenmediğini gerçekten bilmek istiyorum.

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

Bir dizi referansı simüle etmek struct cintrefyerine kullanmak mümkündür const int &.

Standart hakkındaki sorunuza cevap verirken C ++ Standardı §8.3.2 / 4'ten alıntı yapabilirim :

Referanslara referanslar, referans dizileri ve referanslara işaretçiler olmayacaktır.

Referanslar nesne değildir. Kendi depolarına sahip değiller, sadece mevcut nesnelere başvuruyorlar. Bu nedenle referans dizilerine sahip olmak mantıklı değil.

Başka bir nesneye başvuran hafif bir nesne istiyorsanız, bir işaretçi kullanabilirsiniz. structTüm structörnekler için tüm başvuru üyeleri için açık başlatma sağlarsanız , yalnızca bir başvuru üyesiyle birlikte dizilerde nesneler olarak kullanabilirsiniz . Referanslar varsayılan olarak büyük harfle yazılamaz.

Düzenleme: jia3ep'in belirttiği gibi, bildirimlerle ilgili standart bölümde referans dizileri üzerinde açık bir yasak vardır.

Bu enteresan bir tartışma. Açıkçası başvuru dizileri tamamen yasadışıdır, ancak IMHO'nun nedeni 'nesneler değiller' veya 'boyutları yok' demek kadar basit değildir. Dizilerin kendilerinin C / C ++ 'da tam teşekküllü nesneler olmadığını belirtmek isterim - buna itiraz ederseniz, bir dizi' sınıf 'şablon parametresi olarak kullanarak bazı stl şablon sınıflarını başlatmayı deneyin ve ne olduğunu görün. Onları iade edemez, atayamaz, parametre olarak geçiremezsiniz. (bir dizi parametresi bir işaretçi olarak kabul edilir). Ancak dizi dizisi yapmak yasaldır. Referansların derleyicinin hesaplayabileceği ve hesaplaması gereken bir boyutu vardır - bir referansı sizeof () edemezsiniz, ancak referanslardan başka hiçbir şey içermeyen bir yapı oluşturabilirsiniz. Referansları uygulayan tüm işaretçileri içerecek büyüklükte olacaktır. Yapabilirsin'

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

Aslında bu satırı yapı tanımına ekleyebilirsiniz

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

... ve şimdi bir dizi başvuruya çok benzeyen bir şeye sahibim:

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

Şimdi, bu gerçek bir dizi değil, bu bir operatör aşırı yüklemesi; örneğin sizeof (arr) / sizeof (arr [0]) gibi dizilerin normalde yaptığı şeyleri yapmaz. Ama bir dizi referansın tam olarak yasal C ++ ile yapmasını istediğim şeyi yapıyor. (A) 3 veya 4 öğeden fazlasını ayarlamak zor ve (b) bir grup?: Kullanarak bir hesaplama yapmak dışında, indeksleme kullanılarak yapılabilir (normal C-işaretçi-hesaplama-anlamsal indekslemeyle değil , ancak yine de indeksleme). Bunu gerçekten yapabilen çok sınırlı bir 'başvuru dizisi' türü görmek istiyorum. Yani bir referans dizisi, referans olan genel bir şeyler dizisi olarak ele alınmaz, bunun yerine yeni bir 'referans dizisi' olur. şablonlarla yapın).

Eğer bu türden iğrenç olanı aldırmazsanız muhtemelen işe yarar: '* this' dizisini int * 'lerden oluşan bir dizi olarak yeniden oluşturun ve bir:' den yapılan bir referansı döndürür: (önerilmez, ancak doğru 'dizi'nin nasıl olduğunu gösterir. işe yarar):

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

Düzenlemenize yorum yapın:

Daha iyi çözüm std::reference_wrapper.

Ayrıntılar: http://www.cplusplus.com/reference/functional/reference_wrapper/

Misal:

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

Bir dizi dolaylı olarak bir işaretçiye dönüştürülebilir ve C ++ 'da işaretçi-referansa yasa dışı

Verilen int& arr[] = {a,b,c,8};nedir sizeof(*arr)?

Diğer her yerde, bir referans sadece şeyin kendisi olarak kabul edilir, bu yüzden sizeof(*arr)basitçe olması gerekir sizeof(int). Ancak bu, bu dizideki dizi işaretçisi aritmetiğini yanlış yapar (referansların aynı genişlikte olmadığını varsayarsak, ints). Belirsizliği ortadan kaldırmak için yasak.

Çünkü burada birçoklarının söylediği gibi, referanslar nesne değildir. onlar sadece takma adlardır. Doğru, bazı derleyiciler bunları işaretçiler olarak uygulayabilir, ancak standart bunu zorlamaz / belirtmez. Ve referanslar nesne olmadığı için onlara işaret edemezsiniz. Öğeleri bir dizide saklamak, bir tür dizin adresi olduğu anlamına gelir (yani, belirli bir dizindeki öğelere işaret etme); ve bu yüzden referans dizilerine sahip olamazsınız, çünkü onları gösteremezsiniz.

Bunun yerine boost :: reference_wrapper veya boost :: tuple kullanın; ya da sadece işaretçiler.

Cevabın çok basit olduğuna ve anlamsal referans kuralları ve dizilerin C ++ 'da nasıl işlendiğiyle ilgili olduğuna inanıyorum.

Kısaca: Referanslar, varsayılan bir kurucuya sahip olmayan yapılar olarak düşünülebilir, dolayısıyla aynı kurallar geçerlidir.

1) Anlamsal olarak, referansların varsayılan bir değeri yoktur. Referanslar sadece bir şeye referans verilerek oluşturulabilir. Referansların referansın yokluğunu temsil edecek bir değeri yoktur.

2) X boyutunda bir dizi ayırırken, program varsayılan olarak başlatılmış nesnelerin bir koleksiyonunu oluşturur. Referansın varsayılan bir değeri olmadığından, böyle bir dizi oluşturmak anlamsal olarak geçersizdir.

Bu kural, varsayılan bir kurucuya sahip olmayan yapılar / sınıflar için de geçerlidir. Aşağıdaki kod örneği derlenmez:

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

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

Bu şablon yapısıyla oldukça yakınlaşabilirsiniz. Ancak, T yerine T'ye işaret eden ifadelerle başlatmanız gerekir; ve böylece, benzer şekilde kolayca bir 'sahte_konstref_array' oluşturabilseniz de, bunu OP'nin örneğinde ('8') yapıldığı gibi r değerlerine bağlayamazsınız;

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

Referans nesnenin boyutu yoktur. Eğer yazarsanız , referansın kendisinin değil, sizeof(referenceVariable)tarafından referans verilen nesnenin boyutunu verecektir referenceVariable. Kendi boyutu yoktur, bu nedenle derleyici dizinin ne kadar boyuta ihtiyacı olduğunu hesaplayamaz.

Bir dizide bir şey depoladığınızda, boyutunun bilinmesi gerekir (dizi indeksleme boyuta bağlı olduğundan). C ++ standardına göre Bir referansın depolamaya ihtiyaç duyup duymadığı belirtilmemiştir, sonuç olarak bir referans dizisini indekslemek mümkün olmayacaktır.

Sadece tüm sohbete eklemek için. Diziler, öğeyi depolamak için ardışık bellek konumları gerektirdiğinden, bu nedenle bir dizi referans oluşturursak, bunların ardışık bellek konumunda olacağı garanti edilmez, bu nedenle erişim bir sorun olur ve bu nedenle tüm matematiksel işlemleri uygulayamayız bile. dizi.

Bir dizi işaretçi düşünün. Bir işaretçi gerçekten bir adrestir; bu nedenle diziyi başlattığınızda, bilgisayara benzer şekilde "bu bellek bloğunu bu X numaralarını (diğer öğelerin adresleri olan) tutması için ayırın" diyorsunuz. Sonra işaretçilerden birini değiştirirseniz, sadece işaret ettiği şeyi değiştirmiş olursunuz; kendisi de aynı noktada oturan sayısal bir adrestir.

Bir referans, bir takma ada benzer. Bir dizi referans bildirecek olsaydınız, temelde bilgisayara "etrafa dağılmış tüm bu farklı öğelerden oluşan bu amorf bellek bloğunu ayırın" diyor olurdunuz.

Aslında bu, C ve C ++ sözdiziminin bir karışımıdır.

Sen gerektiğini ya sadece C ++ parçası olan referans beri, referansların olamaz saf C dizileri kullanın. Veya C ++ yoluna gidin ve amacınız için std::vectorveya std::arraysınıfını kullanın .

Düzenlenen bölüme gelince: structC'den bir öğe olmasına rağmen, onu bir C ++ yapan bir yapıcı ve operatör işlevleri tanımlarsınız class. Sonuç olarak, structsaf C'de derlenemezsiniz!