Warum unterstützen C und C ++ die Mitgliedszuweisung von Arrays innerhalb von Strukturen, jedoch nicht generell?

Ich verstehe, dass die Mitgliedszuweisung von Arrays nicht unterstützt wird, so dass Folgendes nicht funktioniert:

int num1[3] = {1,2,3};
int num2[3];
num2 = num1; // "error: invalid array assignment"

Ich habe dies nur als Tatsache akzeptiert und festgestellt, dass das Ziel der Sprache darin besteht, ein offenes Framework bereitzustellen und den Benutzer entscheiden zu lassen, wie etwas wie das Kopieren eines Arrays implementiert werden soll.

Folgendes funktioniert jedoch:

struct myStruct { int num[3]; };
struct myStruct struct1 = {{1,2,3}};
struct myStruct struct2;
struct2 = struct1;

Das Array num[3]wird von seiner Instanz in struct1in seine Instanz in mitgliedsbezogen zugewiesen struct2.

Warum wird die Mitgliederzuweisung von Arrays für Strukturen unterstützt, jedoch nicht generell?

edit : Roger Pates Kommentar im Thread std :: string in struct - Probleme beim Kopieren / Zuweisen? scheint in die allgemeine Richtung der Antwort zu zeigen, aber ich weiß nicht genug, um es selbst zu bestätigen.

edit 2 : Viele ausgezeichnete Antworten. Ich habe mich für Luther Blissett entschieden , weil ich mich hauptsächlich über die philosophischen oder historischen Gründe für das Verhalten gewundert habe , aber auch James McNellis 'Verweis auf die zugehörige Spezifikationsdokumentation war nützlich.

Hier ist meine Meinung dazu:

Die Entwicklung der C-Sprache bietet einige Einblicke in die Entwicklung des Array-Typs in C:

• http://cm.bell-labs.com/cm/cs/who/dmr/chist.html

Ich werde versuchen, das Array zu skizzieren:

Die Vorläufer B und BCPL von C hatten keinen bestimmten Array-Typ, eine Deklaration wie:

auto V[10] (B)
or 
let V = vec 10 (BCPL)

würde V als (nicht typisierten) Zeiger deklarieren, der so initialisiert wird, dass er auf einen nicht verwendeten Bereich von 10 "Wörtern" Speicher zeigt. B bereits verwendet *für Zeiger Dereferenzierung und hatte die [] verkürzte Schreibweise, *(V+i)gemeint V[i], ebenso wie in C / C ++ heute. Ist Vjedoch kein Array, ist es immer noch ein Zeiger, der auf einen Speicher zeigen muss. Dies verursachte Probleme, als Dennis Ritchie versuchte, B mit Strukturtypen zu erweitern. Er wollte, dass Arrays Teil der Strukturen sind, wie in C heute:

struct {
    int inumber;
    char name[14];
};

Mit dem B, BCPL-Konzept von Arrays als Zeiger hätte das nameFeld jedoch einen Zeiger enthalten müssen, der zur Laufzeit auf einen Speicherbereich von 14 Bytes innerhalb der Struktur initialisiert werden musste . Das Initialisierungs- / Layoutproblem wurde schließlich gelöst, indem Arrays eine Sonderbehandlung gegeben wurden: Der Compiler verfolgte die Position von Arrays in Strukturen, auf dem Stapel usw., ohne dass der Zeiger auf die Daten tatsächlich materialisiert werden musste, außer in Ausdrücken, die die Arrays betreffen. Diese Behandlung ermöglichte es, dass fast der gesamte B-Code noch ausgeführt wird, und ist die Quelle der Regel "Arrays werden in Zeiger konvertiert, wenn Sie sie betrachten" . Es ist ein Kompatibilitäts-Hack, der sich als sehr praktisch herausstellte, da er Arrays mit offener Größe usw. erlaubte.

Und hier ist meine Vermutung, warum ein Array nicht zugewiesen werden kann: Da Arrays Zeiger in B waren, können Sie einfach schreiben:

auto V[10];
V=V+5;

ein "Array" neu zu gründen. Dies war jetzt bedeutungslos, da die Basis einer Array-Variablen kein Wert mehr war. Daher wurde diese Zuweisung nicht zugelassen, was dazu beitrug, die wenigen Programme zu erfassen, die diese Neuausrichtung auf deklarierten Arrays durchgeführt haben. Und dann blieb dieser Gedanke bestehen: Da Arrays niemals so konzipiert wurden, dass sie vom C-Typ-System erstklassig zitiert werden, wurden sie meist als spezielle Bestien behandelt, die zu Zeigern werden, wenn Sie sie verwenden. Und unter einem bestimmten Gesichtspunkt (der ignoriert, dass C-Arrays ein verpatzter Hack sind) ist es immer noch sinnvoll, die Array-Zuweisung nicht zuzulassen: Ein offenes Array oder ein Array-Funktionsparameter wird als Zeiger ohne Größeninformationen behandelt. Der Compiler verfügt nicht über die Informationen, um eine Array-Zuweisung für sie zu generieren, und die Zeigerzuweisung war aus Kompatibilitätsgründen erforderlich.

/* Example how array assignment void make things even weirder in C/C++, 
   if we don't want to break existing code.
   It's actually better to leave things as they are...
*/
typedef int vec[3];

void f(vec a, vec b) 
{
    vec x,y; 
    a=b; // pointer assignment
    x=y; // NEW! element-wise assignment
    a=x; // pointer assignment
    x=a; // NEW! element-wise assignment
}

