12 - Funktioner

Funktioner


Det här kanske blir en lång del av min guide för det är ganska mycket vi ska gå igenom, mycket viktiga saker som är väldigt användbara. Funktioner är ett jättebra sätt att programmera på innan man kan objektorienterad programmering. Det bygger i princip på att man delar upp sin kod i olika bitar, och dessa bitar ska göra var sin väldigt specifik sak. Man kan då testa varje bit för sig och se att de fungerar och på detta sätt så blir det oändligt mycket enklare att hitta och förebygga problem i koden!

Jag kan börja med att berätta att int main() är en funktion, fast det kanske ni redan visste, main är dessutom en funktion som finns i alla program och det är här som programmet startar.

Vi börjar med ett exempel som har ytterligare en funktion förutom main:

  1.  
  2. #include<iostream>
  3.  
  4. using std::cout;
  5.  
  6. void minFunktion();
  7.  
  8. void minFunktion()
  9. {
  10.   cout << "Nu är vi i funktionen minFunktion!\n";
  11.   return;
  12. }
  13.  
  14. int main()
  15. {
  16.   cout << "Nu startar vi!";
  17.   minFunktion();
  18.   cout << "Nu är vi tillbaka i main-funktionen igen!";
  19.  
  20.   return 0;
  21. }
  22.


På sjätte raden gör vi så att funktionen kan anropas från vart som helst i koden, om man inte gör detta kan bara funktioner som ligger nedanför den funktionen i koden anropa den. Detta spelar egentligen inte så stor roll när man bara har två funktioner, men när man har flera så kan det bli omöjligt att lägga funktionerna så att de ligger i ordning och därför behöver man skriva såhär. Det man egentligen skriver är precis samma sak som första raden på funktionen fast med ett semikolon efter.

På rad åtta skapar vi själva funktionen och det ser ju ganska mycket ut som när vi skapar main. Skillnaden är att vi använder oss av datatypen void, void är en typ som inte är någon typ skulle man kunna säga, den används när man måste bestämma en datatyp men egentligen inte vill hå någon.

Anledningen till att man bestämmer en datatyp på en funktion är att man kan skicka tillbaka värden från funktionen med raden "return". I vår main-funktion har vi alltid returnerat värdet 0, och därför är datatypen int (heltal). I fallet med main spelar det ingen jättestor roll vilket värde man returnerar eftersom ingen troligtvis kommer att se detta värde. När man gör egna funktioner brukar man dock returnera värden som betyder något meningsfullt.

Den funktion som vi deklarerat nu kommer inte att returnera något spciellt värde, den kommer bara att skriva ut en text. Därför använder vi datatypen void och skriver bara "return;"

Programmet börjar i main som alla program gör och skriver ut texten "Nu startar vi!", sedan kommer den här raden:
minFunktion();

Detta är vad man kallar funktionsanropet, man anropar en funktion, och här kommer programmet alltså börja köra koden som finns i funktionen minFunktion. Min funktion skriver ut ytterligare en text och när det är klart kommer koden fortsätta att köras från efter den punkt där man gjorde funktionsanropet.

Här kommer en till void-funktion med den skillnaden att vi skickar med en variabel till funktionen. Variabler som skickas till en funktion kallas argument eller parametrar.

  1.  
  2. #include<iostream>
  3.  
  4. using std::cout;
  5.  
  6. void minFunktion(int tal);
  7.  
  8. void minFunktion(int tal)
  9. {
  10.   cout << "Nu är vi i funktionen!";
  11.   cout << tal << "\n";
  12.   return;
  13. }
  14.  
  15. int main ()
  16. {
  17.   int tal=21;
  18.  
  19.   // Det går att anropa funktionen genom att ange en variabel som argument/parameter
  20.   minFunktion(tal);
  21.  
  22.   cout << "Nu är vi tillbaka i main igen!\n";
  23.  
  24.   // Det går även anropa funktionen genom att direkt skriva in ett värde!
  25.   minFunktion(12);
  26.  
  27.   return 0;
  28. }
  29.


Vi deklarerar alltså en variabel i main, döper den till tal och tilldelar den värdet 21. Sedan reser vi upp till funktionen minFunktion och tar med oss variabeln tal.

Eller vi kopierar rättare sagt värdet av variabeln och skickar det till funktionen. Ja, så är det faktiskt. Om vi ändrar på vaiabeln i funktionen minFunktion så kommer variabeln fortfarande ha värdet 21 i main funktionen, det är bara lokalt i funktionen som värdet kommer att ha ändrats.

Om man vill ändra på en variabel så gör man på ett annat vis som jag ska visa i en senare del.

Här kommer en funktion som använder sig utav ett returvärde:

  1.  
  2. #include<iostream>
  3.  
  4. using std::cout;
  5.  
  6. int minFunktion(int tal);
  7.  
  8. int minFunktion(int tal)
  9. {
  10.   cout << "Nu är vi i funktionen!\n";
  11.   tal+=2;
  12.   return tal;
  13. }
  14.  
  15. int  main ()
  16. {
  17.   int tal=21;
  18.   int retur;
  19.  
  20.   retur = minFunktion(tal);
  21.   cout << retur;
  22.   cout << "Nu är vi tillbaka i main igen!\n";
  23.   cout << tal;
  24.  
  25.   return 0;
  26. }
  27.


Ok, nu ska jag förklara lite igen.
Nu gör vi funktionen av datatypen int i stället för void eftersom att vi nu vill använda oss av ett returvärde, ett värde som vi skickar tillbaka till funktionsanropet. Lägg också märke till att vi tilldeler värdet av funktionsanropet (alltså det värde som funktionen returnerar) till variabeln retur.

I funktionen så ökar vi variabelns värde med 2, när vi gör detta ändras bara värdet på variabeln i funktionen och inte i hela programmet! Variabeln tal kommer alltså fortfarande att ha värdet 21 i main-funktionen. Men vi skickar även tillbaka det nya värdet (23) som ett returvärde.

I en senare del av den här guiden som handlar om pekare kommer jag att visa hur man kan göra för att ändra på variablen i main från funktionen.

Nu ska jag visa hur man gör en funktion som tar två tal som användaren matar in och multiplicerar det ena värdet med det andra:

  1.  
  2. #include<iostream>
  3.  
  4. using std::cout;
  5. using std::cin;
  6.  
  7. int minFunktion(int tal_1, int tal_2);
  8.  
  9. int minFunktion(int tal_1, int tal_2)
  10. {
  11.   int summa;
  12.  
  13.   summa = tal_1 * tal_2;
  14.  
  15.   return summa;
  16. }
  17.  
  18. int main ()
  19. {
  20.   int tal_1, tal_2;
  21.  
  22.   cout << "Skriv in ett tal:\n";
  23.   cin >> tal_1;
  24.   cout << "Skriv in ett tal till:\n";
  25.   cin >> tal_2;
  26.  
  27.   int produkt = minFunktion(tal_1, tal_2);
  28.  
  29.   cout << "Produkten av " << tal_1 << " och " << tal_2 << " blir " << produkt << "!\n"; 
  30.  
  31.   return 0;
  32. }
  33.


Vi börjar med main. På första raden i main så deklarerar vi 2 variabler tal_1 och tal_2, sedan ber vi användaren fylla på värden i dessa variabler.

På 27:e raden anropar vi funktionen minFunktion och skickar med variablerna tal_1 och tal_2 och sparar sedan returvärdet från det funktionsanropet i variabeln produkt.

Funktionen minFunktion tar helt sonika de två argumenten och multiplicerar dem. Värdet skickas sedan tillbaka med hjälp utav return.

Källa: http://blinkenlights.se/