4. Pointer auf Tabelle

Pointer auf Tabelle

  • ?

    Hallo ich habe ein kleines Problem ich soll eine Tabelle erstellen in welcher ein Struct abgebildet ist.Nun soll ich jede Position in der Tabelle mit einem der Position zugewiesenen Zeiger aufrufen können. Wie kann ich das realisieren.
    Mein Struct sieht so aus :

    typedef struct SLAVE_INFO
{
   Uint8 Active;
   Uint8 Serial_1;
   Uint8 Serial_2;
   Uint8 Serial_3;
   Uint8 Status_1;
   Uint8 Status_2;
   Uint8 SlaveAddr;
   Uint8 Uist_1;
   Uint8 Uist_2;   
   Uint8 List_1;
   Uint8 List_2;
   Uint8 PwrUpCnt_1;
   Uint8 PwrUpCnt_2;
   Uint8 Time_1;
   Uint8 Time_2;
   Uint8 Config;

}SlaveInfo;

    Um eine Tabelle zu erstellen bin ich wie folgt vorgegangen:

    void main(void)
{
	struct	SLAVE_INFO G_SLAVE_INFO[MAX_SLAVE]; 

}

    Nur wie kann ich nun jedem Tabelleneintrag einen festen Pointer zuweisen.

    0

  • - Uint8 ist kein Standard
    - void main(void) ist kein Standard
    - warum verwendest du die typedef nicht, wenn du sie vorher explizit deklarierst?
    - was soll ein "fester" Zeiger sein?
    - nur Masochisten verwenden großbuchstabige Variablennamen
    - ...

    int main()
{
  SlaveInfo slaveinfo [MAX_SLAVE];
  SlaveInfo *siptr0 = &slaveinfo[0],
            *siptr1 = &slaveinfo[1],
            *siptr2 = &slaveinfo[2],
            *siptr3 = &slaveinfo[3];
  ...
  return 0;
}
    0
  • ?

    Sorry bin noch neu und grün hinter den Ohren.
    Hab mich wohl falch ausgedrück ich soll eine 2 Tabelle erstellen in welche nur die Pointer hinterlegt sind wlche auf die Tabelle mit den Daten verweist.Wie würde ich das machen?

    0

  • Steht zwar implizit schon da, aber hier nochmal explizit:

    int main()
{
  SlaveInfo ichbineinarrayausstrukturelementen[3];
  SlaveInfo *ichbineinarrayvonzeigernaufstrukturelemente[3] = {&ichbineinarrayausstrukturelementen[0],&ichbineinarrayausstrukturelementen[1],&ichbineinarrayausstrukturelementen[2]};
  ...
  return 0;
}
    0
  • ?

    Wenn schon, denn schon...

    int main()
{
  SlaveInfo ICHBINEINARRAYAUSSTRUKTURELEMENTEN[3];
  SlaveInfo *ICHBINEINARRAYVONZEIGERNAUFSTRUKTURELEMENTE[3] = {&ICHBINEINARRAYAUSSTRUKTURELEMENTEN[0],&ICHBINEINARRAYAUSSTRUKTURELEMENTEN[1],&ICHBINEINARRAYAUSSTRUKTURELEMENTEN[2]};
  ...
  return 0;
}

    [/quote]

    0
  • ?

    Sorry bin halt das erste mal in der Paxis und gerade im 2 Semester meines Studiums.Vielleicht gehe ich auch ganz falsch an das ganzer herran? Grundgedanke ist der ich hab 5 Geräte jedes hat andere Daten.Diese sollen in einer Tabelle hintelegt werden. Darum der Struct und das array des Structs. Nun soll ich über einen Pointer die Daten für das jeweilige Gerät aufrufen können.Wie würde das zum Beispiel aussehen?

    0
  • ?

    student07 schrieb:

    Sorry bin halt das erste mal in der Paxis und gerade im 2 Semester meines Studiums.

    Und ich dachte, mein Arbeitgeber würde mich verarschen, als er meinte, dass sein Mathematik- und Informatikstudium für den Arsch war, und dass sie bereits Studenten hier hatten, die keine Zeile Code schreiben konnten ...

    student07 schrieb:

    Vielleicht gehe ich auch ganz falsch an das ganzer herran? Grundgedanke ist der ich hab 5 Geräte jedes hat andere Daten.Diese sollen in einer Tabelle hintelegt werden. Darum der Struct und das array des Structs. Nun soll ich über einen Pointer die Daten für das jeweilige Gerät aufrufen können.Wie würde das zum Beispiel aussehen?

    Gegeben ist folgende Struktur (meine Erfindung ;)):

    typedef struct
{
    int _1;
    int _2;
}MyStruct;

    Es gibt verschiedene Möglichkeiten, sowohl die Art, wie die Daten gesichert werden, als auch den Zugriff auf diese Daten zu bestimmen.

    1.1. Du kannst die Objekte auf den Stack legen. Ist im Grunde genau das, was du sonst auch machst:

    /*Auf dem Stack*/
struct My Struct a,b;

    1.2 Du kannst das Ganze aber auch auf den Heap legen, wenn du willst:

    const int MySize=sizeof(struct MyStruct);
/*Auf dem Heap*/
struct MyStruct*p_1=(struct MyStruct*)malloc(MySize),*p_2=(struct MyStruct*)malloc(MySize);

    2.1 Oben wurde der Zugriff immer über einzelne Variablen geregelt. Es ist aber auch möglich, das ganze über Arrays und Zeiger zu erledigen:

    /*Array auf dem Stack*/
struct MyStruct AllMyObjects[5];

    2.2. Macht aber nicht viel Sinn, falls sich die Anzahl der Geräte ändert. Dafür ist der Weg über malloc einfacher:

    /*Pointer auf dem Stack, zeigt auf ein "Array" mit 5 Elementen im Heap*/
struct MyStruct*MyPointer=(struct MyStruct*)malloc(sizeof(struct MyStruct)*5);

    Der Zugriff hierbei ist derselbe wie beim Array - ein Grund, warum vor allem Neulinge meinen, Arrays und Zeiger seien dasselbe. 🤡

    2.3 Und schließlich kannst du es auch ganz umständlich machen, ein Array von Zeigern auf dem Stack erstellen, wobei jedes Element (also jeder Zeiger) auf EIN Objekt im Heap zeigt:

    struct MyStruct*AllMyPointers[5];
for(int i=0;i<5;i++)
{
    AllMyPointers[i]=(struct MyStruct*)malloc(sizeof(struct MyStruct));
}

    Meiner Meinung nach Blödsinn, aber möglich - und einen besseren Beweis für die Mächtigkeit der Sprache als die Tatsache, dass man mit ihr auch dumme Sachen realisieren kann, gibt es wohl kaum.

    PS: Entschuldigung, wenn ich einige struct vergessen oder zu viel eingefügt habe, aber ich programmiere meistens in C++, und da kann ich das class meistens weglassen.

    0
Anmelden zum Antworten