Große Datenmengen verarbeiten

[Ingo (Gast)]

Nabend,

ich habe ein Array, bestehend aus 20.000 Messwerten, die ich einer 
Funktion übergeben möchte. Da sich die Funktion in einer anderen 
Übersetzungseinheit befindet, würde ich gern einen Pointer übergen, da 
ich das Array nicht gern global hätte. Die Funktion soll mir 6 Werte 
zurückgeben, auch in ein Array.

Könnte das so funktionieren? Habe weder Buch noch sonst was zur Hand.

//main.c

struct Daten_s{
 uint_t Messwerte[50000];
 uint_t Rueckgabe[6]
};

Daten_s Daten;

int main (void)
{
  ...
  Daten.Rueckgabe = foo (&Daten.Messwerte);
  ...
}

// Auswertung.c

uint16_t *p_Rueck foo ( uint16_t *pDaten )
{
   // *pDaten verarbeiten; 
   ...

   // Rückgabewerte
   *p_Rueck->Rueckgabe[0]  = 5
   *p_Rueck->Rueckgabe[1]  = 10
   ...
   *p_Rueck->Rueckgabe[5]  = 30;
 
}

Danke schonmal



Ingo

[Ingo (Gast)]

sorry, sollte heißen:

struct Daten_s{
 uint16_t Messwerte[50000];
 uint16_t Rueckgabe[6];
};

[Christian H. (netzwanze)]

Was ist eine Übersetzungseinheit?

[Irgendjemand (Gast)]

Ich würde das mit einem Ausgabeparameter lösen. Damit spart man sich das 
Allokieren und Freigeb von dynamischen Speicher. Dazu sollten die 
Arraylängen der Funktion mitgeteilt werden um das ganze ein wenig 
robuster zu machen.

//main.c

#define N_MESSWERTE 50000
#define N_RUECKGABE 6

struct Daten_s{
 uint_t Messwerte[N_MESSWERTE];
 uint_t Rueckgabe[N_RUECKGABE];
};

Daten_s Daten;

int main (void)
{
  ...
  foo (Daten.Messwerte, N_MESSWERTE, Daten.Rueckgabe, N_RUECKGABE);
  ...
}

// Auswertung.c
void foo ( uint16_t *pDaten, long nDaten, uint16_t *p_Rueck, long nRueck )
{
   // *pDaten verarbeiten; 
   ...

   // Rückgabewerte
   p_Rueck->Rueckgabe[0]  = 5
   p_Rueck->Rueckgabe[1]  = 10
   ...
   p_Rueck->Rueckgabe[5]  = 30;
 
}

[Marcel (Gast)]

Ingo schrieb:
> Habe weder Buch noch sonst was zur Hand.

Auch kein Internet?

Ingo schrieb:
> struct Daten_s{
>  uint_t Messwerte[50000];
>  uint_t Rueckgabe[6]
> };

Wenn du schon eine Struktur hast, warum übergibst du die nicht komplett?

void foo ( struct Daten_s *pDaten )

Bist du sicher dass dein Controller genug RAM für das ganze hat?

[Simon S. (-schumi-)]

// Auswertung.h

typedef struct {
 uint_t Messwerte[50000];
 uint_t Rueckgabe[6]
} Daten_s;

void foo ( Daten_s *pDaten );

//main.c

Daten_s Daten;

int main (void)
{
  ...
  foo (&Daten);
  ...
}

// Auswertung.c

void foo ( Daten_s *pDaten )
{
   // *pDaten verarbeiten; 
   ...

   // Rückgabewerte
   *pDaten->Rueckgabe[0]  = 5
   *pDaten->Rueckgabe[1]  = 10
   ...
   *pDaten->Rueckgabe[5]  = 30;
 
}

[horst (Gast)]

Mit einem Pointer auf die Struktur Daten könnte die Funktion direkt in 
das originale Rückgabefeld schreiben. Bei deinem Beispiel wird ein 
Pointer zurückgegeben und soll eine Referenz auf ein Feld überschreiben? 
Nicht wirklich sinnvoll. Sollte p_Rueck nur in der Funktion existieren 
und nicht als static deklariert sein, so sind die Inhalte mit dem 
Beenden der Funktion verloren.

Oftmals eine gute Idee:
Die Struktur in einem Modul mit allen Funktionen die darauf zugreifen. 
Dann kann man die Variable Daten auch als static deklarieren und sie ist 
von außerhalb des Moduls nicht mehr sichtbar.
Bei deinem Beispiel ist es prinzipiell immer noch möglich, von überall 
auf die Variable zuzugreifen.

Wenn ich mich recht erinnere:
In dieser Variante wäre es

struct Daten_s Daten;

um die Variable anzulegen oder

struct Daten_struct{
 uint_t Messwerte[50000];
 uint_t Rueckgabe[6]
} Daten_s;

Daten_s Daten;

[Dr. Sommer (Gast)]

#include <vector>
#include <cstdint>
#include <iostream>

std::vector<uint16_t> foo (const std::vector<uint16_t>& input) {
  // Array aus 6 Zahlen zurückgeben
  return { 1, 2, 3, 4, 5, 6 };
}

int main () {
  // Eingabearray anlegen...
  std::vector<uint16_t> eingabe (50000);
  // Array füllen...
  for (size_t i = 0; i < eingabe.size (); i++)
    eingabe [i] = i;
  
  // Funktion aufrufen und Rückgabe speichern
  auto ausgabe = foo (eingabe);
  
  // Rückgabe ausgeben
  for (uint16_t x : ausgabe) {
    std::cout << x << ", ";
  }
}

Christian H. schrieb:
> Was ist eine Übersetzungseinheit?
Eine Quellcodedatei, auf der man den Compiler aufruft und aus der eine 
Object File erzeugt wird. Die einzelnen Übersetzungseinheiten werden 
seperat kompiliert.

[Weg mit dem Troll. (Gast)]

Kein globales Array ? Bedeutet ein dynamisches Array ? Das wuerd ich 
eher sein lassen. Man sollte sowieso keine dynamischen Variablen 
verwenden. Dh keine mit new() oder getmem() allozierten.

[Dr. Sommer (Gast)]

Weg mit dem Troll. schrieb:
> Kein globales Array ? Bedeutet ein dynamisches Array ? Das wuerd
> ich
> eher sein lassen. Man sollte sowieso keine dynamischen Variablen
> verwenden. Dh keine mit new() oder getmem() allozierten.
getmem()? In Pascal?
Genau, dynamischen Speicher sollte man vermeiden, wer will schon dass 
sein Programm flexibel mit verschiedenen Eingabedaten umgehen kann?!

[Ingo (Gast)]

Marcel schrieb:
> Wenn du schon eine Struktur hast, warum übergibst du die nicht komplett?
Weil die Struct noch andere Daten beeinhaltet, die für die 
Datenauswertung nicht benötigt werden.

Danke erstmal!

[Dumdi D. (dumdidum)]

Dr. Sommer schrieb:
> Genau, dynamischen Speicher sollte man vermeiden, wer will schon dass
> sein Programm flexibel mit verschiedenen Eingabedaten umgehen kann?!

Bei muC? Keiner will das. Insbesondere wenn man an Langzeitstabilität 
interessiert ist.

[Dr. Sommer (Gast)]

dumdi dum schrieb:
> Bei muC? Keiner will das. Insbesondere wenn man an Langzeitstabilität
> interessiert ist.
Gibt genug Anwendungen wo das gemacht wird. Hängt halt stark von der 
Speichergröße, Umgebung, evtl. OS etc. ab.