Lors de la déclaration d'une référence à un tableau d'Ints, pourquoi doit-il faire référence à un pointeur const?

Note: j'utilise le compilateur g++ (qui est ce que j'entends est assez bonne et censé être assez proche de la norme).

Disons que vous avez déclaré un tableau d'entiers:

int a[3] = { 4, 5, 6 };

Maintenant, disons que vous voulez vraiment pour déclarer une référence à ce tableau (nevermind pourquoi, autres que les Bjarne dit la langue prend en charge).

Cas 1 -- Si vous essayez:

int*& ra = a;

puis le compilateur hésite et dit:

"invalid initialization of non-const reference of type `int*&' from a temporary of type `int*'"

Tout d'abord, pourquoi est - 'a' une variable temporaire (c'est à dire ne pas avoir une place dans la mémoire?)...

De toute façon, fine, chaque fois que je vois un non-const erreur, j'ai essayer de le jeter dans un const...

Cas 2 -- si vous essayez:

int*const&rca = a;  //wish I knew where the spaces should go (but my other post asking about this sort of protocol got a negative rank while many of the answers got ranked highly -- aha! there are stupid questions!)

Ensuite, tout est cool, ça compile, et vous obtenez une référence à la matrice.

Cas 3 -- Maintenant, voici une autre chose qui va compiler:

int* justSomeIntPointer = a;  //LINE 1
int*& rpa = justSomeIntPointer;  //LINE 2

Cela vous donne aussi une référence pour le tableau d'origine.

Voici donc ma question: À quel point est-ce le nom d'une manière statique déclaré tableau
devenir un const-pointeur? Je crois me souvenir que le nom d'un tableau d'entiers est également un pointeur de type int, mais je ne me souviens pas qu'il ne soit jamais un const-pointeur vers int...

Il semble que le Cas 1 échoue parce que la référence à déclarer (ra) n'est pas const-pointeur, ce qui peut signifier que " a " est déjà un const-pointeur vers int.

Il semble que le Cas 2 fonctionne parce que la référence à déclarer (rca) est déjà un const-pointeur vers int.

