tabelle aus struct erstellen



  • Hallo,

    ich hab ein struct array im headerfile angelegt

    struct _strArray StrArray[] = {
    
       {NBR_1, LENGTH_11, STRING_1},             //Spalte1
       {NBR_2, LENGTH_5, STRING_2},              //Spalte2
       {.... usw}                                //Spalte3
    };
    

    Dieses struct array soll die spalten darstellen von einer tabelle. Jetzt möchte ich im C-File dazu die Tabelle erstellen - wie mach ich das? Eigentlich hätte ich gern einen Pointer, mit dem ich mich von einem Tabelleneintrag zum nächsten Fortbewegen kann, damit ich diese Tabelle einfach durchsuchen kann, nach xyz Datensätzen.

    gruß
    Linda



  • struct _strArray *pstr = StrArray;
    
    const size_t count = sizeof(StrArray) / sizeof(StrArray[0]);
    
    while(pstr < &StrArray[count])
    {
      // mach was mit dem aktuellen Element
    
      ++pstr; // zum nächsten Element 
    }
    


  • vielen dank für deine hilfe.

    vll erklär ich schnell mal was ich überhaupt vorhabe - vll gibt es auch einen viel besseren schnelleren Weg.

    struct _strArray
    

    beinhaltet die Syntax der einzelnen Spaltenelemente. Drinnen stehen tut u.a. die eine ID mit der Spalte eindeutig identifiziert werden kann, sowie die Länge der ID und die Art des eintrages der Spalte (also ob es sich um einen Integer oder String etc. handelt)

    struct _strArray StrArray[]
    

    hier stehen dann für diese tabelle die spalten-werte drinnen. Ich wollte sie gerne nicht zur laufzeit generieren, so dass ich dieses StrArray gewählt habe. In dieser Tabelle können von 0 bis 10 Einträge vorhanden sein.

    z.B. erste Spalte Index (ID für Index, Länge von ID, Integer)
    z.B. zweite Spalte Name (ID für Name, Länge der ID, String)
    ...

    Diese Tabelle, sollen während der Laufzeit mit neuen Werten gefüllt werden, es können auch Werte / Reihen der Tabellen gelöscht werden oder einfach nur auf ihre Werte abgefragt werden.

    Ist das ein guter Ansatz dies zu realisieren oder geht es einfacher, schneller?

    gruß
    Linda



  • noch eine frage, wie kann ich mir zu beginn gleich 10 elemente davon anlegen?

    struct _strArray StrArray[10];

    Linda



  • Linda schrieb:

    noch eine frage, wie kann ich mir zu beginn gleich 10 elemente davon anlegen?
    struct _strArray StrArray[10];

    hast du doch so ähnlich schon in deinem ersten beitrag gemacht.
    🙂



  • eigentlich möchte ich es gern so:

    struct StrArray Array[10];
    

    aber wenn ich jetzt mir noch einen Ptr deklarier, der auf das erste Element dieser Tabelle zeigen soll, dann bekomm ich immer eine Fehlermeldung "variable ptr was declared with a never-completed type"

    struct StrArray *ptr; 
    ptr = &Array[0];
    

    hab irgendwie das gefühl, dass mir noch eine struct deklaration fehlt. 😕

    Da ich nicht mehrere Elemente von der struct _strArray haben möchte - die kann ich ja einfach in der struct StrArray hinzufügen. Aber ich möchte jetzt gern eine Art Tabelle erstellen aus 10 Elementen - jedes Element sollte der struct StrArray gleichen.

    gruß
    Linda



  • wie sieht denn die struct _strArray aus?
    🙂



  • die struct _strArray ist:

    struct _strArray {
    
      unsigned int *ID; 
      unsigned short Length; 
    
      unsigned short Type; 
      void           *Value; 
    };
    

    Im Prinzip ist in dieser struct für jede Spalte die Definition dieser Spalte enthalten; also welcher Type (string, char, int etc.) der Value besitzt in der Spalte...

    Hatte schon die Idee über eine weitere typedef struct zu gehen, in der lediglich ein pointer der struct StrArray enthalten ist.

    typedef struct list {
       struct StrArray *listptr; 
    }LIST_PTR; 
    
    LIST_PTR List_Tbl[10]; 
    LIST_PTR *ptr = List_Tbl[0];
    

    aber wie greife ich dann auf die einzelnen elemente zu?

    ptr->listptr[0]->Length = 0 // funktioniert leider nicht
    

    Und ist dieser Ansatz dann noch sinnvoll, oder nicht schon viel zu komplex?

    gruß
    Linda

    gruß
    Linda



  • Linda schrieb:

    struct StrArray *ptr; 
    ptr = &Array[0];
    

    hab irgendwie das gefühl, dass mir noch eine struct deklaration fehlt. 😕

    so sollte es gehen:

    struct _strArray 
    {
      unsigned int *ID;
      unsigned short Length;
      unsigned short Type;
      void           *Value;
    };
    ...
    struct _strArray a[10];  // array anlegen
    struct _strArray *ptr;   // pointer anlegen
    
    ptr = a;      // zeigt auf erstes element
    ptr = &a[0];  // ebenso
    ...  
    ptr = a+1;    // zeigt auf zweites element
    ptr = &a[1];  // ebenso
    ...
    unsigned int *p = a[3].ID;        // zugriff auf array, 4tes element, member ID
    unsigned short t = ptr->Type;     // zugriff über den pointer auf member Type 
    unsigend short l = ptr[2].Length; // zugriff über pointer, 2 elemente weiter auf member Length
    

    ungetestet
    🙂



  • sorry, so hab ich das nicht gemeint... ich versuch es noch mal mit einem bild deutlicher zu erklären.

    struct _strArray 
    {
      unsigned int *ID;
      unsigned short Length;
      unsigned short Type;
      void           *Value;
    };
    

    diese struct soll lediglich die Syntax darstellen (von einem element aus der tabelle).

    | _strArray_Spalte1 | _strArray_Spalte2 |
    ----------------------------------------------
    row1 | | |
    row2 | | | usw.

    d.h. jedes Spaltenelement stellt eine struct an sich schon dar. Jetzt hab ich alle Spaltenelemente (

    _strArray structs
    

    ) in

    struct _strArray StrArray[]
    

    reingepackt und mit Werten initialisiert (da diese fest sind).

    Und jetzt möchte ich eine Tabelle erstellen von 10 Zeilen mit diesen Spalten! Und hier liegt noch mein Problem.

    gruß
    Linda



  • hier noch mal die tabelle (irgendwie hat das nicht funktioniert)...

    | _strArray_Spalte1 | _strArray_Spalte2 | 
    ---------------------------------------------- 
    row1 |                   |                   | 
    row2 |                   |                   | usw.
    


  • bin leider nicht der große C-freak,

    aber vielleicht ist es möglich über eine Liste sowas zu erstellen? Allerdings weiß ich nicht, wie man den nextptr innerhalb deiner struct StrArray[] platzieren muss / kann...

    ansonsten anders programmieren, da so wie du es dir vorstellt es nicht geht...

    wenn StrArray[] wichtig ist, weil man ansonsten alle Werte zu Fuß zu Beginn des Programms reinschreiben muss, fällt mir nur ein diese StrArray mit Zeilenanzahl * Spaltenanzahl zu füllen. Also bei 10 Zeilen 10x den Inhalt von StrArray hintereinander reinschreiben.

    Wenn natürlich dein StrArray schon selbst 10 einträge von _strArray beinhaltet, dann wird die struct StrArray sehr lang... und shcön ist es auch nicht (aber eine Möglichkeit, die mir einfällt)

    gruß
    jörg



  • warum machst du die strukturen nicht so, das man die elemente mit

    SetAt( Table* p, int x, iny )
    {
    // Setze Zelle an Pos x,y
    }

    adressiert ? 😕



  • kannst du mir ein kleines beispiel mit den strukturen zeigen?

    weiß leider nicht ganz genau wie du das machen würdest?

    gruß
    Linda



  • Hi Schwester !
    Hier ist ein kleines Beispiel, wie man eine Tabelle realisieren kann.
    Dieses Beispiel ist extrem erweiterungsfähig. Du kannst einfach in struct Cell deine eigenen Datentypen hinzufügen.
    Die entsprechenden Funktionen musst du dann natürlich erweitern/neu schreiben.

    #include <stdio.h>
    #include <stdlib.h>
    
    int ErrMsg( char* msg )
    {
    	fprintf( stderr, "%s\n", msg );
    	return 1;
    }
    
    typedef struct Cell
    {
    	unsigned m, n; // Adressierung der Zellen einer Tabelle.  
    	int some_data_type;
    	// ... hier weitere, eigene Datentypen ergänzen.
    }Cell;
    
    typedef struct Table
    {
    	unsigned rows, cols;
    	Cell* cell;
    }Table;
    // Dimension der Tabelle festlegen.
    // Anzahl der Zeilen: m
    // Anzahl der Spalten: n
    void SetFormat ( Table* T, unsigned m, unsigned n )
    {
    	T->rows = m;
    	T->cols = n;
    }
    
    int Create ( Table* T ) 
    {
    	if ( NULL == ( T->cell = malloc( T->rows * T->cols * sizeof( Cell ))))
    		return ErrMsg( "Create: Out of memory." );
    	else 
    		return 0;
    }
     // Entweder hier mit speziellen Werten initialiseren,
    // oder in Create() mit calloc alles 0 setzen.
    void Init ( Table* T )
    
    {
    	//unsigned some_data_value = 1;
    	unsigned m=0, n=0;
    	for ( m = 0; m < T->rows; m++ )
    	{
    		for ( n = 0; n < T->cols; n++ )
    		{
    			( T->cell + ( m*T->cols + n ) )->m = m;
    			( T->cell + ( m*T->cols + n ) )->n = n;
    		//	( T->cell + ( m*T->cols + n ) )->some_data_type = some_data_value;
    		}
    	}
    }
    
    void ShowTable ( Table* T )
    {
    	unsigned m=0, n=0;
    	for ( m = 0; m < T->rows; m++ )
    	{
    		for ( n = 0; n < T->cols; n++ )
    		{
    			printf("%u%u ",	( T->cell + ( m*T->cols + n ) )->m,
    				( T->cell + ( m*T->cols + n ) )->n );
    		}
    		puts("");
    	}
    }
    
    int SetCellSomeDataType ( Table* T, unsigned m, unsigned n )
    {
    	( T->cell + ( m*T->cols + n ) )->some_data_type = 12;
    	return 0;
    }
    
    void Close( Table* T )
    {
    	if (!T)
    		return;
    	if (T->cell)
    		free(T->cell);
    }
    
    Cell* GetCell( Table* T, unsigned m, unsigned n )
    {
    	return T->cell + m*T->cols + n;
    }
    
    void ShowCell( Cell* C )
    {
    	printf( "Ich bin die Zelle %u%u\n", C->m, C->n );
    	printf( "Meine Daten: %u\n", C->some_data_type );
    }
    
    int main()
    {
    	unsigned rows = 5, cols = 3;
    
    	Table table = {0};		
    	Table* T = &table;
    
    	Cell* C = NULL;
    
    	SetFormat ( T, rows, cols );
    
    	if ( Create ( T ) )
    		return 1;
    	Init ( T );
    	ShowTable ( T );
    
    	SetCellSomeDataType ( T, 1, 2 );
    	C = GetCell( T, 1, 2 );
    	ShowCell( C );
    
    	Close( T );
    
    	return 0;
    }
    

    🕶



  • vielen dank für die mühe...

    d.h. ich kann auch über

    Table ListTabl[10];
    

    gleich 10 elemente anlegen - das ist sehr schön.

    vielen dank, werd ich morgn mal näher anschauen...

    gruß
    Linda


Log in to reply