Uso da palavra-chave const com ponteiros de array em C

Então, segundo os autores, ambos int * const arraye int *array são equivalentes a int array[].

Parcialmente.

• void foo(int array[])e void foo(int *array)significa exatamente a mesma coisa
• int * const arrayé algo diferente: arrayé constum ponteiro paraint

A posição das constquestões:

• const int *array; - arrayé um ponteiro paraconst int
• int * const array;- arrayé um constponteiro paraint
• const int * const array;- arrayé um constponteiro paraconst int

Como os nomes de array são ponteiros constantes para o primeiro elemento do array,

Não, não são. Arrays decaem para ponteiros para seu primeiro elemento quando usados ​​em expressões ou como parâmetros de função. Mas não constponteiros

Conclusão:

void foo(int array[])
void foo(int *array)

faça o mesmo

Estes:

void foo(int array[])
void foo(int *const array)

Não, pois o parâmetro tem um tipo diferente.

Como os nomes de array são ponteiros constantes para o primeiro elemento do array…

Isto é falso. Um array é frequentemente convertido em um ponteiro para seu primeiro elemento (mas nem sempre), e isso pode levar os alunos a pensar em um array como um ponteiro, mas não é. Existem diferenças importantes. sizeof arraypara um array e sizeof ppara um ponteiro são coisas diferentes e não podem ser usados ​​de forma intercambiável. Um array não é convertido em um ponteiro quando é o operando de sizeof, é o operando de um operador typeof, é o operando de unário &ou é um literal de string usado para inicializar um array.

"Quando o compilador encontra um parâmetro de função para um array unidimensional da forma int b[], o compilador converte o parâmetro para a notação de ponteiro int *b. As duas formas são intercambiáveis".

Esta é uma declaração incorreta dos autores em dois aspectos. Primeiro, esta mudança de um parâmetro de array para um parâmetro de ponteiro é chamada de ajuste, não de conversão. Isto porque “conversões” em C se referem a operações em valores, mas esta é uma mudança no tipo de uma função, não uma conversão de valores. Segundo, o ajuste é realizado na representação interna da função do compilador. Não é um ajuste a notação usada no código-fonte. O compilador muda suas estruturas de dados internas para registrar que o parâmetro é um ponteiro. É improvável que um compilador realmente use a notação int b[]ou int *bpara registrar esta informação.

Então, segundo os autores, ambos int * const arraye int *arraysão equivalentes a int array[].

Sua declaração “Como nomes de array são ponteiros constantes…” estava fora das aspas, então você não a atribuiu aos autores. O texto que você citou não disse que nomes de array são ponteiros constantes, e duvido que o livro diga isso em algum lugar. Se disser, você deve citar essa passagem.

O texto citado diz “essas notações são intercambiáveis”, mas isso é apenas no contexto de uma declaração de parâmetro de função, e significa que uma declaração de um array será ajustada para ser uma declaração de um parâmetro. Isso é diferente de dizer que um array é equivalente a um ponteiro constante.

Quando o ajuste de um parâmetro de array para um parâmetro de ponteiro é realizado, constnão é adicionado. Dentro do corpo de uma função declarada com void foo(size_t size, int array[]), o tipo de arrayé int *, e pode ser alterado. array += 1mudaria arraypara apontar para o próximo elemento no array, e isso é código C totalmente definido válido (desde que arraynão estivesse já apontando para o fim do array).

Um parâmetro de array pode ser declarado constcolocando constdentro dos colchetes: int array[const]. Então esta declaração de parâmetro será ajustada para declarar um constponteiro para int.

Tanto a formulação de Deitel quanto sua compreensão estão um pouco confusas.

Primeiro de tudo, vamos falar sobre o que

int * const array

na verdade faz -- ele irá disparar um diagnóstico se você tentar escrever para array(alterando-o para apontar para outra coisa). Ele permite que você escreva

array[i] = some_int_value;

enquanto não permite

array = some_pointer_value;

IOW, isso previne que você acidentalmente sobrecarregue seu arrayponteiro no corpo da função. Fazer isso não afetará o array apontado, mas não será ideal para sua função funcionar corretamente.

No entanto, não é equivalente a

int array[]

que é "ajustado" para

int *array

não

int * const array

A declaração de parâmetro equivalente usando notação de matriz seria na verdade

int array[const]

Os nomes de array não são ponteiros; quando você declara um array como

int arr[SOME_SIZE];

isto é o que você obtém na memória (os endereços são apenas para ilustração e não refletem nenhuma plataforma real):

               +---+
0x8000    arr: |   | arr[0]
               +---+
0x8004         |   | arr[1]
               +---+
0x8008         |   | arr[2]
               +---+
                ...

Nenhum armazenamento é reservado para um valor de ponteiro; arr é o array. Na maioria das circunstâncias , o compilador avaliará a expressão arr como algo equivalente a &arr[0]; as exceções a esta regra ocorrem quando

• a expressão de matriz é o operando dos operadores sizeof, typeof, typeof_unequal, ou unários ;&
• a expressão de matriz é uma string literal usada para inicializar uma matriz de caracteres em uma declaração;

Então se você tem uma matriz

int arr[N];

e você escreve

bubbleSort( arr, N );

o compilador gera código equivalente a

bubbleSort( &arr[0], N );