Wenn eine Funktion einen Array-Parameter bestimmter Größe hat, warum wird sie durch einen Zeiger ersetzt?

Angesichts des folgenden Programms,

#include <iostream>

using namespace std;

void foo( char a[100] )
{
    cout << "foo() " << sizeof( a ) << endl;
}

int main()
{
    char bar[100] = { 0 };
    cout << "main() " << sizeof( bar ) << endl;
    foo( bar );
    return 0;
}

Ausgänge

main() 100
foo() 4

1. Warum wird das Array als Zeiger auf das erste Element übergeben?
2. Ist es ein Erbe von C?
3. Was sagt der Standard?
4. Warum wird die strikte Typensicherheit von C ++ aufgehoben?

Ja, es ist von C geerbt. Die Funktion:

void foo ( char a[100] );

Wird der Parameter als Zeiger angepasst und wird so:

void foo ( char * a );

Wenn Sie möchten, dass der Array-Typ erhalten bleibt, sollten Sie einen Verweis auf das Array übergeben:

void foo ( char (&a)[100] );

C ++ '03 8.3.5 / 3:

... Der Typ einer Funktion wird nach folgenden Regeln bestimmt. Der Typ jedes Parameters wird aus seiner eigenen Deklarationsspezifizierer-Sequenz und seinem eigenen Deklarator bestimmt. Nach dem Bestimmen des Typs jedes Parameters wird jeder Parameter vom Typ "Array von T" oder "Funktion, die T zurückgibt" so eingestellt, dass er "Zeiger auf T" bzw. "Zeiger auf Funktion, die T zurückgibt" ist ....

So erklären Sie die Syntax:

Suchen Sie in Google nach der Regel "rechts-links". Ich habe hier eine Beschreibung gefunden .

Es würde ungefähr wie folgt auf dieses Beispiel angewendet:

void foo (char (&a)[100]);

Beginnen Sie mit der Kennung 'a'

'a' ist a

Bewegen Sie sich nach rechts - wir finden eine, )also kehren wir die Richtung um und suchen nach dem (. Wenn wir uns nach links bewegen, gehen wir vorbei&

'a' ist eine Referenz

Nach dem &erreichen wir die Öffnung, (also kehren wir wieder um und schauen nach rechts. Wir sehen jetzt[100]

'a' ist eine Referenz auf ein Array von 100

Und wir kehren die Richtung wieder um, bis wir erreichen char:

'a' ist eine Referenz auf ein Array von 100 Zeichen

Ja. In C und C ++ können Sie keine Arrays an Funktionen übergeben. So ist es halt.

Warum machst du überhaupt einfache Arrays? Hast du dir boost/ std::tr1::array/ std::arrayoder angesehen std::vector?

Beachten Sie, dass Sie kann jedoch eine Referenz auf ein Array von beliebiger Länge an eine Funktion Vorlage . Aus dem Kopf:

template< std::size_t N >
void f(char (&arr)[N])
{
  std::cout << sizeof(arr) << '\n';
}

In der C / C ++ - Terminologie gibt es ein großartiges Wort, das für statische Arrays und Funktionszeiger verwendet wird - Zerfall . Betrachten Sie den folgenden Code:

int intArray[] = {1, 3, 5, 7, 11}; // static array of 5 ints
//...
void f(int a[]) {
  // ...
}
// ...
f(intArray); // only pointer to the first array element is passed
int length = sizeof intArray/sizeof(int); // calculate intArray elements quantity (equals 5)
int ptrToIntSize = sizeof(*intArray); // calculate int * size on your system