¿Por qué los compiladores C y C ++ permiten longitudes de matriz en firmas de funciones cuando nunca se aplican?

Esto es lo que encontré durante mi período de aprendizaje:

#include<iostream>
using namespace std;
int dis(char a[1])
{
    int length = strlen(a);
    char c = a[2];
    return length;
}
int main()
{
    char b[4] = "abc";
    int c = dis(b);
    cout << c;
    return 0;
}  

Entonces, en la variable int dis(char a[1]), [1]parece no hacer nada y no funciona en
absoluto, porque puedo usar a[2]. Justo como int a[]o char *a. Sé que el nombre de la matriz es un puntero y cómo transmitir una matriz, por lo que mi rompecabezas no se trata de esta parte.

Lo que quiero saber es por qué los compiladores permiten este comportamiento ( int a[1]). ¿O tiene otros significados que no conozco?

Es una peculiaridad de la sintaxis para pasar matrices a funciones.

En realidad, no es posible pasar una matriz en C. Si escribe una sintaxis que parece que debería pasar la matriz, lo que realmente sucede es que se pasa un puntero al primer elemento de la matriz.

Como el puntero no incluye ninguna información de longitud, los contenidos de su []en la lista de parámetros formales de la función se ignoran realmente.

La decisión de permitir esta sintaxis se tomó en la década de 1970 y ha causado mucha confusión desde entonces ...

Se ignora la longitud de la primera dimensión, pero la longitud de las dimensiones adicionales son necesarias para permitir que el compilador calcule las compensaciones correctamente. En el siguiente ejemplo, la foofunción pasa un puntero a una matriz bidimensional.

#include <stdio.h>

void foo(int args[10][20])
{
    printf("%zd\n", sizeof(args[0]));
}

int main(int argc, char **argv)
{
    int a[2][20];
    foo(a);
    return 0;
}

El tamaño de la primera dimensión [10]se ignora; el compilador no le impedirá indexar al final (tenga en cuenta que el formal quiere 10 elementos, pero el real solo proporciona 2). Sin embargo, el tamaño de la segunda dimensión [20]se usa para determinar el paso de cada fila, y aquí, el formal debe coincidir con el real. Nuevamente, el compilador tampoco le impedirá indexar el final de la segunda dimensión.

El desplazamiento de bytes desde la base de la matriz a un elemento args[row][col]está determinado por:

sizeof(int)*(col + 20*row)

Tenga en cuenta que si col >= 20, en realidad se indexará en una fila posterior (o fuera del final de toda la matriz).

sizeof(args[0]), vuelve 80a mi máquina donde sizeof(int) == 4. Sin embargo, si intento tomar sizeof(args), me sale la siguiente advertencia del compilador:

foo.c:5:27: warning: sizeof on array function parameter will return size of 'int (*)[20]' instead of 'int [10][20]' [-Wsizeof-array-argument]
    printf("%zd\n", sizeof(args));
                          ^
foo.c:3:14: note: declared here
void foo(int args[10][20])
             ^
1 warning generated.

Aquí, el compilador advierte que solo dará el tamaño del puntero en el que la matriz se ha descompuesto en lugar del tamaño de la matriz misma.

El problema y cómo superarlo en C ++

El problema ha sido explicado ampliamente por Pat y Matt . El compilador básicamente ignora la primera dimensión del tamaño de la matriz, ignorando efectivamente el tamaño del argumento pasado.

En C ++, por otro lado, puede superar fácilmente esta limitación de dos maneras:

• utilizando referencias
• utilizando std::array(desde C ++ 11)

Referencias

Si su función solo intenta leer o modificar una matriz existente (sin copiarla), puede usar referencias fácilmente.

Por ejemplo, supongamos que desea tener una función que restablezca una matriz de diez ints configurando cada elemento 0. Puede hacerlo fácilmente utilizando la siguiente firma de función:

void reset(int (&array)[10]) { ... }

No solo esto funcionará bien , sino que también impondrá la dimensión de la matriz .

También puede utilizar plantillas para hacer que el código anterior sea genérico :

template<class Type, std::size_t N>
void reset(Type (&array)[N]) { ... }

Y finalmente puedes aprovechar la constcorrección. Consideremos una función que imprime una matriz de 10 elementos:

void show(const int (&array)[10]) { ... }

Al aplicar el constcalificador estamos evitando posibles modificaciones .

La clase de biblioteca estándar para matrices.

Si considera que la sintaxis anterior es fea e innecesaria, como lo hago yo, podemos lanzarla a la lata y usarla std::arrayen su lugar (desde C ++ 11).

Aquí está el código refactorizado:

void reset(std::array<int, 10>& array) { ... }
void show(std::array<int, 10> const& array) { ... }

¿No es maravilloso? Sin mencionar que el truco de código genérico que te enseñé anteriormente, todavía funciona:

template<class Type, std::size_t N>
void reset(std::array<Type, N>& array) { ... }

template<class Type, std::size_t N>
void show(const std::array<Type, N>& array) { ... }

No solo eso, sino que obtienes copias y movimientos semánticos gratis. :)

void copy(std::array<Type, N> array) {
    // a copy of the original passed array 
    // is made and can be dealt with indipendently
    // from the original
}

¿Entonces, Qué esperas? Ve a usar std::array.

Es una característica divertida de C que te permite dispararte efectivamente en el pie si estás tan inclinado.

Creo que la razón es que C está solo un paso por encima del lenguaje ensamblador. La comprobación de tamaño y características de seguridad similares se han eliminado para permitir el máximo rendimiento, lo que no es malo si el programador es muy diligente.

Además, asignar un tamaño al argumento de la función tiene la ventaja de que cuando otro programador utiliza la función, existe la posibilidad de que noten una restricción de tamaño. Solo usar un puntero no transmite esa información al siguiente programador.

