Pourquoi les tableaux de références sont-ils illégaux?

Le code suivant ne compile pas.

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

Que dit la norme C ++ à ce sujet?

Je sais que je pourrais déclarer une classe qui contient une référence, puis créer un tableau de cette classe, comme indiqué ci-dessous. Mais je veux vraiment savoir pourquoi le code ci-dessus ne se compile pas.

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

Il est possible d'utiliser struct cintrefau lieu de const int &pour simuler un tableau de références.

En réponse à votre question sur la norme, je peux citer la norme C ++ §8.3.2 / 4 :

Il ne doit y avoir aucune référence à des références, aucun tableau de références et aucun pointeur vers des références.

Les références ne sont pas des objets. Ils n'ont pas de stockage propre, ils font simplement référence aux objets existants. Pour cette raison, il n'a pas de sens d'avoir des tableaux de références.

Si vous voulez un objet léger qui référence un autre objet, vous pouvez utiliser un pointeur. Vous ne pourrez utiliser un structavec un membre de référence comme objets dans des tableaux que si vous fournissez une initialisation explicite pour tous les membres de référence pour toutes les structinstances. Les références ne peuvent pas être initialisées par défaut.

Edit: Comme le note jia3ep, dans la section standard sur les déclarations, il y a une interdiction explicite sur les tableaux de références.

C'est une discussion intéressante. Il est clair que les tableaux de références sont carrément illégaux, mais à mon humble avis, la raison pour laquelle ce n'est pas si simple que de dire «ils ne sont pas des objets» ou «ils n'ont pas de taille». Je soulignerais que les tableaux eux-mêmes ne sont pas des objets à part entière en C / C ++ - si vous vous y opposez, essayez d'instancier des classes de modèle stl en utilisant un tableau comme paramètre de modèle de `` classe '', et voyez ce qui se passe. Vous ne pouvez pas les retourner, les assigner, les passer en paramètres. (un paramètre de tableau est traité comme un pointeur). Mais il est légal de créer des tableaux de tableaux. Les références ont une taille que le compilateur peut et doit calculer - vous ne pouvez pas sizeof () une référence, mais vous pouvez créer une structure ne contenant que des références. Il aura une taille suffisante pour contenir tous les pointeurs qui implémentent les références. Vous pouvez'

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

En fait, vous pouvez ajouter cette ligne à la définition de struct

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

... et maintenant j'ai quelque chose qui ressemble beaucoup à un tableau de références:

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

Maintenant, ce n'est pas un vrai tableau, c'est une surcharge d'opérateurs; il ne fera pas des choses que les tableaux font normalement comme sizeof (arr) / sizeof (arr [0]), par exemple. Mais il fait exactement ce que je veux qu'un tableau de références fasse, avec un C ++ parfaitement légal. Sauf (a) c'est difficile de configurer plus de 3 ou 4 éléments, et (b) il fait un calcul en utilisant un tas de?: Ce qui pourrait être fait en utilisant l'indexation (pas avec l'indexation normale de C-pointer-calcul-sémantique , mais indexation tout de même). J'aimerais voir un type de «tableau de référence» très limité qui peut réellement le faire. C'est-à-dire qu'un tableau de références ne serait pas traité comme un tableau général de choses qui sont des références, mais plutôt un nouveau 'tableau-de-références' faire avec des modèles).

cela fonctionnerait probablement, si cela ne vous dérange pas ce genre de méchant: refondre '* this' comme un tableau d'int * et renvoyer une référence faite à partir de l'un: (non recommandé, mais cela montre comment le bon 'tableau' travaillerait):

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

Commentez votre modification:

La meilleure solution est std::reference_wrapper.

Détails: http://www.cplusplus.com/reference/functional/reference_wrapper/

Exemple:

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

Un tableau est implicitement convertible en pointeur, et le pointeur vers référence est illégal en C ++

Étant donné int& arr[] = {a,b,c,8};, qu'est-ce que c'est sizeof(*arr)?

Partout ailleurs, une référence est traitée comme étant simplement la chose elle-même, elle sizeof(*arr)devrait donc l' être sizeof(int). Mais cela rendrait l'arithmétique du pointeur de tableau erronée sur ce tableau (en supposant que les références ne sont pas de la même largeur est ints). Pour éliminer l'ambiguïté, c'est interdit.

