O que é matriz para decaimento do ponteiro?

O que é matriz para decaimento do ponteiro? Existe alguma relação com ponteiros de matriz?

Dizem que matrizes "decaem" em ponteiros. Uma matriz C ++ declarada como int numbers [5]não pode ser apontada novamente, ou seja, você não pode dizer numbers = 0x5a5aff23. Mais importante ainda, o termo decadência significa perda de tipo e dimensão; numbersdecaia int*perdendo as informações da dimensão (contagem 5) e o tipo não existe int [5]mais. Veja aqui os casos em que a deterioração não acontece .

Se você estiver passando uma matriz por valor, o que realmente está fazendo é copiar um ponteiro - um ponteiro para o primeiro elemento da matriz é copiado para o parâmetro (cujo tipo também deve ser um ponteiro para o tipo de elemento da matriz). Isso funciona devido à natureza em decomposição da matriz; uma vez deteriorado, sizeofnão fornece mais o tamanho completo da matriz, porque se torna essencialmente um ponteiro. É por isso que é preferível (entre outros motivos) passar por referência ou ponteiro.

Três maneiras de passar em uma matriz ¹ :

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])

Os dois últimos fornecerão sizeofinformações apropriadas , enquanto o primeiro não fornecerá , desde que o argumento do array tenha se deteriorado para ser atribuído ao parâmetro.

^{1 A constante U deve ser conhecida em tempo de compilação.}

Matrizes são basicamente os mesmos que ponteiros em C / C ++, mas não exatamente. Depois de converter uma matriz:

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

em um ponteiro (que funciona sem conversão e, portanto, pode ocorrer inesperadamente em alguns casos):

const int* p = a;

você perde a capacidade do sizeofoperador de contar elementos na matriz:

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

Essa habilidade perdida é chamada de "deterioração".

Para mais detalhes, consulte este artigo sobre decaimento de matriz .

Aqui está o que o padrão diz (C99 6.3.2.1/3 - Outros operandos - Lvalues, matrizes e designadores de função):

Exceto quando é o operando do operador sizeof ou o operador unary &, ou é uma cadeia de caracteres literal usada para inicializar uma matriz, uma expressão que tem o tipo '' matriz do tipo '' é convertida em uma expressão com o tipo '' ponteiro para digite '' que aponta para o elemento inicial do objeto da matriz e não é um lvalue.

Isso significa que praticamente sempre que o nome do array é usado em uma expressão, ele é automaticamente convertido em um ponteiro para o 1º item do array.

Observe que os nomes das funções agem de maneira semelhante, mas os ponteiros de função são usados ​​muito menos e de uma maneira muito mais especializada que não causa tanta confusão quanto a conversão automática de nomes de matriz em ponteiros.

O padrão C ++ (conversão de matriz para ponteiro 4.2) afrouxa o requisito de conversão para (ênfase minha):

Um lvalue ou rvalue do tipo "array of NT" ou "array de limite desconhecido de T" pode ser convertido em um rvalue do tipo "apontador para T."

Portanto, a conversão não precisa acontecer como acontece quase sempre em C (isso permite sobrecarga de funções ou modelos correspondentes no tipo de matriz).

É também por isso que em C você deve evitar o uso de parâmetros de matriz em protótipos / definições de funções (na minha opinião - não tenho certeza se há algum acordo geral). Eles causam confusão e são uma ficção de qualquer maneira - use parâmetros de ponteiro e a confusão pode não desaparecer completamente, mas pelo menos a declaração de parâmetro não está mentindo.

"Decaimento" refere-se à conversão implícita de uma expressão de um tipo de matriz para um tipo de ponteiro. Na maioria dos contextos, quando o compilador vê uma expressão de matriz, ele converte o tipo da expressão de "matriz do elemento N de T" em "ponteiro para T" e define o valor da expressão para o endereço do primeiro elemento da matriz . As excepções a esta regra são quando uma matriz é um operando de ambos os sizeofou &operadores, ou a matriz é uma string literal sendo usado como um inicializador em uma declaração.

Suponha o seguinte código:

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

A expressão aé do tipo "matriz de 80 elementos do caractere" e a expressão "Este é um teste" é do tipo "matriz de 16 elementos do caractere" (em C; na string C ++, literais são matrizes de const char). No entanto, na chamada para strcpy(), nenhuma expressão é um operando de sizeofou &, portanto, seus tipos são implicitamente convertidos em "ponteiro para char" e seus valores são definidos no endereço do primeiro elemento em cada um. O que strcpy()recebe não são matrizes, mas ponteiros, como visto em seu protótipo:

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