Primero, C nunca verifica los límites de la matriz. No importa si son parámetros locales, globales, estáticos, lo que sea. Verificar los límites de la matriz significa más procesamiento, y se supone que C es muy eficiente, por lo que el programador realiza la verificación de los límites de la matriz cuando es necesario.

En segundo lugar, hay un truco que hace posible pasar una matriz por valor a una función. También es posible devolver por valor una matriz de una función. Solo necesita crear un nuevo tipo de datos usando struct. Por ejemplo:

typedef struct {
  int a[10];
} myarray_t;

myarray_t my_function(myarray_t foo) {

  myarray_t bar;

  ...

  return bar;

}

Tienes que acceder a los elementos de esta manera: foo.a [1]. El ".a" adicional puede parecer extraño, pero este truco agrega una gran funcionalidad al lenguaje C.

Para decirle al compilador que myArray apunta a una matriz de al menos 10 ints:

void bar(int myArray[static 10])

Un buen compilador debería avisarle si accede a myArray [10]. Sin la palabra clave "estática", el 10 no significaría nada en absoluto.

Esta es una "característica" bien conocida de C, que se pasa a C ++ porque se supone que C ++ compila correctamente el código C.

El problema surge de varios aspectos:

1. Se supone que un nombre de matriz es completamente equivalente a un puntero.
2. Se supone que C es rápido, originalmente desarrollado para ser una especie de "ensamblador de alto nivel" (especialmente diseñado para escribir el primer "sistema operativo portátil": Unix), por lo que no se supone que inserte código "oculto"; la comprobación del rango de tiempo de ejecución está "prohibida".
3. El código de máquina generado para acceder a una matriz estática o dinámica (ya sea en la pila o asignado) es realmente diferente.
4. Dado que la función llamada no puede conocer el "tipo" de matriz que se pasa como argumento, se supone que todo es un puntero y se trata como tal.

Se podría decir que las matrices no son realmente compatibles en C (esto no es realmente cierto, como decía antes, pero es una buena aproximación); Una matriz se trata realmente como un puntero a un bloque de datos y se accede mediante la aritmética del puntero. Como C NO tiene ninguna forma de RTTI, debe declarar el tamaño del elemento de matriz en el prototipo de la función (para admitir la aritmética del puntero). Esto es incluso "más cierto" para las matrices multidimensionales.

De todos modos, todo lo anterior ya no es realmente cierto: p

La mayoría de los compiladores modernos C / C ++ hacen los límites de soporte de cheques, pero las normas exigen que sea desactivada por defecto (por compatibilidad con versiones anteriores). Las versiones razonablemente recientes de gcc, por ejemplo, realizan la comprobación del rango de tiempo de compilación con "-O3 -Wall -Wextra" y la comprobación de límites de tiempo de ejecución completo con "-fbounds-Check".

C no solo transformará un parámetro de tipo int[5]en *int; dada la declaracióntypedef int intArray5[5]; , se va a transformar un parámetro de tipo intArray5a *inttambién. Hay algunas situaciones en las que este comportamiento, aunque extraño, es útil (especialmente con cosas como las va_listdefinidas en stdargs.h, que algunas implementaciones definen como una matriz). Sería ilógico permitir como parámetro un tipo definido como int[5](ignorando la dimensión) pero no permitir int[5]que se especifique directamente.

Encuentro que el manejo de C de los parámetros de tipo de matriz es absurdo, pero es una consecuencia de los esfuerzos por adoptar un lenguaje ad-hoc, gran parte del cual no estaba particularmente bien definido o pensado, y tratar de llegar a un comportamiento. especificaciones que son consistentes con lo que hicieron las implementaciones existentes para los programas existentes. Muchas de las peculiaridades de C tienen sentido cuando se miran desde esa perspectiva, particularmente si se considera que cuando se inventaron muchas de ellas, grandes partes del lenguaje que conocemos hoy todavía no existían. Por lo que entiendo, en el predecesor de C, llamado BCPL, los compiladores realmente no registraban muy bien los tipos de variables. Una declaración int arr[5];era equivalente a int anonymousAllocation[5],*arr = anonymousAllocation;; una vez que se asignó la asignación. el compilador no sabía ni le importaba siarrera un puntero o una matriz. Cuando se accede como cualquieraarr[x] o*arr, se consideraría como un puntero independientemente de cómo se declarara.

Una cosa que aún no ha sido respondida es la pregunta real.

Las respuestas ya dadas explican que las matrices no se pueden pasar por valor a una función en C o C ++. También explican que un parámetro declarado como int[]se trata como si tuviera tipo int *, y que una variable de tipoint[] se puede pasar a dicha función.

Pero no explican por qué nunca se ha cometido un error al proporcionar explícitamente una longitud de matriz.

void f(int *); // makes perfect sense
void f(int []); // sort of makes sense
void f(int [10]); // makes no sense

¿Por qué el último de estos no es un error?

Una razón para eso es que causa problemas con typedefs.

typedef int myarray[10];
void f(myarray array);

Si fuera un error especificar la longitud de la matriz en los parámetros de la función, no podría usar el myarraynombre en el parámetro de la función. Y dado que algunas implementaciones usan tipos de matriz para tipos de biblioteca estándar como va_list, y se requieren todas las implementaciones para hacer jmp_bufun tipo de matriz, sería muy problemático si no hubiera una forma estándar de declarar parámetros de función usando esos nombres: sin esa capacidad, podría haber No ser una implementación portátil de funciones como vprintf.

Está permitido que los compiladores puedan verificar si el tamaño de la matriz aprobada es el mismo que el esperado. Los compiladores pueden advertir un problema si no es el caso.