Azine
Om tidningen Azine
Köpa Azine
Kontakta Azine
Hjälpa till
Annonsera i Azine
About Azine English

Senaste numret
Nästa nummer
Arkiv

Kurser/Skolor
Intervjuer
Forum

ACG
SUA
ACG Göteborg
AmigaGuiden

Annonsörer:
GGS-Data

Sponsorer:
AmigaRulez (Forum)
GGS-Data
WestSide Praetorian
M.Andersson

Försäljningsställen
GGS-Data
Guru Meditation


Senaste Nummer 8 Nummer 7 Nummer 7 bilaga Nummer 6 Nummer 5++ Nummer 4 Nummer 3 Nummer 2 Nummer 1









Vill du ha din banner här?
Skriv till [email protected]!
Välkommen till hela Sveriges Amigatidning.


ACGs maskot

Grunderna i C, del 3.

I förra numret gick vi igenom hur man gjorde val och hur man gjorde upprepningar. I den här delen kommer vi att lära oss hur man gör egna funktioner.

Vad är en funktion?

En funktion är ett block av kod som kan anropas. Vi har redan i vårt första program skapat en funktion och denna var funktionen main (där exekveringen av programmet börjar).
En funktion ska vara deklarerad innan den används. Till exempel: float medel(int tal1, int ta2);
Funktionsdeklarationer av den här typen kallas funktionsprototyp.
Man kan även skriva funktions­prototypen som float medel(int, int);. Identifierare som tal1 och tal2 i exemplet används inte av kompilatorn men kan skrivas in för att hjälpa programmeraren eller andra som läser koden.
Funktionsprototypen säger till kompilatorn hur många argument som en funktion tar samt vilken typ dessa är. Dessutom talar den om vad funktionen returnerar.
Till exempel funktionsprototypen för funktionen printf, som är int printf(const char *format, ...);, kan hittas i filen stdio.h.

Skriva egna funktioner

Vi börjar lite lätt med att skapa en liten funktion som räknar ut medelvärdet av två tal. Vi kallar den funktionen medel. Skriv in enligt Figur 1.

Figur 1.

#include 
float medel(int tal1, int tal2);int main(void)
{
  int tal1 = 4, tal2 = 3;
  float medeltalet;  medeltalet = medel(tal1, tal2);
  printf("Medel är: %f\n",medeltalet);
  
  return 0;
}float medel(int tal1, int tal2)
{
  float medeltal;
  medeltal = (tal1 + tal2)/2;
  return medeltal;
}

Vad har vi gjort?