Car comme beaucoup l'ont dit ici, les références ne sont pas des objets. ce sont simplement des alias. Il est vrai que certains compilateurs peuvent les implémenter en tant que pointeurs, mais la norme ne force / ne spécifie pas cela. Et comme les références ne sont pas des objets, vous ne pouvez pas les pointer. Stocker des éléments dans un tableau signifie qu'il existe une sorte d'adresse d'index (c'est-à-dire, pointant vers des éléments à un certain index); et c'est pourquoi vous ne pouvez pas avoir de tableaux de références, car vous ne pouvez pas les pointer.

Utilisez plutôt boost :: reference_wrapper ou boost :: tuple; ou juste des pointeurs.

Je pense que la réponse est très simple et qu'elle a à voir avec les règles sémantiques de références et la façon dont les tableaux sont gérés en C ++.

En bref: les références peuvent être considérées comme des structures qui n'ont pas de constructeur par défaut, donc toutes les mêmes règles s'appliquent.

1) Sémantiquement, les références n'ont pas de valeur par défaut. Les références ne peuvent être créées qu'en référençant quelque chose. Les références n'ont pas de valeur pour représenter l'absence de référence.

2) Lors de l'allocation d'un tableau de taille X, le programme crée une collection d'objets initialisés par défaut. Puisque la référence n'a pas de valeur par défaut, la création d'un tel tableau est sémantiquement illégale.

Cette règle s'applique également aux structures / classes qui n'ont pas de constructeur par défaut. L'exemple de code suivant ne compile pas:

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

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

Vous pouvez être assez proche avec cette structure de modèle. Cependant, vous devez initialiser avec des expressions qui sont des pointeurs vers T, plutôt que T; et ainsi, bien que vous puissiez facilement créer un 'fake_constref_array' de la même manière, vous ne pourrez pas le lier à rvalues ​​comme dans l'exemple de l'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}

Un objet de référence n'a pas de taille. Si vous écrivez sizeof(referenceVariable), cela vous donnera la taille de l'objet référencé par referenceVariable, pas celle de la référence elle-même. Il n'a pas de taille propre, c'est pourquoi le compilateur ne peut pas calculer la taille requise par le tableau.

Lorsque vous stockez quelque chose dans un tableau, sa taille doit être connue (car l'indexation du tableau dépend de la taille). Selon le standard C ++ Il n'est pas spécifié si une référence nécessite ou non du stockage, par conséquent l'indexation d'un tableau de références ne serait pas possible.

Juste pour ajouter à toute la conversation. Étant donné que les tableaux nécessitent des emplacements mémoire consécutifs pour stocker l'élément, donc si nous créons un tableau de références, il n'est pas garanti qu'elles seront à un emplacement mémoire consécutif, l'accès sera donc un problème et nous ne pouvons même pas appliquer toutes les opérations mathématiques sur tableau.

Considérez un tableau de pointeurs. Un pointeur est vraiment une adresse; Ainsi, lorsque vous initialisez le tableau, vous dites de manière analogue à l'ordinateur, "allouez ce bloc de mémoire pour contenir ces numéros X (qui sont les adresses d'autres éléments)". Ensuite, si vous changez l'un des pointeurs, vous changez simplement ce qu'il pointe; c'est toujours une adresse numérique qui se trouve elle-même au même endroit.

Une référence est analogue à un alias. Si vous deviez déclarer un tableau de références, vous diriez essentiellement à l'ordinateur, "allouez cette goutte amorphe de mémoire constituée de tous ces différents éléments éparpillés."

En fait, il s'agit d'un mélange de syntaxe C et C ++.

Vous devez soit utiliser des tableaux C purs, qui ne peuvent pas être des références, car les références font partie de C ++ uniquement. Ou vous utilisez la méthode C ++ et utilisez la classe std::vectorou std::arraypour vos besoins.

Quant à la partie éditée: même si le structest un élément de C, vous définissez un constructeur et des fonctions d'opérateur, ce qui en fait un C ++ class. Par conséquent, vous structne compileriez pas en C pur!