In C, warum kann ich nicht zuordnen, einen string in ein char-array, nachdem es erklärt?

Diese wurde Lauschangriff mich für eine Weile.

struct person {
       char name[15];
       int age;
};
struct person me;
me.name = "nikol";

wenn ich compile bekomme ich diesen Fehler:

Fehler: unverträgliche Typen bei Zuweisung an Typ 'char[15]' vom Typ 'char *'

übersehe ich etwas offensichtliches hier?

Fragen Sie, wie man die Initialisierung? struct person me = {"nikol", 3}; funktionieren sollte.
Ähnlich: stackoverflow.com/questions/14826952/...
auch hier. Disclaimer: Meine Antwort

InformationsquelleAutor Kok Nikol | 2014-11-01

16

Arrays sind Bürger zweiter Klasse in C, Sie unterstützen keine Zuordnung.
```
char x[] = "This is initialization, not assignment, thus ok.";
```
Funktioniert nicht:
```
x = "Compilation-error here, tried to assign to an array.";
```
Verwendung library-Funktionen oder kopieren Sie manuell jedes element für sich:
```
#include <string.h>
strcpy(x, "The library-solution to string-assignment.");
```
- Ich Durcheinander Initialisierung und Zuweisung, sorry. Ja, das löst es, danke. Ich führte den falschen Weg, indem Sie ein Beispiel aus dem Lehrer (was ich jetzt sehe, ist falsch).
InformationsquelleAutor Deduplicator
5

me.name = "nikol"; ist falsch !! Sie benötigen strcpy()

wenn Sie x = "Some String" eigentlich sind Sie setzen der Startadresse des static string "Some String" in variable x. In deinem Fall name ist ein statisches array, und Sie können nicht ändern Sie die Adresse. Was Sie brauchen, ist zum kopieren der Zeichenfolge an die bereits reservierten Arrays name. Für, die, Nutzung strcpy().

InformationsquelleAutor Sourav Ghosh
3

Erste von allen, müssen Sie wissen, die folgenden Punkte:
- In C -, text-strings sind einfach arrays.
- In C sind array-Variablen sind im Grunde nur Hinweise.
So, char mytext[12]; ist im Grunde nur die Deklaration einer char-Zeiger genannt mytext speichert die Adresse des ersten (null, ' te) element des array/string.

Dieser code ist daher gültig:
```
#include <stdio.h>
int main(int argc, char *argv[])
{
    const char a[] = "Hello";
    const char *b = a;
    printf("%s\n", b);
    return 0;
}
```
Die wichtige Sache zu beachten ist hier, dass re-zuweisen b ändert nichts an der Inhalt, was es Punkte zu - es ändert sich die Sache, dass es Punkte zu.

Gibt es jedoch sind Fällen, in denen arrays und Zeiger Verhalten sich anders. Im obigen Beispiel a kann nicht neu zugewiesen werden. Wenn Sie versuchen, Sie erhalten eine Fehlermeldung.

Zurück, um Sie ursprüngliche Beispiel dieser Struktur:
```
struct person{
    char name[15];
    int age;
};
```
...gedacht werden kann, als ein 19-byte-Struktur* von denen die ersten 15 bytes sind vorgesehen zum speichern einer Zeichenfolge. Die name Attribut speichert die Adresse des ersten Bytes, damit Sie wissen, wo diese 15 bytes live in Gedächtnis - Sie brauchen nur zu schreiben, etwas sinnvolles in Sie.

Dies ist, wo Funktionen wie sprintf() oder strcpy() ins Spiel kommen - Sie kopieren von Daten in die Adresse definiert durch name eher als re-zuweisen name selbst.

* Unter der Annahme, dass sizeof(int) ist 4 und die Struktur ist nicht gepolstert, natürlich...
- die Größe der Beispiel-struct ist 20 Bytes. Es ist ein padding byte zwischen dem array und der int.
- Sie sind in der Tat richtige - werde ich Bearbeiten, meine Antwort entsprechend.
- Eigentlich war ich das erste mal richtig - es ist 19 bytes ohne Polsterung, als ich sagte, ursprünglich.
- Arrays sind keine Zeiger.
- James, ich habe nicht gesagt, dass Sie identisch waren (daher, warum ich betonte das Wort grundsätzlich in meine zweite Kugel-Punkt, und wies darauf hin, dass "es gibt Fälle, in denen arrays und Zeiger Verhalten sich anders," zu einem späteren Zeitpunkt), aber bitte fühlen Sie sich frei zu Bearbeiten die post, wenn Sie denken, dass die Antwort, die ich gab, könnte für mehr Klarheit in diesem Punkt.
- Sie sind auf einen wirklich schlechten start, wenn Sie nicht die Unterscheidung zwischen arrays und Zeigern. Und in C sind strings 0-terminiert-Sequenzen.
- Ich weiß jetzt den Unterschied. Danke für den Hinweis it out
- Eigentlich meinte ich GoBusto, als seine post nicht wirklich widerspiegeln. Ja, er später erwähnt ein Unterschied, aber das ist zu wenig (es gibt mehrere) und zu spät (er legt den Ton am start, und zu viele werden das vermissen).
InformationsquelleAutor GoBusto
0

Initialisierung:
```
char name[15]
```
ist das erstellen eines char-array, 15 bytes in der Größe.

"nikol" ist ein string-literal, das ist vom Typ 'char *' ist, d.h. einen Zeiger auf einen string. Sie sind inkompatible Typen. Sie müssen kopieren Sie die Zeichenfolge in das array eingefügt werden, etwa so:
```
strcpy(me.name, "nikol")
```
InformationsquelleAutor Brett
-1

Verwenden strcpy() - Funktion (von string.h Bibliothek) 🙂
```
main(){
struct person{
       char name[15];
       int age;
};
struct person me;
strcpy(me.name,"nikol");
}
```
- FYI: string.h ist der Kopf, nicht eine Bibliothek.
InformationsquelleAutor LucaLumetti
-1

Sie versuchen, ändern Sie die Speicher-Adresse eines array-pointer (durch das geben von mir.name = "nikol"), die unmöglich ist. Name des array (mich.name) ist ein fester Zeiger und kann nicht geändert werden, um den Punkt an eine neue Position der Zeichenkette ("nikol"), weil die Speicher-Adresse von einem array-Zeiger auf das erste Element des Arrays. Wenn Sie möchten, weisen Sie einen string nach erklärt (mich.name = "nikol"), die Nutzung externer Zeiger *Namen statt, da externe Zeiger schwebt außerhalb array, so dass sein Wert kann geändert werden on-the-fly.
```
struct person {
       char *name;
       int age;
};
struct person me;
me.name = "nikol"; //no error
```
InformationsquelleAutor Ray Chakrit

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.