Zeiger auf Elemente aus einem struct

[Großes F. (112)]

Hallo,

ich hätte eine Frage zur C-Programmierung.

Ich habe ein struct, das wie folgt aufgebaut ist:

struct T_Messreihe
    {
uint16_t Messwert;
uint16_t Buffer_1[SAMPLES];
uint16_t Buffer_2[SAMPLES];
uint16_t Buffer_3[SAMPLES];    
uint16_t Bufferzeiger;
      
uint16_t Mittelwert_1;
uint16_t Mittelwert_2;
uint16_t Mittelwert_3;

Nun möchte ich in einer Funktion die Mittelwerte 1 bis 3 bestimmen, 
allerdings benötige ich nicht immer alle drei Mittelwerte.

Ich könnte nun also eine Funktion schreiben, die das struct als solches 
übergeben bekommt:

uin16_t Average(struct T_Messreihe* Data)
{
uint16_t Average_1 = 0;
uint16_t Average_2 = 0;
uint16_t Average_3 = 0;

{berechne Average_i};
  
Data->Mittelwert_1 = Average_1;
Data->Mittelwert_2 = Average_2;
Data->Mittelwert_3 = Average_3;
}

Das ist aber insofern ungünstig, weil die Buffer_1 bis Buffer_3 nicht 
gleichmäßig gefüllt werden und ich daher den Mittelwert eigentlich nur 
zu ganz bestimmten Zeitpunkten aktualisieren möchte.

Was ich also bräuchte wäre ein Funktionsaufruf in der Form

uin16_t Average("ZEIGER AUF ELEMENTE AUS DEM STRUCT")
{}

...nur wie baue ich eine solche Parameterübergabe, also so dass ich die 
Funktion "allgemein" halte und genau diejenigen Buffer auswerte, deren 
Mittelwert mich gerade interessiert?

mfg

[Rufus Τ. F. (rufus)]

Großes Fragezeichen schrieb:
> Was ich also bräuchte wäre ein Funktionsaufruf in der Form
> uin16_t Average("ZEIGER AUF ELEMENTE AUS DEM STRUCT")
> {}

Und welche Elemente möchtest Du da übergeben?

Möchtest Du nur den Mittelwert eines der drei Arrays (Buffer_1 .. _3) 
berechnen, oder möchtest Du nur den Mittelwert eines Teiles der Arrays 
berechnen?

[Markus_AC (Gast)]

Mach es doch so:

uin16_t Average(struct T_Messreihe* Data, int iCount1, iCount2, iCount3)
{
...
    calcAverage(Data->Buffer1, iCount1)
...
}

und dann

uin16_t calcAverage(uint16_t *pBuffer, int iCount)
{
    int i, Sum=0;
    for(i = 0; i < iCount; i++)
    {
        Sum += pBuffer[i];
    }
    return (uint16_t)(Sum/iCount);
}

[Oliver (Gast)]

Ganz prinzipiell bekommt man in C eine Adresse über den Adress-Operator 
&.

Der lässt sich auf beinahe alles anwenden, incl. der Elemente eines 
Structs und/oder Arrays.

Ob das die Lösung für dein Problem ist, oder du eventuell die falsche 
Frage stellst, ist allerdings andere und weit wichtigere Frage.

Oliver

[Rolf Magnus (Gast)]

Wenn ich dich richtig verstehe, willst du sowas wie einen Zeiger auf 
eine Kombination aus Buffer und Mittelwert. Warum kombinierst du die 
dann nicht einfach in einer struct?

struct Buffer
{
    uint16_t Werte[SAMPLES];
    uint16_t Mittelwert;
};

struct T_Messreihe
{
    uint16_t Messwert;
    struct Buffer Buffer_1;
    struct Buffer Buffer_2;
    struct Buffer Buffer_3;
    uint16_t Bufferzeiger;
};

uint16_t Average(struct Buffer* Data)
{
uint16_t Average_1 = 0;

{berechne Average_1};
  
Data->Mittelwert = Average_1;
}

Statt Buffer_1, Buffer_2 und Buffer3 könnte man auch gleich noch ein 
Array nehmen. Das macht's in der Regel an einigen Stellen auch 
einfacher.