Weisen Sie in C eine Struktur einer anderen zu

Können Sie eine Instanz einer Struktur einer anderen zuweisen, etwa so:

struct Test t1;
struct Test t2;
t2 = t1;

Ich habe gesehen, dass es für einfache Strukturen funktioniert, aber funktioniert es für komplexe Strukturen?
Woher weiß der Compiler, wie er Datenelemente abhängig von ihrem Typ kopiert, dh zwischen an unterscheidet int und Schnur?

Ja, wenn die Struktur vom gleichen Typ ist. Betrachten Sie es als eine Speicherkopie.

Ja, die Zuweisung wird für Strukturen unterstützt. Allerdings gibt es Probleme:

struct S {
   char * p;
};

struct S s1, s2;
s1.p = malloc(100);
s2 = s1;

Jetzt zeigen die Zeiger beider Strukturen auf denselben Speicherblock – der Compiler kopiert die Daten, auf die gezeigt wird, nicht. Es ist jetzt schwierig zu wissen, welcher Strukturinstanz die Daten gehören. Aus diesem Grund hat C++ das Konzept der benutzerdefinierbaren Zuweisungsoperatoren erfunden – Sie können spezifischen Code schreiben, um diesen Fall zu handhaben.

Schauen Sie sich zuerst dieses Beispiel an:

Der C-Code für ein einfaches C-Programm ist unten angegeben

struct Foo {
    char a;
    int b;
    double c;
} foo1, foo2;

void foo_assign(void)
{
    foo1 = foo2;
}

int main(/*char *argv[],int argc*/)
{
    foo_assign();
    return 0;
}

Der äquivalente ASM-Code für foo_assign() ist

00401050 <_foo_assign>:
  401050:   55                      push   %ebp
  401051:   89 e5                   mov    %esp,%ebp
  401053:   a1 20 20 40 00          mov    0x402020,%eax
  401058:   a3 30 20 40 00          mov    %eax,0x402030
  40105d:   a1 24 20 40 00          mov    0x402024,%eax
  401062:   a3 34 20 40 00          mov    %eax,0x402034
  401067:   a1 28 20 40 00          mov    0x402028,%eax
  40106c:   a3 38 20 40 00          mov    %eax,0x402038
  401071:   a1 2c 20 40 00          mov    0x40202c,%eax
  401076:   a3 3c 20 40 00          mov    %eax,0x40203c
  40107b:   5d                      pop    %ebp
  40107c:   c3                      ret    

Wie Sie sehen können, wird eine Zuweisung einfach durch eine “mov”-Anweisung in Assembler ersetzt, der Zuweisungsoperator bedeutet einfach, Daten von einem Speicherplatz zu einem anderen Speicherplatz zu verschieben. Die Zuweisung tut dies nur für unmittelbare Mitglieder einer Struktur und kann nicht kopiert werden, wenn Sie komplexe Datentypen in einer Struktur haben. Hier bedeutet KOMPLEX, dass Sie kein Array von Zeigern haben können, die auf Listen zeigen.

Ein Array von Zeichen innerhalb einer Struktur funktioniert selbst auf den meisten Compilern nicht, da die Zuweisung einfach versucht, zu kopieren, ohne den Datentyp auch nur als komplexen Typ zu betrachten.

Dies ist eine einfache Kopie, genau wie Sie es tun würden memcpy() (in der Tat erzeugen einige Compiler tatsächlich einen Aufruf an memcpy() für diesen Code). Es gibt keinen “String” in C, nur Zeiger auf ein paar Zeichen. Wenn Ihre Quellstruktur einen solchen Zeiger enthält, wird der Zeiger kopiert, nicht die Zeichen selbst.

Meinten Sie “komplex” wie in komplexen Zahlen mit Real- und Imaginärteil? Dies erscheint unwahrscheinlich, wenn nicht, müssten Sie ein Beispiel geben, da “komplex” in Bezug auf die C-Sprache nichts Besonderes bedeutet.

Sie erhalten eine direkte Speicherkopie der Struktur; ob man das will, hängt von der Struktur ab. Wenn die Struktur beispielsweise einen Zeiger enthält, zeigen beide Kopien auf dieselben Daten. Dies kann oder kann nicht das sein, was Sie wollen; das liegt an Ihrem Programmdesign.

Um eine „intelligente“ Kopie (oder eine „tiefe“ Kopie) durchzuführen, müssen Sie eine Funktion implementieren, um die Kopie durchzuführen. Dies kann sehr schwierig zu erreichen sein, wenn die Struktur selbst Zeiger und Strukturen enthält, die ebenfalls Zeiger enthalten, und möglicherweise Zeiger auf solche Strukturen (vielleicht meinen Sie das mit „komplex“), und es ist schwer zu warten. Die einfache Lösung besteht darin, C++ zu verwenden und Kopierkonstruktoren und Zuweisungsoperatoren für jede Struktur oder Klasse zu implementieren, dann wird jede für ihre eigene Kopiersemantik verantwortlich, Sie können Zuweisungssyntax verwenden, und sie ist einfacher zu verwalten.

Ja, Sie können eine Instanz einer Struktur einer anderen zuweisen, indem Sie eine einfache Zuweisungsanweisung verwenden.

• Im Fall von Nicht-Zeigern oder Nicht-Zeigern, die Strukturmitglieder enthalten, bedeutet Zuweisung Kopieren.

• Im Fall von Zeigerstrukturmitgliedern bedeutet Zuweisung, dass der Zeiger auf die gleiche Adresse wie der andere Zeiger zeigt.

Lassen Sie uns das aus erster Hand sehen:

#include <stdio.h>

struct Test{
    int foo;
    char *bar;
};

int main(){
    struct Test t1;
    struct Test t2;
    t1.foo = 1;
    t1.bar = malloc(100 * sizeof(char));
    strcpy(t1.bar, "t1 bar value");
    t2.foo = 2;
    t2.bar = malloc(100 * sizeof(char));
    strcpy(t2.bar, "t2 bar value");
    printf("t2 foo and bar before copy: %d %s\n", t2.foo, t2.bar);
    t2 = t1;// <---- ASSIGNMENT
    printf("t2 foo and bar after copy: %d %s\n", t2.foo, t2.bar);
    //The following 3 lines of code demonstrate that foo is deep copied and bar is shallow copied
    strcpy(t1.bar, "t1 bar value changed");
    t1.foo = 3;
    printf("t2 foo and bar after t1 is altered: %d %s\n", t2.foo, t2.bar);
    return 0;
}