Warum können keine arrays übergeben werden, die als Funktion der Argumente?

Warum können keine arrays übergeben werden, die als Funktion der Argumente?

Können Sie:

void foo(const int (&myArray)[5]) {
   //`myArray` is the original array of five integers
}

In technischer Hinsicht, die Art der Argumentation foo ist "Verweis auf ein array von 5 const ints"; mit Referenzen, dann können wir auch die tatsächlichen Objekt um (Haftungsausschluss: Terminologie variiert je nach Abstraktionsebene).

Was Sie nicht tun können, ist pass von Wert, weil aus historischen Gründen sind wir nicht kopieren arrays. Stattdessen, versuchen, übergeben Sie ein array als Wert in eine Funktion (oder, übergeben kopieren eines Arrays) führt seinen Namen Zerfall in einen Zeiger. (einige Ressourcen, die verstehen das falsch!)

Array-Namen zerfallen zu Zeigern für pass-by-value

Bedeutet dies:

void foo(int* ptr);

int ar[10]; //an array
foo(ar);    //automatically passing ptr to first element of ar (i.e. &ar[0])

Gibt es auch die äusserst irreführend sind "syntaktischer Zucker", die sieht wie können Sie übergeben Sie ein array von beliebiger Länge durch Wert:

void foo(int ptr[]);

int ar[10]; //an array
foo(ar);

Aber, tatsächlich, du bist immer noch nur auf der Durchreise zu einem Zeiger (auf das erste element ar). foo ist die gleiche wie oben!

Während wir gerade dabei sind, die folgende Funktion auch nicht wirklich die Handschrift, so scheint es. Schauen Sie, was passiert, wenn wir versuchen, diese Funktion aufrufen, ohne es zu definieren:

void foo(int ar[5]);
int main() {
   int ar[5];
   foo(ar);
}

//error: undefined reference to `func(int*)'

So foo nimmt int* in der Tat nicht int[5]!

(Live-demo.)

Aber man kann-um es!

Können Sie hack, um dieses durch die Verpackung des Arrays in einer struct oder class, da die Standard-copy-operator wird copy-array:

struct Array_by_val
{
  int my_array[10];
};

void func (Array_by_val x) {}

int main() {
   Array_by_val x;
   func(x);
}

Dies ist etwas verwirrend Verhalten.

Oder, besser, eine generische pass-by-reference-Ansatz

In C++ mit template-Magie, die wir machen können, eine Funktion sowohl wieder verwendbar und in der Lage zu erhalten ein array:

template <typename T, size_t N>
void foo(const T (&myArray)[N]) {
   //`myArray` is the original array of N Ts
}

Aber wir können noch nicht übergeben Sie einen Wert. Etwas zu erinnern.

Die Zukunft...

Und seit C++11 ist knapp über dem Horizont, und C++0x support kommen zusammen schön in den mainstream-toolchains, können Sie die schöne std::array geerbt, die von Boost! Ich lasse die Erforschung, die als übung für den Leser.

Arrays sind in ein Gefühl zweiter Klasse Typen, etwas, was C++ geerbt von C.

Zitieren 6.3.2.1p3 in der C99-standard:

Außer, wenn es ist der operand der sizeof der unäre operator oder
& - operator, oder ist ein string-literal verwendet, um ein array zu initialisieren, eine
Ausdruck, der den Typ "array von Typ" umgewandelt
Ausdruck vom Typ "Zeiger auf Typ", zeigt auf die erste
element des array-Objekts und ist nicht ein lvalue. Wenn das array-Objekt
hat registrieren storage-Klasse, ist das Verhalten undefiniert.

Gleichen Absatz in der C11-standard ist im wesentlichen der gleiche, mit dem Zusatz von der neuen _Alignof Betreiber. (Beide links sind Entwürfe, die sehr nah an den offiziellen standards. (UPDATE: Das war tatsächlich ein Fehler in der N1570 Entwurf, korrigiert, veröffentlicht in der C11-standard. _Alignof können, werden nicht angewandt auf einen Ausdruck, nur eine in Klammern eingeschlossene Typ-Namen, also C11 hat nur die gleichen 3 Ausnahmen, die C99 und C90 hat. (Aber ich schweife ab.)))

Habe ich nicht die entsprechenden C++ citation praktisch, aber ich glaube, es ist ziemlich ähnlich.

Also, wenn arr ist ein array-Objekt, und rufen Sie eine Funktion func(arr), dann func erhalten einen Zeiger auf das erste element arr.

Bislang ist dies mehr oder weniger "funktioniert es so, weil es ist definiert, der Weg", aber es gibt historische und technische Gründe.

Erlaubt array-Parameter würde nicht zulassen, dass für viel Flexibilität (ohne weitere änderungen an der Sprache), da zum Beispiel char[5] und char[6] sind unterschiedliche Typen. Auch die übergabe von arrays per Referenz nicht helfen (es sei denn, es gibt einige C++ - Funktion fehlt mir, immer eine Möglichkeit). Übergabe von Zeigern gibt Ihnen enorme Flexibilität (vielleicht zu viel!). Der pointer auf das erste element eines Arrays beliebiger Größe-aber du musst Rollen Sie Ihre eigenen Mechanismus zu sagen, die Funktion, wie groß das array ist.

Entwerfen einer Sprache, so dass arrays von verschiedenen Längen sind einigermaßen kompatibel, während immer noch ausgeprägt ist tatsächlich ziemlich verzwickt. In Ada zum Beispiel, die äquivalente char[5] und char[6] sind die gleichen Typ, aber unterschiedliche Subtypen. Dynamischer Sprachen stellen Sie die Länge ein Teil eines array-Objekts den Wert, nicht von seinem Typ ab. C noch ziemlich viel muddles zusammen mit expliziten Zeigern und Längen, oder Zeiger und terminatoren. C++ geerbt alle, die Gepäck von C. Es meist Stakte auf die gesamte array-Sache eingeführt und Vektoren, also es war nicht so viel brauchen, um arrays erste-Klasse-Typen.

TL;DR: Das ist C++, sollten Sie mit Hilfe von Vektoren sowieso! (Gut, manchmal.)

Ich glaube, der Grund, warum C++ war dies, wenn es erstellt wurde, dass es hätte zu viele Ressourcen zu senden, die das gesamte array anstatt die Adresse im Speicher. Das sind lediglich meine Gedanken zu dem Thema und eine Annahme.