Re: Problem z dynamiczną alokacją pamięci struktury

2013-05-14T21:24:22+01:00

toch88 napisał(a):

(PRZED wywołaniem CreateChild)
tprs->string[0]="Silnik 3,5"
tprs->string[1]="Silnik 5,25"
tprs->string[2]="Silnika 7,45"

Już pierwszy string ma 10 znaków doliczając '\0' wychodzi 11 bajtów.
Funkcja do poprawki:

toch88 napisał(a):

[syntax=c]void createChild(TPARSER *tprs, const char *kryterium){
uint8_t i;
char temp[10]; //-------------tylko 9 znaków
tprs->child = (struct TPARSER**)malloc (sizeof(TPARSER)); //dynamiczna allokacja pamieci
i=0;
while(iElementsOfTab){
tprs->child[i]=(struct TPARSER*)malloc (sizeof(TPARSER));
strcpy(temp,tprs->string[i]); //--------temp musi być na tyle duże by pomieścić tprs->string[i], bo nie jest to sprawdzane
initParser(tprs->child[i], temp,kryterium);
i++;
}
tprs->nbOfChild=i;
}[/syntax]

Właściwie to zmienna temp nie jest wcale potrzebna, bo i tak ginie po zakończeniu działania funkcji. Dlaczego nie może być tak:
[syntax=c]void createChild(TPARSER *tprs, const char *kryterium){
uint8_t i;
tprs->child = (struct TPARSER**)malloc (sizeof(TPARSER)); //dynamiczna allokacja pamieci
i=0;
while(iElementsOfTab){
tprs->child[i]=(struct TPARSER*)malloc (sizeof(TPARSER));
initParser(tprs->child[i], tprs->string[i], kryterium);
i++;
}
tprs->nbOfChild=i;
}[/syntax]

Statystyki: Napisane przez Krauser — 14 maja 2013, o 21:24

Problem z dynamiczną alokacją pamięci struktury

2013-05-13T19:28:03+01:00

Witam

Mam dosyć spory problem z parsowaniem tekstu, mianowicie użytkownik może w terminalu wpisać sobie taką o to składnie.

Silnik 3,5;Silnik 5,25;Silnika 7,45;

Ma to podzielić na "Silnik 3,5" , "Silnika 5,25" itp;

Robię to w następujący sposób:
-gdy z USARTa przychodzi ciąg znaków zakończonych znakiem '\0' wychodzi do przerwania gdzie tworzona jest tablica (buforRx) przesłanych znaków, przekazywanych dalej do pętli głównej:

[syntax=c]extern unsigned char buforRx[];
extern unsigned char bufRxIndex;
extern bool odebranoDane;
#define SIZE_RX_BUF 100
void USART1_IRQHandler(void){

if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) {
buforRx[bufRxIndex]=USART_ReceiveData(USART1);
if(buforRx[bufRxIndex]==0x0d){
odebranoDane=TRUE;
while(bufRxIndex buforRx[bufRxIndex]=0;
bufRxIndex++;
}
bufRxIndex=0;
}
else{
bufRxIndex++;
}
if(bufRxIndex>SIZE_RX_BUF-1){
bufRxIndex=0;
}
}
}[/syntax]

W pętli głównej obsługa tego wygląda tak:
MAIN
[syntax=c]if(odebranoDane) {

tprs=(struct TPARSER*)malloc (sizeof(TPARSER));
initParser(tprs, buforRx,";");
createChild(tprs," ");
freeStructure(tprs);
odebranoDane=FALSE;

}[/syntax]

Po krótce dzięki temu kodowi bd miał:

(PRZED wywołaniem CreateChild)
tprs->string[0]="Silnik 3,5"
tprs->string[1]="Silnik 5,25"
tprs->string[2]="Silnika 7,45"

wszystko ładnie pięknie teraz tworze "dzieci"

(Wywołanie createChild)

na podstawie każdego ze stringów dzielę wq kryterium " ":
po takim sparsowaniu mam:

tprs->child[0]->string[0]="Silnik"
tprs->child[0]->string[1]="3,5"

tprs->child[1]->string[0]="Silnik"
tprs->child[1]->string[1]="5,25"

Dobrze tak wyglądają funkcje:
Inicjująca
[syntax=c]void initParser(TPARSER *tprs,char *wsk, const char *kryterium){
uint8_t i;
i=0;

tprs->string[i] = strtok (wsk,kryterium); // tworzę tokeny według przyjętego kryterium // 0 token

while( tprs->string[i] != NULL ){

i++; // zwiększ wskaźnik tokenów
tprs->string[i] = strtok (NULL, kryterium); // przyporządkuj następny token

}

tprs->ElementsOfTab=i;

}[/syntax]

Tworząca dzieci

[syntax=c]void createChild(TPARSER *tprs, const char *kryterium){
uint8_t i;
char temp[10];
tprs->child = (struct TPARSER**)malloc (sizeof(TPARSER)); //dynamiczna allokacja pamieci
i=0;
while(iElementsOfTab){
tprs->child[i]=(struct TPARSER*)malloc (sizeof(TPARSER));
strcpy(temp,tprs->string[i]);
initParser(tprs->child[i], temp,kryterium);
i++;
}

tprs->nbOfChild=i;

}[/syntax]

Teraz pytanie w jaki sposób zwolnić tą pamięć przed przybyciem paczki do parsowania? Mam napisane coś takiego ale niestety HardFault_Handler
[syntax=c]void freeStructure(struct TPARSER *tprs){
uint8_t i;
i=0;

if(hasChild(tprs)){
USART_PutString(USART1, "Czyszczenie dzieci\r");
while(tprs->child[i]!=NULL){
freeStructure(tprs->child[i]);
tprs->child[i]
i++;
}

}
else{
USART_PutString(USART1, "Czyszczenie dzieci else \r");
while(tprs!=NULL){
free(tprs);
tprs=NULL;
}
}
}[/syntax]

tak wygląda deklaracja structury
[syntax=c]typedef struct TPARSER{
uint8_t ElementsOfTab;
uint8_t LoopNb;
uint8_t nbOfChild;
uint8_t childId;
uint8_t thisId;
char *string[10];
struct TPARSER **child;

}TPARSER;[/syntax]
Bardzo proszę o pomoc naprawdę próbowałem wielu rzeczy, ale może mój zamysł w ogóle jest niepoprawny stąd te ceregiele. Wydaje mi się że to sprawa źle zwalnianych wskaźników bo w pewnych przypadkach program działa tzn kilka razy odbierze i przerobi polecenia, a np za 3 -4 się wysypie ;/

Pozdrawiam.

Statystyki: Napisane przez toch88 — 13 maja 2013, o 19:28

ATNEL tech-forum

Re: Problem z dynamiczną alokacją pamięci struktury

Problem z dynamiczną alokacją pamięci struktury