Cas 3 fonctionne aussi, qui est très bien, mais pourquoi? À partir de quel point de l'hypothèse d'un pointeur de int (c'est à dire le nom du tableau "a") const-pointeur? T-il se passer si vous l'affectez à un int* (LIGNE 1), ou faut-il se produire lorsque vous affectez cet int* int*& (LIGNE 2)?

Espérons que cela a du sens. Merci.

source d'informationauteur Jimmy

  1. 28
    int*& ra = a;

    int* est un type de pointeur, pas de type tableau. C'est pourquoi il ne se lient pas à aqui a le type int[3].

    int* const& ra = a;

    fonctionne, parce que c'est équivalent à

    int* const& ra = (int*)a;

    Qui est, temporaire pointeur est conceptuellement créé sur le côté droit de la cession, et ce temporaire est ensuite lié à ra. Donc en fin de compte, ce n'est pas mieux que:

    int* ra = a;

    où ra est en fait un pointeur vers le premier élément du tableau, pas une référence à la matrice.

    La déclaration d'une référence à un tableau de la manière la plus facile:

    typedef int array_type[3];
array_type& ra = a;

    La pas-si-facile moyen:

    int (&ra)[3] = a;

    Le C++11 est facile:

    auto& ra = a;

    À quel point est-ce le nom d'une manière statique déclaré matrice de devenir un const-pointeur? Je crois me souvenir que le nom d'un tableau d'entiers est également un pointeur de type int, mais je ne me souviens pas qu'il ne soit jamais un const-pointeur vers int...

    C'est la bonne question à se poser! Si vous comprenez lors de tableau de pointeur de décomposition se produit, alors vous êtes en sécurité. Simplement mis, il y a deux choses à considérer:

    • de désintégration qui se passe quand tout type de "copie" est tenté (parce que le C ne permet pas de tableaux pour être copié directement)
    • la carie est une sorte de conversion et peut survenir à tout moment d'une conversion est possible: si les types ne correspondent pas

    Le premier type arrive généralement avec des modèles. Donc, étant donné template<typename T> pass_by_value(T);puis pass_by_value(a) vont passer à une int*parce que le tableau de type int[3] ne peut pas être copié.

    Que pour le second, vous l'avez déjà vu en action: ce qui se passe dans votre deuxième cas, quand int* const& ne peut pas se lier à int[3]mais peut se lier à une temporaire int*de sorte que la conversion se produit.

  2. 8

    Le mot "array" en C++ est orthographié avec des crochets []. Si vous voulez déclarer une quelque chose de la matrice de quelque chose en C++, vous devez avoir des crochets dans votre déclaration. Si vous écrivez un astérisque * au lieu de cela, vous obtiendrez un pointeur. Les pointeurs et les tableaux sont deux choses différentes.

    C'est une référence à un tableau:

    int (&ra) [3] = a;
  3. 2

    La très grosse erreur (c'est aussi une très bonne question d'entrevue) que la plupart des gens font, c'est qu'ils pensent que le nom d'un tableau est l'équivalent d'un pointeur. Ce n'est PAS vrai. Cette erreur provoque de nombreux bugs dans les programmes en C particulièrement le lien entre les bugs, et ils sont très difficiles à déboguer. La diffrence est ceci: Le nom du tableau est un pointeur, le premier élément d'une structure, le tableau. Le type du nom du tableau n'est pas un pointertype cependant, mais une arraytype. Un pointeur, d'autre part, est simplement un pointeur vers une chose avec aucune autre information. Le type d'un pointeur est une pointertype. Un arraytype a d'autres propriétés, comme il sait si son sur la pile ou pas; par conséquent, "temporaire". L'erreur temporaire dans votre cas relève d'un check qui empêche une variable temporaire pour être affecté à une référence. Le mot-clé const tourne que cocher. Un pointertype sur l'autre main n'a aucune notion de "temporaire". Maintenant, supposons que vous voulez tromper le compilateur et affecter une référence à quelque chose qui est dans la pile. Dans ce cas, vous avez besoin de faire un pointeur. Comment?

    int*& ra = &a[0];

    dans le cas ci-dessus, vous devez d'abord obtenir la valeur et à l'aide d'un &(adresse de l'opérateur) de vous faire un pointerType. Maintenant un pointertype ne dispose d'aucune information quant à savoir si son sur la pile (une variable temporaire) ou pas. Cependant, cela fera une référence à un pointeur vers le premier élément du tableau. (Donc juste un type de pointeur, pas un arraytype)

  4. 1

    Si vous voulez vraiment une référence à un tableau, vous devez utiliser les éléments suivants:

    int a[3] = { 4, 5, 6 };
int (&ra)[3] = a;

    Ce que vous essayez de créer avec int *& est une référence à un pointeur vers un int. Ce n'est pas le même type. Et comme vous initialisez la référence à une valeur qui ne peut pas changer (le adresse de la matrice de), vous devez déclarer le pointeur const (pas le ints).

  5. 1

    Vous avez un tableau d'entiers : 

    int a[3] = { 4, 5, 6 };

    Aujourd'hui, cette ligne : 

    int*& ra = a;

    crée une référence à un pointeur. Puisque vous créer un pointeur temporaire (converti à partir du tableau a), le compilateur se plaint, parce que la norme interdit la cession des temporaires à une référence.

    Donc, pour résoudre ce problème, vous devez créer un pointeur, puis l'affecter à une référence à un pointeur : 

    int *pa = a;
int *& rpa = pa;

    Constantes références à la référence de maintien temporaires, mais que vous avez déjà trouvé.

    Ce que vous avez demandé (à propos de la référence à un tableau) - l'exemple le plus célèbre sur la création d'une référence à un tableau est: est-ce 

    template< typename T, size_t N >
size_t ArraySize( T (&)[ N ] )
{
    return N;
}

    Cette fonction prend une référence à un tableau, et renvoie sa taille.

  6. 0

    À quel point est-ce le nom d'une manière statique déclaré matrice de devenir un const-pointeur? Je crois me souvenir que le nom d'un tableau d'entiers est également un pointeur de type int, mais je ne me souviens pas qu'il ne soit jamais un const-pointeur vers int...

    Parce que vous avez écrit les valeurs dans le fichier cpp, c'est pourquoi il est constant.

    Vous pouvez simplement utiliser:

    const int *pToArray = a;

    ou 

    const int *pToArray = (const int*)&a[0];
  7. -2

    a est une variable temporaire parce que vous avez déclaré dans la pile et non pas sur le tas à l'aide d'un malloc ou une nouvelle.