free erzeugt Fehler

Martin Sche Gast #1510722
Lesenswert?
• ▲
▼ 
Hallo Leute!
Ich wollte nur mal kurz ein kleines Programm schreiben, um zu testen, ob 
ich ein dynamisch erzeugtes Array auch irgendwie global verfügbar machen 
kann bzw. auch in einer ISR verwenden kann.
Ich nehme nen globalen Zeiger und lasse ihn auf ein dnymaisch erzeugtes 
Array zeigen, fertig...
Funktioniert eigentlich ganz gut, nur die Funktion free(pointer) erzeugt 
nen Fehler. Das "volatile" stört hier, aber das muss ich ja wohl lassen, 
da ich den Pointer in ner ISR brauche...oder?
Hier mal der Code:
1
#include <avr/io.h>

2
#include <avr/wdt.h> /* Watchdog*/

3
#include <avr/interrupt.h> 

4
#include <avr/eeprom.h>

5
#include <stdio.h>

6
#include <stdlib.h>

7
#include <stdint.h>

8
#include <stdbool.h>

9
#include <string.h>

10


11


12
volatile uint16_t *pointer;

13
void funktion();

14


15
int main()

16
{

17
int k=3;

18
pointer= (uint16_t *) malloc(k*sizeof(uint16_t)+1);

19


20


21
funktion();

22
int i;

23
int array[3];

24
for(i=0;i<k;i++)

25
  {

26
    array[i]=pointer[i];

27
  }

28


29
free(pointer);

30
return 0;

31


32
}

33


34


35
void funktion()

36
{

37


38
pointer[0]=96;

39
pointer[1]=5;

40
pointer[2]=256;

41


42
}

Kann ich das Problem irgendwie umgehn? Ist der Speicher automatisch wenn 
die Funktion (wo er bereitgestellt wurde) abgeschlossen ist wieder 
frei??

Vielen Dank!
P.S. Das spätere Programm wird auf einen Atmega 32 laufen...
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
der mechatroniker Gast #1510746
Lesenswert?
• ▲
▼ 
Äh... Schön, dass du so ein gewissenhafter Programmierer bist. du bist 
auf nem Mikrocontroller. Hast du Angst vor einem Memory Leak beim 
Ausschalten des Geräts?

Scherz beiseite: wenn du aus irgendwelchen Gründen das Ding doch 
freigeben musst, darfst du das volatile wegcasten. Aber versprich mir, 
höllisch aufzupassen, dass keine ISR dazwischenfunkt, während der 
Pointer (da gefreet) nicht gültig ist.

P.S. Zeig mal ein vollst. Programm inkl. ISR, so wie du das benutzen 
willst.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Martin Sche Gast #1510764
Lesenswert?
• ▲
▼ 
Danke für die schnelle Antworten!

Ich erklär jetzt mal wie ich das verwenden will:
Von außen wird festgelegt wie oft ein Interrupt ausgelöst werden darf, 
nehmen wir an k-mal. Bei jedem Interrupt schreib ich etwas in ein Array, 
das ich später in meinem Hautprogramm verarbeite. Danach werden die 
Interrupts gesperrt.
Ich habe dann also k Werte in meinem k großen Array.
Wenn ich diese Werte verarbeitet habe, brauch ich das Array nicht mehr 
und hätte es jetzt einfach mal "gefreet" um wieder Speicher für weitere 
Variablen zu haben (der Platz wird aber wohl nicht eng, dachte nur free 
waäre ganz nett*gg*).
Kann ich also das free getrost wegglasen?
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #1510771
Lesenswert?
• ▲
▼ 
Martin Sche schrieb:


> Von außen wird festgelegt wie oft ein Interrupt ausgelöst werden darf,
> nehmen wir an k-mal. Bei jedem Interrupt schreib ich etwas in ein Array,
> das ich später in meinem Hautprogramm verarbeite. Danach werden die
> Interrupts gesperrt.
> Ich habe dann also k Werte in meinem k großen Array.
> Wenn ich diese Werte verarbeitet habe, brauch ich das Array nicht mehr
> und hätte es jetzt einfach mal "gefreet" um wieder Speicher für weitere
> Variablen zu haben

Welche anderen Variablen?

Wir bewegen uns doch auf einem µC.
D.h. du kannst alles SRAM, welches dir noch zur Verfügung steht, von 
Haus aus in dein Werte-Array buttern. Ob dieses SRAM jetzt brach liegt, 
oder ob du dort von voneherein ein Array reinlegst, ist Jacke wie Hose.
Der einzige Unterschied:
Legst du das Array statisch an, dann weißt du zur Compilerzeit, wie groß 
das Array ist und kannst darauf einfach reagieren, wenn das k zu groß 
wird.
Ganz abgesehen davon, dass du bereits nach dem Compilieren weißt, 
wieviel Speicher du im SRAM für dich verbrutzelt hast.
Mehr SRAM, als wie wenn du das Array statisch allokierst, kriegst du 
auch dann nicht, wenn du eine dynamische Allokierung machst. Auch ein 
malloc kann keinen Speicher aus dem Hut zaubern.

> Kann ich also das free getrost wegglasen?
In dem Fall nicht.
Aber das ist auch die falsche Frage. Die richtige Frage lautet: Was 
bringt dir eine dynamische Allokierung ausser dass du dem µC zusätzliche 
Arbeit aufbürdest?


(Es sei denn natürlich du hättest mehrere dynamische Allokierungen, die 
wechselseitig den Speicher belegen. Dann könnte es Sinn machen, mit 
malloc zu arbeiten)
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren