Normalt att det blir bugg om man anropar funktion i funktion

[TomasL]

Det är för det mesta rätt dumt att deklarera lokala variabler i rekursiva funktioner, då de kan (även om det bara är char's eller int) käka mycket minne om funktionen körs många gånger.

[Al_Bundy]

och det finns ingen funktion som man kan anropa som "raderar" den gamla vägen som man har gått? Tömmer minnet t.ex fast inte alla variabler?

Typ precis innan jag ska anropa funktionen igen. Då ska jag anropa en funktion som raderar dessa värden, eller några av dem?

Kod: Markera allt

  int part[] = {1,2,3,4,5};
  int temponary_value;
  int values_storage[10];
  String labels[5][5] = { {"*****TIME*****", "Dv0 time:", "Range 30-99:", String(values_storage[0]), String(values_storage[1]) },
                          {"*****TEMP*****", "Dv0 temp:", "Range 50-99:", String(values_storage[2]), String(values_storage[3]) },
                          {"*****TIME*****", "Dv1 time:", "Range 30-99:", String(values_storage[4]), String(values_storage[5]) },
                          {"*****TEMP*****", "Dv1 temp:", "Range 50-99:", String(values_storage[6]), String(values_storage[7]) },
                          {"***END TEMP***", "End temp:", "Range 50-99:", String(values_storage[8]), String(values_storage[9]) }};

[TomasL]

Nej, eftersom du inte "vet" var de hamnat, deklarera dem globalt (i alla fall i modulen) så slipper du problemet.

[johano]

Jag förstog din kod och tyckte det var rätt bra, men visst är det typ nu man ska använda pekare?

Jag gillar denna typ av utmaning

Visst, du kan ju låta funktionerna returnera en pekare till "nästa" funktion som ska köras..

Kod: Markera allt

typedef void* (*PFN)();

void* funk1();
void* funk2();
void* funk3();

int main(int argc, const char * argv[])
{
   PFN pfn = funk1;

   while(pfn)
      pfn = pfn();

   retun 0;
}


void* funk1()
{
   return funk2;
}

void* funk2()
{
   return funk3;
}

void* funk3()
{
  return NULL;
}

[TomasL]

Nu tror jag nog att herr bundy skall undvika det där med pekare, tills dess han förstår sig på det här med programmering (speciellt när det gäller dessa små 8-bitars processorer med mycket begränsat RAM-minne) lite bättre

[ElectricNooB]

Jag skulle nog säga att pekare är nått man lär sig före man lär sig om stacks osv. Men det är klart det är ju µC'n vi talar om och inga vanliga datorer så du har helt klart en poäng.

[Al_Bundy]

johano: Brukar void returnera ett värde? Trodde void gjorde inte det.

[Al_Bundy]

Nu tror jag nog att herr bundy skall undvika det där med pekare, tills dess han förstår sig på det här med programmering (speciellt när det gäller dessa små 8-bitars processorer med mycket begränsat RAM-minne) lite bättre

Det tror jag också!

Men så varje funktion måste ge tillbaka ett värde för att....tömma på ramminnet lite?

[TomasL]

Nej naturligtvis inte, men du måste lära dig hur funktionsanrop och rekursiva funktioner i C fungerar.
Du måste lära dig skillnaden mellan globala, statiska och lokala variabler och hur de beter sig vid till exempel ett funktionsanrop och rekursivitet.
Uppenbarligen måste du också lära dig vad ett returvärde är.

[TomasL]

Jag skulle nog säga att pekare är nått man lär sig före man lär sig om stacks osv. Men det är klart det är ju µC'n vi talar om och inga vanliga datorer så du har helt klart en poäng.

Hmm, tja, jag menade inte att man skall lära sig om stackar heller, snarare det elementära, dvs hur variabler och variabeldefinitioner/deklarationer osv fungerar, samma gäller även konstanter och dess olika varianter på definition, samt hur funktionsanrop fungerar.
Kort och gott de elementära grunderna i C

[Al_Bundy]

Nej naturligtvis inte, men du måste lära dig hur funktionsanrop och rekursiva funktioner i C fungerar.
Du måste lära dig skillnaden mellan globala, statiska och lokala variabler och hur de beter sig vid till exempel ett funktionsanrop och rekursivitet.
Uppenbarligen måste du också lära dig vad ett returvärde är.

Jag ska skriva en liten kod som visar hur jag tänker ungefär

Kod: Markera allt

#include <stdout>

int main()
{
  int varde;
  varde = funk1();
  funk2(varde);
}

int funk1()
{
  /* I denna funktion så får jag ett värde som jag skickar tillbaka */
  return x;
}

int funk2(int x)
{
  /* I denna funktion så gör kollar jag om x är mitt rätta värde.
  Om x är mitt rätta värde så går jag vidare till funk3(), annars hoppar jag till funk1();*/
  
  if (1 == x)
  {
    funk3("Hej");
  }
  else
  {
    varde = funk1();
    funk2(varde);
  }
  
  /* här slutar hela programmet på denna rad */
}

String funk3(String word)
{
  printf(word);
}

Om x skulle vara inte 1 så skulle programmet loopa och det är ungefär så här jag tänker vid programmerning. Jag glömmer bort(inte nu kanske) att än fast jag hoppar vidare i en funktion så lämnar jag fortfarande spår.

Om det inte finns någon metod att sopa igen dessa spår så måste jag tyvärr programmera på något hela annat sätt som jag aldrig har testat på någonsin.

[sodjan]

> ...annars hoppar jag till funk1()

Nej, nej, nej, nej...
Du *hoppar* aldrig till en funktion, de anropas !!

Det är ju exakt på denna punkt som du tänker fel från första början!
Ett funktionsanrop är inget "hopp" som en "goto" eller något liknande... !!

Om du gör om funk2() till en oändlig loop (while 1;...) och tar
bort anropet funk2(varde); så fungerar det "i princip"...

[TomasL]

Kod: Markera allt

#include <stdout>

int main()
{
  int varde;
  while (1)
  {
  	varde = funk1();
  	funk2(varde);
  }
}

int funk1()
{
  /* I denna funktion så får jag ett värde som jag skickar tillbaka */
  return x;
}

int funk2(int x)
{
  /* I denna funktion så gör kollar jag om x är mitt rätta värde.
  Om x är mitt rätta värde så går jag vidare till funk3(), annars hoppar jag till funk1();*/
  
  if (1 == x)
  {
    funk3("Hej");
  }
   
  /* här slutar hela programmet på denna rad */
}

String funk3(String word)
{
  printf(word);
}

Typ.

[Al_Bundy]

> ...annars hoppar jag till funk1()

Nej, nej, nej, nej...
Du *hoppar* aldrig till en funktion, de anropas !!

Det är ju exakt på denna punkt som du tänker fel från första början!
Ett funktionsanrop är inget "hopp" som en "goto" eller något liknande... !!

Om du gör om funk2() till en oändlig loop (while 1;...) och tar
bort anropet funk2(varde); så fungerar det "i princip"...

Okej! Jag får lägga detta på minne att en funktion är något man anropar och inte går till, samt att en funktion skall alltid skicka tillbaka ett värde, om det inte är en void funktion.

Men kommer denna funktion skriva ut detta tal 3?

Kod: Markera allt

int main()
{
  int tal;
  tal = funk1();
  printf(tal);
  // här skriver printf(tal) ut värdet 10.
}

int funk1()
{
  int varde;
  varde = 10;
  return varde;
  printf("3");
  // Kommer då printf("3") köras efter funk1() har skickat ett värde?
}

[TomasL]

nja, return är det sista du skall ha innan du hoppar ut.
return avslutar funktionen, så den kommer inte att utföra sista raden.

Varför försöker du inte att läsa grundkurser i C, i stället för att bara gissa dig fram?