Isso não é a mesma coisa que um ponteiro de matriz. Por exemplo:

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

Ambos ptr_to_first_elemente ptr_to_arraytêm o mesmo valor ; o endereço base de a. No entanto, são tipos diferentes e são tratados de maneira diferente, conforme mostrado abaixo:

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

Recordar que a expressão a[i]é interpretada como *(a+i)(que só funciona se o tipo de matriz é convertido para um tipo de ponteiro), de modo que ambos a[i]e ptr_to_first_element[i]trabalho a mesma. A expressão (*ptr_to_array)[i]é interpretada como *(*a+i). As expressões *ptr_to_array[i]e ptr_to_array[i]podem levar a avisos ou erros do compilador, dependendo do contexto; eles definitivamente farão a coisa errada se você espera que eles avaliem a[i].

sizeof a == sizeof *ptr_to_array == 80

Novamente, quando uma matriz é um operando de sizeof, não é convertida em um tipo de ponteiro.

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 é um ponteiro simples para char.

Matrizes, em C, não têm valor.

Onde quer que o valor de um objeto seja esperado, mas o objeto seja uma matriz, o endereço do seu primeiro elemento será usado com type pointer to (type of array elements).

Em uma função, todos os parâmetros são passados ​​por valor (matrizes não são exceção). Quando você passa um array em uma função, "decai em um ponteiro" (sic); quando você compara uma matriz com outra coisa, ela "decai em um ponteiro" (sic); ...

void foo(int arr[]);

A função foo espera o valor de uma matriz. Mas, em C, matrizes não têm valor! Então, fooobtém o endereço do primeiro elemento da matriz.

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

Na comparação acima, arrnão tem valor, então se torna um ponteiro. Torna-se um ponteiro para int. Esse ponteiro pode ser comparado com a variável ip.

Na sintaxe de indexação de array que você está acostumado a ver, novamente, o arr é 'deteriorado para um ponteiro'

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

As únicas vezes em que uma matriz não se decompõe em um ponteiro é quando é o operando do operador sizeof, ou o operador & (o operador 'address of'), ou como uma string literal usada para inicializar uma matriz de caracteres.

É quando o array apodrece e está sendo apontado para ;-)

Na verdade, é só que, se você deseja passar uma matriz em algum lugar, mas o ponteiro é passado (porque quem diabos passaria toda a matriz por você), as pessoas dizem que essa matriz pobre se deteriorou para apontar.

A deterioração da matriz significa que, quando uma matriz é passada como parâmetro para uma função, ela é tratada de forma idêntica a ("decai para") um ponteiro.

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

Existem duas complicações ou exceções ao acima.

Primeiro, ao lidar com matrizes multidimensionais em C e C ++, apenas a primeira dimensão é perdida. Isso ocorre porque as matrizes são dispostas de forma contígua na memória; portanto, o compilador deve conhecer tudo, exceto a primeira dimensão, para poder calcular as compensações nesse bloco de memória.

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

Segundo, em C ++, você pode usar modelos para deduzir o tamanho das matrizes. A Microsoft usa isso para as versões C ++ das funções Secure CRT, como strcpy_s , e você pode usar um truque semelhante para obter com segurança o número de elementos em uma matriz .

tl; dr: Quando você usa uma matriz que você define, na verdade você usa um ponteiro para o primeiro elemento.

Portanto:

• Quando você escreve, arr[idx]está realmente apenas dizendo *(arr + idx).
• As funções nunca recebem matrizes como parâmetros, apenas ponteiros, mesmo quando você especifica um parâmetro de matriz.

Exceções de tipo a esta regra:

• Você pode passar matrizes de comprimento fixo para funções dentro de a struct.
• sizeof() fornece o tamanho ocupado pela matriz, não o tamanho de um ponteiro.

Eu posso ser tão ousado ao pensar que existem quatro (4) maneiras de passar uma matriz como argumento de função. Também aqui está o código curto, mas funcional, para sua leitura.

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

Eu também acho que isso mostra a superioridade de C ++ vs C. Pelo menos em referência (trocadilhos) de passar uma matriz por referência.

É claro que existem projetos extremamente rígidos, sem alocação de heap, sem exceções e sem std :: lib. O tratamento de array nativo em C ++ é um recurso de linguagem de missão crítica, pode-se dizer.