Qu'est-ce que la décomposition du tableau vers le pointeur?

Qu'est-ce que la décomposition du tableau vers le pointeur? Y a-t-il une relation avec les pointeurs de tableau?

On dit que les tableaux "se désintègrent" en pointeurs. Un tableau C ++ déclaré comme int numbers [5]ne peut pas être re-pointé, c'est-à-dire que vous ne pouvez pas le dire numbers = 0x5a5aff23. Plus important encore, le terme de désintégration signifie une perte de type et de dimension; numbersse désintégrer en int*perdant les informations de dimension (compte 5) et le type n'est int [5]plus. Recherchez ici les cas où la décomposition ne se produit pas .

Si vous passez un tableau par valeur, ce que vous faites réellement, c'est la copie d'un pointeur - un pointeur vers le premier élément du tableau est copié dans le paramètre (dont le type doit également être un pointeur du type de l'élément du tableau). Cela fonctionne en raison de la nature en décomposition de la matrice; une fois décomposé, sizeofne donne plus la taille du tableau complet, car il devient essentiellement un pointeur. C'est pourquoi il est préférable (entre autres raisons) de passer par référence ou par pointeur.

Trois façons de passer dans un tableau ¹ :

void by_value(const T* array)   // const T array[] means the same
void by_pointer(const T (*array)[U])
void by_reference(const T (&array)[U])

Les deux derniers donneront des sizeofinformations correctes , tandis que le premier ne le sera pas, car l'argument tableau a diminué pour être affecté au paramètre.

^{1 La constante U doit être connue au moment de la compilation.}

Les tableaux sont fondamentalement les mêmes que les pointeurs en C / C ++, mais pas tout à fait. Une fois que vous avez converti un tableau:

const int a[] = { 2, 3, 5, 7, 11 };

dans un pointeur (qui fonctionne sans transtypage et peut donc survenir de manière inattendue dans certains cas):

const int* p = a;

vous perdez la capacité de l' sizeofopérateur à compter les éléments du tableau:

assert( sizeof(p) != sizeof(a) );  // sizes are not equal

Cette capacité perdue est appelée «désintégration».

Pour plus de détails, consultez cet article sur la dégradation des baies .

Voici ce que dit la norme (C99 6.3.2.1/3 - Autres opérandes - Valeurs L, tableaux et désignateurs de fonctions):

Sauf lorsqu'il s'agit de l'opérande de l'opérateur sizeof ou de l'opérateur unaire &, ou s'il s'agit d'un littéral de chaîne utilisé pour initialiser un tableau, une expression de type `` tableau de type '' est convertie en une expression de type '' pointeur vers tapez '' qui pointe vers l'élément initial de l'objet tableau et n'est pas une valeur l.

Cela signifie qu'à peu près à chaque fois que le nom du tableau est utilisé dans une expression, il est automatiquement converti en pointeur vers le 1er élément du tableau.

Notez que les noms de fonction agissent de manière similaire, mais les pointeurs de fonction sont utilisés beaucoup moins et de manière beaucoup plus spécialisée que cela ne cause pas autant de confusion que la conversion automatique des noms de tableau en pointeurs.

La norme C ++ (4.2 conversion de tableau en pointeur) assouplit l'exigence de conversion en (accentuez le mien):

Une lvalue ou rvalue de type "tableau de NT" ou "tableau de borne inconnue de T" peut être convertie en une rvalue de type "pointeur vers T."

La conversion ne doit donc pas se produire comme elle le fait presque toujours en C (cela permet aux fonctions de surcharger ou aux modèles de correspondre au type de tableau).

C'est aussi pourquoi en C, vous devriez éviter d'utiliser les paramètres de tableau dans les prototypes / définitions de fonctions (à mon avis - je ne suis pas sûr qu'il y ait un accord général). Ils provoquent de la confusion et sont de toute façon une fiction - utilisez des paramètres de pointeur et la confusion pourrait ne pas disparaître complètement, mais au moins la déclaration de paramètre ne ment pas.

"Decay" fait référence à la conversion implicite d'une expression d'un type tableau vers un type pointeur. Dans la plupart des contextes, lorsque le compilateur voit une expression de tableau, il convertit le type de l'expression de "tableau à N éléments de T" en "pointeur sur T" et définit la valeur de l'expression à l'adresse du premier élément du tableau . Les exceptions à cette règle sont quand un tableau est un opérande soit des sizeofou &opérateurs, ou le tableau est une chaîne littérale utilisé comme un initialiseur dans une déclaration.

Supposons le code suivant:

char a[80];
strcpy(a, "This is a test");

L'expression aest de type "tableau de 80 éléments de char" et l'expression "Ceci est un test" est de type "tableau de 16 éléments de char" (en C; en C ++, les littéraux de chaîne sont des tableaux de const char). Cependant, dans l'appel à strcpy(), aucune expression n'est un opérande de sizeofou &, donc leurs types sont implicitement convertis en "pointeur vers char", et leurs valeurs sont définies à l'adresse du premier élément de chacun. Ce qui strcpy()reçoit ne sont pas des tableaux, mais des pointeurs, comme le montre son prototype:

char *strcpy(char *dest, const char *src);

Ce n'est pas la même chose qu'un pointeur de tableau. Par exemple:

char a[80];
char *ptr_to_first_element = a;
char (*ptr_to_array)[80] = &a;

Les deux ptr_to_first_elementet ptr_to_arrayont la même valeur ; l'adresse de base de a. Cependant, ils sont de types différents et sont traités différemment, comme indiqué ci-dessous:

a[i] == ptr_to_first_element[i] == (*ptr_to_array)[i] != *ptr_to_array[i] != ptr_to_array[i]

Rappelez - vous que l'expression a[i]est interprétée comme *(a+i)( ce qui ne fonctionne que si le type de tableau est converti en un type pointeur), donc à la fois a[i]et le ptr_to_first_element[i]travail même. L'expression (*ptr_to_array)[i]est interprétée comme *(*a+i). Les expressions *ptr_to_array[i]et ptr_to_array[i]peuvent entraîner des avertissements ou des erreurs du compilateur selon le contexte; ils feront certainement la mauvaise chose si vous vous attendez à ce qu'ils évaluent a[i].

sizeof a == sizeof *ptr_to_array == 80

Encore une fois, lorsqu'un tableau est un opérande de sizeof, il n'est pas converti en type de pointeur.

sizeof *ptr_to_first_element == sizeof (char) == 1
sizeof ptr_to_first_element == sizeof (char *) == whatever the pointer size
                                                  is on your platform

ptr_to_first_element est un simple pointeur sur char.

Les tableaux, en C, n'ont aucune valeur.

Partout où la valeur d'un objet est attendue mais l'objet est un tableau, l'adresse de son premier élément est utilisée à la place, avec type pointer to (type of array elements).

Dans une fonction, tous les paramètres sont passés par valeur (les tableaux ne font pas exception). Lorsque vous passez un tableau dans une fonction, il "se désintègre en un pointeur" (sic); lorsque vous comparez un tableau à autre chose, il "se désintègre en un pointeur" (sic); ...

void foo(int arr[]);

La fonction foo attend la valeur d'un tableau. Mais, en C, les tableaux n'ont aucune valeur! Obtient donc à la fooplace l'adresse du premier élément du tableau.

int arr[5];
int *ip = &(arr[1]);
if (arr == ip) { /* something; */ }

Dans la comparaison ci-dessus, arrn'a aucune valeur, il devient donc un pointeur. Il devient un pointeur vers int. Ce pointeur peut être comparé à la variable ip.

Dans la syntaxe d'indexation des tableaux, vous avez l'habitude de voir, encore une fois, l'arr est `` décomposé en un pointeur ''

arr[42];
/* same as *(arr + 42); */
/* same as *(&(arr[0]) + 42); */

Les seuls moments où un tableau ne se désintègre pas en un pointeur sont quand il est l'opérande de l'opérateur sizeof, ou l'opérateur & (l'opérateur 'address of'), ou comme un littéral de chaîne utilisé pour initialiser un tableau de caractères.

C'est quand le tableau pourrit et est pointé du doigt ;-)

En fait, c'est juste que si vous voulez passer un tableau quelque part, mais que le pointeur est passé à la place (car qui diable passerait le tableau entier pour vous), les gens disent que le mauvais tableau s'est désintégré en pointeur.

La décomposition d'un tableau signifie que, lorsqu'un tableau est transmis en tant que paramètre à une fonction, il est traité de manière identique ("se désintègre") à un pointeur.

void do_something(int *array) {
  // We don't know how big array is here, because it's decayed to a pointer.
  printf("%i\n", sizeof(array));  // always prints 4 on a 32-bit machine
}

int main (int argc, char **argv) {
    int a[10];
    int b[20];
    int *c;
    printf("%zu\n", sizeof(a)); //prints 40 on a 32-bit machine
    printf("%zu\n", sizeof(b)); //prints 80 on a 32-bit machine
    printf("%zu\n", sizeof(c)); //prints 4 on a 32-bit machine
    do_something(a);
    do_something(b);
    do_something(c);
}

Il existe deux complications ou exceptions à ce qui précède.

Premièrement, lorsque vous traitez des tableaux multidimensionnels en C et C ++, seule la première dimension est perdue. Cela est dû au fait que les tableaux sont disposés de manière contiguë en mémoire, de sorte que le compilateur doit connaître toutes les dimensions sauf la première pour pouvoir calculer les décalages dans ce bloc de mémoire.

void do_something(int array[][10])
{
    // We don't know how big the first dimension is.
}

int main(int argc, char *argv[]) {
    int a[5][10];
    int b[20][10];
    do_something(a);
    do_something(b);
    return 0;
}

Deuxièmement, en C ++, vous pouvez utiliser des modèles pour déduire la taille des tableaux. Microsoft l'utilise pour les versions C ++ des fonctions Secure CRT comme strcpy_s , et vous pouvez utiliser une astuce similaire pour obtenir de manière fiable le nombre d'éléments dans un tableau .

tl; dr: lorsque vous utilisez un tableau que vous avez défini, vous utilisez en fait un pointeur sur son premier élément.

Donc:

• Lorsque vous écrivez, arr[idx]vous dites vraiment *(arr + idx).
• les fonctions ne prennent jamais vraiment les tableaux comme paramètres, seulement des pointeurs, même lorsque vous spécifiez un paramètre de tableau.

Sortes d'exceptions à cette règle:

• Vous pouvez transmettre des tableaux de longueur fixe à des fonctions dans a struct.
• sizeof() donne la taille occupée par le tableau, pas la taille d'un pointeur.

Je pourrais être si audacieux de penser qu'il existe quatre (4) façons de passer un tableau comme argument de fonction. Voici également le code court mais fonctionnel de votre lecture.

#include <iostream>
#include <string>
#include <vector>
#include <cassert>

using namespace std;

// test data
// notice native array init with no copy aka "="
// not possible in C
 const char* specimen[]{ __TIME__, __DATE__, __TIMESTAMP__ };

// ONE
// simple, dangerous and useless
template<typename T>
void as_pointer(const T* array) { 
    // a pointer
    assert(array != nullptr); 
} ;

// TWO
// for above const T array[] means the same
// but and also , minimum array size indication might be given too
// this also does not stop the array decay into T *
// thus size information is lost
template<typename T>
void by_value_no_size(const T array[0xFF]) { 
    // decayed to a pointer
    assert( array != nullptr ); 
}

// THREE
// size information is preserved
// but pointer is asked for
template<typename T, size_t N>
void pointer_to_array(const T (*array)[N])
{
   // dealing with native pointer 
    assert( array != nullptr ); 
}

// FOUR
// no C equivalent
// array by reference
// size is preserved
template<typename T, size_t N>
void reference_to_array(const T (&array)[N])
{
    // array is not a pointer here
    // it is (almost) a container
    // most of the std:: lib algorithms 
    // do work on array reference, for example
    // range for requires std::begin() and std::end()
    // on the type passed as range to iterate over
    for (auto && elem : array )
    {
        cout << endl << elem ;
    }
}

int main()
{
     // ONE
     as_pointer(specimen);
     // TWO
     by_value_no_size(specimen);
     // THREE
     pointer_to_array(&specimen);
     // FOUR
     reference_to_array( specimen ) ;
}

Je pourrais aussi penser que cela montre la supériorité de C ++ vs C. Au moins en référence (jeu de mots voulu) de passer un tableau par référence.

Bien sûr, il existe des projets extrêmement stricts sans allocation de tas, sans exception et sans std :: lib. On pourrait dire que la gestion des baies natives C ++ est une fonctionnalité de langage critique.