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

Ich versuche zum zuweisen der Werte einer Struktur auf eine Karte, aber folgende Fehlermeldung erscheint nach dem kompilieren:

error: incompatible types when assigning to type ‘char[25]’ from type ‘char *’

map[i].n=m.n

Meine Struktur ist so definiert:

struct m1{
int c;
char n[25];
int q_m;
int q;};

Teil von meinem code:

    struct m1 m;
    struct m1 *map = 0;
    scanf("%d",&m.c);
    scanf("%s",&m.n);
    scanf("%d",&m.q_m);
    scanf("%d",&m.q);

    map[i].c=m.c;
    map[i].n=m.n;
    map[i].q_m=m.q_m;
    map[i].q=m.q;

InformationsquelleAutor Zombie | 2014-12-30

8

Array-Ausdrücke können nicht das Ziel eines Auftrags; die = - operator nicht definiert ist, kopieren Sie die Inhalt von einem array in das andere.

Wenn n festhalten sollte eine 0-terminierte Zeichenfolge, verwenden Sie strcpy:
```
strcpy( map[i].n, m.n );
```
Wenn n festhalten sollte, eine nicht 0-terminierte Zeichenkette (oder eine Folge von Zeichen, die mit embedded-0 Werte), verwenden Sie memcpy:
```
memcpy( map[i].n, m.n, sizeof map[i].n );
```
Es sei denn, es ist der operand der sizeof oder unäre & Betreiber, oder ein string-literal verwendet wird, zu initialisieren ein array in einer Erklärung, die einen Ausdruck vom Typ "N-element array von T" umgewandelt werden ("decay") auf einen Ausdruck vom Typ "Zeiger auf T", und der Wert des Ausdrucks wird die Adresse des ersten Elements.

Das ist, warum Sie bekam die Fehler Meldung Sie haben; der Ausdruck m.n Typ "25-element-array von char"; da es sich nicht um die Operanden der sizeof oder unäre & Betreiber, es wurde umgebaut zu Typ char *. map[i].n war nicht konvertiert (es blieb Art char [25]), aber wie ich bereits sagte, array-Ausdrücke können nicht das Ziel der Zuweisungsoperator.

Auch, nicht OP ' s zweite scanf falsch?
Yup. Ich war mit den spezifischen Fehler in der Frage, aber ja, scanf("%s",&m.n); werden muss scanf("%s", m.n);.

InformationsquelleAutor John Bode
3

Array-Variablen kann nicht sein, ein lvalue der Zuweisungsoperator, das ist, dass Sie nicht zugeordnet werden können, nichts.

Kopieren ein array zu kopieren element von element oder die Verwendung einer "low-level" - Funktion wie memcpy() zum kopieren einer bestimmten Menge an Speicher auf einmal:
```
memcpy(map[i].n, m.n, sizeof map[i].n);
```
InformationsquelleAutor alk
1

Zuerst müssen Sie Speicher für map.
```
struct m1 *map = malloc(sizeof(struct m1)); 
```
und verwenden strcpykopieren m.n zu map->n.

InformationsquelleAutor haccks
1
```
struct m1 *map;
```
map ist ein Zeiger, und man sollte reservieren von Speicher, um Sie vor etwas zu schreiben.
```
map = malloc(sizeof(struct m1) * n);
```
Dann können Sie
```
map[i]
```
Nachdem dieses Update string-copy -
```
strcpy(map[i].n,m.n);
```
InformationsquelleAutor Gopi
1

Wie es scheint, was Sie wahrscheinlich wollen, zu tun (neben der allokierung von Speicher für die Struktur), ist das kopieren der Inhalt des Arrays verweist n, anstatt nur das kopieren der eigentlichen Zeiger.
```
strcpy(map[i].n, m.n);
```
InformationsquelleAutor Tommy Andersen
0

Kopieren Sie all die Struktur der Mitglieder. Der einfachste Weg das zu tun ist:
```
map[i]=m;
```
InformationsquelleAutor Hans Klünder

Sieht aus wie Sie versuchen, zuweisen direkt m an.n-Wert in das array.
Sehen Sie bitte unten detail Beispiel :

#include<stdio.h>
#include<stdlib.h>

struct db{
    int db_num;
    char db_name[10];
};

int main()
{
    struct db *ptr;
    ptr = (struct db*)malloc(sizeof(struct db));
    ptr->db_num = 10;
    ptr->db_name = "xyz";
    printf("Input data Base:\n");
    printf("db_num:%d db_name:%s",ptr->db_num,(char*)ptr->db_name);
    return 0;
}

Im obigen code-snippet, den ich versuche zu ordnen "XYZ" an das array der Mitglied des struct db.
Durch die ähnlichen Fehler, da der ptr->db_name = "xyz";

st_dyna_mem.c:14: Fehler: unverträgliche Typen bei Zuweisung an Typ 'char[10]' vom Typ 'char *'

Update :
Für die Festsetzung dieser Art von Problem, das Sie verwenden Können, strcpy() oder memcpy().
EX:

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

struct db{
    int db_num;
    char db_name[10];
};

int main()
{
    struct db *ptr;
    ptr = (struct db*)malloc(sizeof(struct db));
    ptr->db_num = 10;
    strcpy(ptr->db_name,"xyz");
    printf("Input data Base:\n");
    printf("db_num:%d db_name:%s",ptr->db_num,(char*)ptr->db_name);
    return 0;
}

Ausgabe:
db_num:10 db_name:xyz

InformationsquelleAutor KRUPASINDHU MOHANTY

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.