float medel(int tal1, int tal2);
Här har vi funktionsprototypen för vår funktion medel. Funktionen tar 2 argument, som båda är av typen int (heltal). Funktionen returnerar en float (flyttal). Man behöver inte skriva in tal1 och tal2 här, så det går lika bra utan dessa så länge man inte plockar bort de två inten.
medeltalet = medel(tal1, tal2);
Här anropar vi vår funktion medel med variablerna tal1 och tal2 (variablerna behöver inte heta likadant som i funktionsdefinitionen (se beskrivningen av medel() nedan). Resultatet (det funktionen returnerar) ska lagras i variabeln medeltalet.
float medel(int tal1, int tal2)
{
  ...
}
Här har vi funktionsdefinitionen. Observera att det inte är ett ; efter denna utan att den följs av ett block({ och sedan }). När funktionen anropas så kommer koden i blocket att exekveras. Inparametrarna används på samma sätt som vanliga variabler. Vi räknar ut medeltalet av tal1 och tal2 och lagrar det i den lokala variabeln medeltal. Variabeln medeltal kan endast användas i funktionen (i det block den är deklarerad).
return medeltal;
Här returnerar vi resultatet från vår funktion, värdet i variabeln medeltal.

Inparametrarnas hantering i C

Parametrar till funktioner är alltid hanterade som värden i C, så kallad call by value. Det vill säga att när man anropar en funktion med variabeln tal1 så är det värdet i variabeln som skickas till funktionen, inte själva variabeln. Därför är argumenten i funktionsdefinitionen egentligen lokala variabler som enbart gäller i själva funktionen, fast de får sina startvärden satta av anropet till funktionen.
Vi kan demonstrera detta genom Figur 2. Eftersom argumentet till funktionen endast skickas som ett värde så ändrar vi bara i variabeln tal internt i funktionen valuechange. För att kunna skicka in argument som vi vill kunna ändra på till en funktion så måste vi använda oss av så kallade pekare. Att använda pekare för detta kommer vi att ta upp i en senare del i programmeringsskolan.

Figur 2.

#include 
void valuechange(int);int main(void)
{
  int tal=0;
  printf("Tal är %d\n",tal);
  valuechange(tal);
  printf("Tal är nu %d\n",tal);
  return 0;
}void valuechange(int tal)
{
  tal = 12;
  return;
}

Arrayer, strängar

Nu ska vi lära oss lite mer komplexa hanteringar av data.
I C är en textsträng en array, och en array är egentligen en pekare. En pekare är en adress som pekar på minnet i datorn. Mer om pekare i en annan del av skolan, men nu hugger vi in i Arrayer och strängar!

Arrayer

Arrayer används då man vill ha många variabler av samma typ (int, float, char o.s.v.). Då man deklarerar en array ser det ut på följande sätt: int a[4];
Det som händer här är att vi allokerar minnesutrymme för en array med plats för 4 stycken element, i det här fallet av typen int.
För att komma åt dessa använder vi oss utav [ och ] och emellan dessa så skriver vi in vilken position som det gäller. T.ex. a[0], a[1], a[2], a[3]. När man indexerar en array så ligger första elementet på position 0. Det innebär att en array med storleken 4 går indexeras från 0 till 3.
Skriv in enligt Figur 3.

Figur 3.

#include int main(void)
{
  int tal[3], i, summa = 0;
  
  for(i=0; i<3; i++)
  {
    printf("Skriv in ett tal: ");
    scanf("%d",&tal[i]);
  }  for(i=0;i<3;i++)
  {
    printf("Tal %d: %d\n",i,tal[i]);
    summa += tal[i];
  }  printf("Summan är: %d\n",summa);
  return;
}  

Vad har vi gjort?

scanf(%d,&tal[i]);
Här läser vi in det vi skriver när programmet kör. Det som är annorlunda här jämfört med vad vi gjorde i del 1 av programmeringsskolan är att vi nu lagrar resultatet i en array. tal[i] pekar ut ett element i arrayen och & säger att vi ska ha adressen till den positionen (se del 1 för mer information om varför vi använder &). For­satsen kör från 0 till 2, så i kommer att vara 0, 1, 2. Varje varv lägger vi in talet i en ny position i arrayen.
printf(...,tal[i]);
Här skriver vi ut talet i positionen som variablen i pekar ut (i går från 0 till 2 i for­loopen) i arrayen.
summa += tal[i];
Här passar vi på att lägga till talet i arrayen (position i där i går från 0 till 2 i for­loopen) till variabeln summa.

Strängar

Strängar är som sagt samma sak som en array fast här är vi låst till typen char eftersom det är bokstäver och tecken vi håller på med.
För att programmet ska hålla reda på vart texten i strängen slutar så ska den alltid avslutas med en position som innehåller värdet noll. Det innebär att en sträng alltid måste vara ett tecken större än antalet tecken i texten som ska rymmas i den.
Det finns flera bra funktioner för att hantera strängar och jag tänkte vi skulle börja med några lättare.
Skriv in enligt Figur 4.

Figur 4.

#include int main(void)
{
  char namn[7];
  int langd = 0;  strcpy(namn, "Magnus");
  langd = strlen(namn);
  prinf("Namnet är %s.\n",namn);
  printf("Längden är %d.\n",langd);  namn[3] = 0;
  printf("Namnet är %s.\n", namn);
  printf("Längden är %d.\n",
           strlen(namn));
  return;
}

Vad har vi gjort nu?

char namn[7];
Här deklarerar vi vår sträng, på samma sätt som en array eftersom de egentligen är samma sak. Storleken är satt till 7 tecken. Vi kommer att kopiera in texten Magnus i den och det är 6 tecken. Men eftersom det behövs ett tecken till (värdet 0') för att programmet ska veta var texten slutar så behöver strängen alltså vara 7 tecken stort.
strcpy(namn,"Magnus");
Här kopierar vi en sträng (Magnus) till en annan sträng. Strängen Magnus är även den 7 tecken lång med en nolla på slutet, men den syns ju inte. Så vi kopierar alltså 7 tecken här, 6 bokstäver och en avslutande nolla.
langd = strlen(namn);
Den här funktionen returnerar antalet tecken i texten som finns i strängen namn. Vi lagrar längden i variabeln langd.
­namn[3] = 0;
Här sätter vi den fjärde positionen (första positionen är ju [0]) i strängen till noll (slut på strängen).
printf(...,namn, strlen(namn));
Här skriver vi ut den modifierade strängen och resultatet av strlen(). Vi kan använda funktionsanropet till strlen() direkt i fprintf eftersom den returnerar ett tal och det är ett tal vi ville skriva ut i printfen. Dock ändrar vi ju inte på variabeln langd, så den är fortfarande 6, som den omodifierade strängens längd.

Avslutning

Här passar det nog att avsluta del 3 av programmeringsskolan.
Har ni frågor om det som skrivits här eller i någon av de föregående delarna så skriv till [email protected]


Hemsidorna underhålls av Magnus Andersson