4. Direktes Setzen von Strukturelementen

Direktes Setzen von Strukturelementen

  • Q

    Wenn ich mich nicht irre,
    müsste der aufruf mit structur.att=var auch nen fehler ergeben 😮

    0
  • ?

    Jawoll, auch das funktioniert nicht!

    Wenn es nicht möglich ist, das so zu lösen wie ich gedacht hatte, muss es doch anders auch eleganter gehen, als jedes einzelne Element manuell zu setzen, oder?? Irgendeine Idee?

    Gruß
    Dominik

    0
  • B

    wie gesagt ...
    Strukturen haben eben den Sinn, dass man die Elemente mit Namen anspricht.

    0
  • G

    Mehrere Elemente des gleichen Typs kannst du natürlich als Array anlegen. Dann ist allerdings kein direktes Ansprechen über den Namen möglich.

    0
  • K

    So geht's, wenn Du die Attribute mit Namen ansprichst.
    In Person.h

    #ifndef PERSON_H
#define PERSON_H

#ifndef BOOL
#define BOOL int
#define FALSE 0
#define TRUE (!FALSE)
#endif

typedef enum _VarTyp
{
    VAR_CHAR = 1,
    VAR_INT,
    VAR_STRING
} VarTyp;

typedef union _VarWert
{
    int i;
    char c;
    char* s;
} VarWert;

typedef struct _Attr
{
    char* szVar;    /* Bezeichnung der Variablen / des Attributs */
    VarTyp eTyp;    /* int, char oder char* */
    VarWert uWert;  /* Wert des Attributs */
    BOOL bValid;    /* Flag, ob Attribut gueltig ist */
} Attr;

#define MAX_ATTR 100

struct _Person
{
    Attr aAttr[MAX_ATTR]; /* Eine Person hat eine Reihe von Attributen */
    int iAnzAttr;
    struct _Person* next;
};

typedef struct _Person Person;

Person* Person_New(void);       /* Person erzeugen */
void Person_Delete(Person*);    /* Person loeschen */
Attr* Person_GetAttr(Person*, const char*); /* Personenattribut ansprechen */
BOOL Person_SetAttr(Person*, const char*, const char*); /* Attribut setzen */
    0
  • K

    Implementierung in Person.c

    #include <stdlib.h>
#include <string.h>
#include "Person.h"

static void Person_NewAttr(Person*, const char*, VarTyp);

void Person_NewAttr(Person* _pPerson, const char* _szVar, VarTyp _eTyp)
{
    Attr* pAttr = &_pPerson->aAttr[_pPerson->iAnzAttr];
    pAttr->szVar = strdup(_szVar);
    pAttr->eTyp = _eTyp;
    pAttr->uWert.s = NULL;
    pAttr->bValid = FALSE;
    _pPerson->iAnzAttr++;
}

Attr* Person_GetAttr(Person* _pPerson, const char* _szVar)
{
    int iIndex = 0;
    Attr* pAttr;
    while(iIndex < _pPerson->iAnzAttr)
    {
        pAttr = &_pPerson->aAttr[iIndex];
        if(!stricmp(pAttr->szVar, _szVar))
            return pAttr;
        iIndex++;
    }
    return NULL;
}

BOOL Person_SetAttr(Person* _pPerson, const char* _szVar, const char* _szWert)
{
    Attr* pAttr = Person_GetAttr(_pPerson, _szVar);
    if(!pAttr)
        return FALSE;
    switch(pAttr->eTyp)
    {
    case VAR_CHAR:
        pAttr->uWert.c = *_szWert;
        break;
    case VAR_INT:
        pAttr->uWert.c = atoi(_szWert);
        break;
    case VAR_STRING:
        if(pAttr->bValid)
            free(pAttr->uWert.s);
        pAttr->uWert.s = strdup(_szWert);
        break;
    default:
        return FALSE;
    }
    pAttr->bValid = TRUE;
    return TRUE;
}

Person* Person_New(void)
{
    Person* pPerson = (Person*) malloc(sizeof(Person));
    if(pPerson)
    {
        pPerson->next = NULL;
        pPerson->iAnzAttr = 0;
        Person_NewAttr(pPerson, "id", VAR_INT);
        Person_NewAttr(pPerson, "type", VAR_CHAR);
        Person_NewAttr(pPerson, "name", VAR_STRING);
        Person_NewAttr(pPerson, "magic", VAR_INT);
        Person_NewAttr(pPerson, "mu", VAR_INT);
        Person_NewAttr(pPerson, "kl", VAR_INT);
        Person_NewAttr(pPerson, "ch", VAR_INT);
        Person_NewAttr(pPerson, "in", VAR_INT);
        Person_NewAttr(pPerson, "ff", VAR_INT);
        Person_NewAttr(pPerson, "kk", VAR_INT);
        Person_NewAttr(pPerson, "lp", VAR_INT);
        Person_NewAttr(pPerson, "lpmax", VAR_INT);
        Person_NewAttr(pPerson, "ad", VAR_INT);
        Person_NewAttr(pPerson, "admax", VAR_INT);
        Person_NewAttr(pPerson, "mr", VAR_INT);
        Person_NewAttr(pPerson, "so", VAR_INT);
        Person_NewAttr(pPerson, "ap", VAR_INT);
        Person_NewAttr(pPerson, "ag", VAR_INT);
        Person_NewAttr(pPerson, "st", VAR_INT);
        Person_NewAttr(pPerson, "last", VAR_INT);
    }
    return pPerson;
}

void Person_Delete(Person* _pPerson)
{
    int iIndex = 0;
    Attr* pAttr;
    while(iIndex < _pPerson->iAnzAttr)
    {
        pAttr = &_pPerson->aAttr[iIndex];
        free(pAttr->szVar);
        if(pAttr->eTyp == VAR_STRING)
            free(pAttr->uWert.s);
        iIndex++;
    }
    free(_pPerson);
}
    0
  • K

    Ach ja, und es gilt natürlich wie immer "Geht nicht" gibt's nicht
    MfG, Krösus

    0
  • B

    grins

    ich bin sicher, das ist genau das, was der OP sucht 😉

    0
  • K

    OP???

    0
  • B

    original poster

    usenet-slang, sorry

    0
Anmelden zum Antworten