Frage zu Pointern

[Matthias W. (macho2000)]

Hallo,

ich stehe gerade etwas auf dem Schlauch und hoffe jemand kann mir 
weiterhelfen.

In meinem aktuellem Projekt gemöchte ich verschiedene Werte auf einem 
Grafikdisplay in einem Schreiber (oder auch Vorhangdiagramm) darstellen. 
Mit einem Menü kann ich dann einen Wert auswählen, welcher im Schreiber 
erscheint!

Mein Problem:

der Schreiber läuft in einer 100ms Schleife und stellt immer den Wert

uintTmp

 dar. Wird das Menü aufgerufen, so wird die Schleife unterbrochen und in 
einen Pointer

ptrDia = &uintSpeed;

die Adresse der neu darzustellenden Messgröße abgelegt. Am anfang der 
100ms Schleife mache ich dann

uintTmp = *ptrDia

Das funktioniert soweit, aber was mache ich wenn ich einen Char-Wert 
übergeben möchte, denn ptrDia ist ja ein Pointer auf einen Integer Wert? 
Ich kann auch nicht den Char Wert erst wandeln in Integer, da die 
Menüschleife nicht immer durchlaufen wird.

Hat jemand ne Idee wie ich das anders lösen kann, oder gibt es eine 
Möglichkeit im einem Poiter auf unterschiedliche Datentypen zu zeigen?

Gruß

Matthias

[Karl H. (kbuchegg)]

Matthias Werner wrote:

> Möglichkeit im einem Poiter auf unterschiedliche Datentypen zu zeigen?

Nein. Gibt es nicht. Ein Pointer hat einen spezifischen Datentyp.

Aber du könntest mehrere Pointer installieren, zusammen mit
einer Variablen, die angibt welcher Pointer denn jetzt die
anzuzeigenden Daten referenziert.

[Matthias W. (macho2000)]

Danke für den Tip!

Das stellt sich mir als recht praktikabel dar.

Gruß

Matthias

[Niels H. (monarch35)]

Ein Pointer ist zunächst mal nur eine Adresse. Und diese angabe ist für 
jeden Datentypen gleich. Eine Möglichkeit wäre die Adresse eines 
Pointers an den fremddatentypen zu übergeben.

z.b.

void ichmachwas (void *abc,int typ)
{
    uint8_t *p1;
    uint16_t *p2;
    uint16_t wert;
    switch (typ)
    {
       case 0:
         p1=abc;
         wert=(uint16_t)(*p1);
       case 1:
         p2=abc;
         wert=(uint16_t)(*p2);
       default:
         wert=0;
      }
}

[Simon K. (simon)]

Ein void-Pointer ist zu allen Pointertypen zuweisungskompatibel. 
Allerdings kann man diesen natürlich nicht wieder dereferenzieren, ohne 
vorher zu casten.

[sniper (Gast)]

Du könntest auch verschiedene Datenstrukturen machen, die alle einen
gemeinsamen Nenner (nämlich Typinformation) haben.

Dein Zeiger würde dann immer auf den Basistyp zeigen. Der Schreiber 
würde
nachsehen, auf welchen Typ der Zeiger zeigt.

Bsp:

typedef enum eWriterTypeInfo
{
   WRITER_TYP_UINT8 = 0,
   WRITER_TYP_UINT16,
   WRITER_TYP_ANSISTRING
   //usw...
}WRITER_TYPE_INFO;

typedef struct _tagUint8Type
{
  WRITER_TYPE_INFO    type;
  unsigned char       value;
}tWriterUint8;

typedef struct _tagUint16Type
{
  WRITER_TYPE_INFO    type;
  unsigned int        value;  //falls int 16Bit breit ist!
}tWriterUint16;

Das lohnt sich aber erst, wenn die Datenstrukturen etwas komplexer 
werden.

[sniper (Gast)]

hmm, schwacher Tag... zur Vollständigkeit:

//poiner anlegen  - globaler Code
WRITER_TYPE_INFO *  pMyDataPointer;
tWriterUint8 myUint8DisplayData;



//der Code, der die Daten erfasst
myUint8DisplayData.value = 23;
pMyDataPointer = (WRITER_TYPE_INFO*)&myUint8DisplayData;



//der Code, der die Daten ausgibt (100ms Schreiber Thread)
switch ( *pMyDataPointer )
{
  case WRITER_TYP_UINT8:
  {
    unsigned char displayData;
    tWriterUint8* p = (tWriterUint8*)*pMyDataPointer;
    displayData = p->value;  
    //displayData ausgeben (== 23)
  }
  break;

  case WRITER_TYP_UINT16:
  {
    unsigned char displayData;
    tWriterUint16* p;
    //usw...
  }
  break;

  //weitere nach Schema f 

  default:
    //error unknown data type
    break;
}