Dies änderte sich nicht, als eine Überarbeitung von C 1978 die Strukturzuweisung hinzufügte ( http://cm.bell-labs.com/cm/cs/who/dmr/cchanges.pdf ). Obwohl Aufzeichnungen waren verschiedene Typen in C, es war nicht möglich , sie in frühen K & R C. Sie zuweisen hatte sie Mitglied weise mit memcpy zu kopieren und Sie nur Zeiger auf sie als Funktionsparameter übergeben konnte. Die Zuweisung (und Parameterübergabe) wurde nun einfach als Speicher des Rohspeichers der Struktur definiert, und da dies den vorhandenen Code nicht beschädigen konnte, wurde er leicht hinzugefügt. Als unbeabsichtigter Nebeneffekt führte dies implizit zu einer Art Array-Zuweisung, die jedoch irgendwo innerhalb einer Struktur auftrat, sodass dies nicht wirklich zu Problemen bei der Verwendung von Arrays führen konnte.

In Bezug auf die Zuweisungsoperatoren sagt der C ++ - Standard Folgendes aus (C ++ 03 §5.17 / 1):

Es gibt mehrere Zuweisungsoperatoren ... alle benötigen einen modifizierbaren l-Wert als linken Operanden

Ein Array ist kein veränderbarer Wert.

Die Zuordnung zu einem Klassentypobjekt ist jedoch speziell definiert (§5.17 / 4):

Die Zuordnung zu Objekten einer Klasse wird vom Kopierzuweisungsoperator definiert.

Wir wollen also sehen, was der implizit deklarierte Kopierzuweisungsoperator für eine Klasse tut (§12.8 / 13):

Der implizit definierte Kopierzuweisungsoperator für die Klasse X führt die Elementzuweisung seiner Unterobjekte durch. ... Jedes Unterobjekt wird in der seinem Typ entsprechenden Weise zugewiesen:
...
- Wenn das Unterobjekt ein Array ist, wird jedes Element in der dem Elementtyp entsprechenden Weise zugewiesen
...

Für ein Klassentypobjekt werden Arrays also korrekt kopiert. Beachten Sie, dass Sie dies nicht nutzen können, wenn Sie einen vom Benutzer deklarierten Kopierzuweisungsoperator angeben, und dass Sie das Array Element für Element kopieren müssen.

Die Argumentation ist in C ähnlich (C99 §6.5.16 / 2):

Ein Zuweisungsoperator muss einen modifizierbaren Wert als linken Operanden haben.

Und §6.3.2.1 / 1:

Ein modifizierbarer Wert ist ein Wert ohne Array-Typ ... [andere Einschränkungen folgen]

In C ist die Zuweisung viel einfacher als in C ++ (§6.5.16.1 / 2):

Bei der einfachen Zuweisung (=) wird der Wert des rechten Operanden in den Typ des Zuweisungsausdrucks konvertiert und ersetzt den Wert, der in dem durch den linken Operanden angegebenen Objekt gespeichert ist.

Für die Zuweisung von Objekten vom Typ Struktur müssen der linke und der rechte Operand denselben Typ haben, sodass der Wert des rechten Operanden einfach in den linken Operanden kopiert wird.

In diesem Link: http://www2.research.att.com/~bs/bs_faq2.html gibt es einen Abschnitt zur Array-Zuweisung:

Die zwei grundlegenden Probleme mit Arrays sind die folgenden

• Ein Array kennt seine eigene Größe nicht
• Der Name eines Arrays wird bei der geringsten Provokation in einen Zeiger auf sein erstes Element konvertiert

Und ich denke, das ist der grundlegende Unterschied zwischen Arrays und Strukturen. Eine Array-Variable ist ein Datenelement auf niedriger Ebene mit begrenzter Selbsterkenntnis. Grundsätzlich ist es ein Stück Speicher und eine Möglichkeit, sich darin zu indizieren.

Der Compiler kann also den Unterschied zwischen int a [10] und int b [20] nicht erkennen.

Strukturen haben jedoch nicht die gleiche Mehrdeutigkeit.

Ich weiß, jeder, der geantwortet hat, ist Experte für C / C ++. Aber ich dachte, das ist der Hauptgrund.

num2 = num1;

Hier versuchen Sie, die Basisadresse des Arrays zu ändern, was nicht zulässig ist.

und natürlich struct2 = struct1;

Hier wird das Objekt struct1 einem anderen Objekt zugewiesen.

Ein weiterer Grund , keine weiteren Anstrengungen unternommen wurden Arrays in C , zu Rindfleisch ist wahrscheinlich , dass Array Zuweisung wäre nicht , dass nützlich. Obwohl dies in C leicht erreicht werden kann, indem es in eine Struktur eingeschlossen wird (und die Adresse der Struktur einfach zur weiteren Verarbeitung in die Adresse des Arrays oder sogar in die Adresse des ersten Elements des Arrays umgewandelt werden kann), wird diese Funktion selten verwendet. Ein Grund dafür ist, dass Arrays unterschiedlicher Größe nicht kompatibel sind, was die Vorteile der Zuweisung oder der damit verbundenen Übergabe an Funktionen nach Wert einschränkt.

Die meisten Funktionen mit Array-Parametern in Sprachen, in denen Arrays erstklassige Typen sind, werden für Arrays beliebiger Größe geschrieben. Die Funktion iteriert dann normalerweise über die angegebene Anzahl von Elementen, eine Information, die das Array bereitstellt. (In C besteht die Redewendung natürlich darin, einen Zeiger und eine separate Elementanzahl zu übergeben.) Eine Funktion, die ein Array mit nur einer bestimmten Größe akzeptiert, wird nicht so oft benötigt, sodass nicht viel übersehen wird. (Dies ändert sich, wenn Sie es dem Compiler überlassen können, eine separate Funktion für jede auftretende Arraygröße zu generieren, wie bei C ++ - Vorlagen. Dies ist der Grund, warum dies std::arraynützlich ist.)