Tags:    c++

Afsnit 10
Indtil videre har vi puttet al vores koden ind i main. Det er også fint til små programmer, men forestil dig at hele koden til Windows eller Linux skulle være inden for main funktionen, det ville være ret upraktisk.

Derfor har man opfundet funktioner, der kan bruges til at splitte koden op i mindre dele.

Lad os se på et eksempel på en funktion:

#include <iostream>
int add(int a, int b)
{
   int c = a + b;
   return c;
}
int main()
{
   int x = add(2, 3);
   std::cout << x << std::endl;
}

Her er add en funktion. I parentesen efter navnet på funktionen står parametrene til funktionen, og deres type.

De står på ca. samme måde som man laver variabler. Hvis ikke funktionen skal bruge nogen parametre lader man bare parentesen være tom.

int foran navnet på funktionen betyder at den returnerer en int, hvis ikke den skal returnere noget skal man skrive void i stedet.

I funktionen laver vi en variabel, c, der er a + b, denne værdi returneres.

I main kalder vi funktionen, dvs udfører koden i funktionen, funktionen laver ikke noget før den bliver kaldt.

Da vi har skrevet 2 og 3 i parentesen betyder det at disse bliver til parametre til funktionen.

I funktionen vil a således være 2 og b vil være 3. c bliver sat til at være summen af de to, dvs. 5, denne værdi returneres.
Tilbage til main vil x blive sat til at være returværdien fra add, dvs. 5.

Det er jo ganske simpelt? Du har allerede brugt flere funktioner, f.eks. std::getline, rand.

Lad os tage et eksempel mere. Vi så før at det var besværligt at læse et enkelt bogstav, men det er måske noget der skal gøres mange gange, så lad os lave en funktion til det:

char GetBogstav()
{
   std::string S;
   std::getline(std::cin, S);
   return S[0];
}

Så kan man bruge den med.
[/pre]
std::cout << "Vil du? ";
char ch = GetBogstav();
if(ch == 'j')
std::cout << "Ok" << std::endl;
[/pre]
Smart ikke?

Der er lige en ting mere vi skal have på plads. For at vi kan få lov til at kalde en funktion skal kompileren vide hvordan funktionen ser ud.
I det først eksempel skrev vi funktionen add inden main, og så er der ingen problemer.
Men ofte vil man gerne have dem byttet om, så main står først, og hvad gør man så?
Man laver en prototype på funktionen:

#include <iostream>
int add(int a, int b);
int main()
{
   int x = add(2, 3);
   std::cout << x << std::endl;
}
int add(int a, int b)
{
   int c = a + b;
   return c;
}

Her er den første linie med add en prototype, den ser ud på samme måde som selve funktionen, indtil { hvor der i stedet er et ;

En prototype betyder noget i retning af at, der kommer senere en funktion der ser sådan ud, jeg skal nok fortælle dig hvordan den ser ud senere.

Opgaver
Lav regnestykke eksemplet fra afsnit 8 om så det bruger funktioner til plus, minus, gange og dividere.

En funktion kan naturligvis godt kalde andre funktioner, og den kan enda kalde sig selv.
Lav en funktion der kalder sig selv og beregner 3*2*1 hvor det første tal i rækken skal være en parameter.
Du skal bruge en if for at undgå at den kalder sig selv igen og igen for evigt.
Hvor store tal kan man gøre det med og få det rigtige resultat?
Brug evt. windows lommeregner til at checke, den kan regne med meget større tal end os, der hedder det n!

Afsnit 11
Lad os kikke lidt på dette kode:

#include <iostream>
void foo(int a)
{
   a++;
   std::cout << a << std::endl;
}
int main()
{
   int x = 1;
   foo(x);
   std::cout << x << std::endl;
}

Hvad vil det skrive? Man kunne tro at det ville skive 2 begge gange, men det gør det ikke.
Det skriver 2 første gang og 1 anden gang.
Det skyldes at når vi kalder foo vil den modtage et kopi af x, denne kopi (som er 1) vil den lægge 1 til, resultatet (2) vil den så udskrive.
Tilbage i main vil vi udskrive x, den er stadig 1 da foo kun ændrede på kopien af x, ikke x i sig selv.
Det er fint i nogle tilfælde, men i andre tilfælde vil vi gerne have foo til at ændre på x og ikke kun kopien af x, og hvad gør man så?

Man bruger en reference.

En reference er en variabel der referer til en anden variabel, man siger også at en reference er et alias, dvs. et andet navn, for en anden variabel.

En reference i sig selv kan ikke indeholde noget, den kan kun referere til en anden variabel.

Et simpelt eksempel:

#include <iostream>
int main()
{
   int i = 2;
   int& r = i;
   i++;
   std::cout << i << ", " << r << std::endl;
   r++;
   std::cout << i << ", " << r << std::endl;
}

Her er i en almindelig int.
r er en reference til en int, den sættes til at referere til i.

Når vi så tæller i op, og udskriver både i og r vil de begge skrive at de er 3, simpelthen fordi det er to udgaver af det samme.
Når vi derpå tælle r op, tæller vi i virkeligheden i op, og både i og r vil fortælle at de er 4.

Og nu til bage til vores eksempel, hvis vi laver foo om så den får en reference i stedet:

#include <iostream>
void foo(int& a)
{
   a++;
   std::cout << a << std::endl;
}
int main()
{
   int x = 1;
   foo(x);
   std::cout << x << std::endl;
}

Så vil programmet skrive 2 begge gange!

Det er fordi a, som er parameteren til foo, nu er en reference til x, så nå foo tæller a op, vil den tælle det op som a refererer til, dvs. x i main.
En reference vil altid referere til det samme, man kan ikke sætte den til at referere til noget andet.
Og en reference vil altid referere til noget.

De følgende eksempler er ugyldige:

   int& x = 1;

En reference skal referere til en variabel.

   int& y;

En reference skal referere til noget.

Int i, j;
int& z = i;
z = j;

En reference skal skal altid referere til det samme.
En reference kan være const:

double d;
const double& r = d;

Man kan godt læse fra en const reference, men man kan ikke skrive til den.
Det kan i nogle tilfælde være praktisk, f.eks. i følgende:

void foo(const int& a)
{
   std::cout << a << std::endl;
}
int main()
{
   foo(1);
}

Hvis ikke a i kaldet til foo var const kunne man ikke bruge 1 som argument, men var nødt til at lave en variabel, det betyder så at foo ikke kan ændre a, men det giver heller ikke rigtigt mening at ændre 1.
Det samme gælder her:

void foo(const std::string& a)
{
   std::cout << a << std::endl;
}
int main()
{
   foo("Hello World");
}

Når man vil overføre en std::string til en funktion er det oftest en fordel at bruge referencer fordi programmet så slipper for at kopiere strengen.
Hvis man så ikke vil have at funktionen roder i ens streng kan man lave den const.

Opgaver
1: Lav regnestykke eksemplet som vi så på i afsnit 10 om, så funktionerne ikke returnerer resultatet, men overfører det som en parameter vha. reference.

Afsnit 12
Vi så i sidste afsnit at man kunne lave en add funktion:

   int add(int a, int b)

Hvis man så ville bruge funktionen med double, måtte man lave en version der bruger double:

   double add(double a, double b)

Dette ville virke fint, men det er lit trivielt at lave add funktioner for alle mulige typer.

Og netop det trivielle vil programører gøre meget for at undgå, så der findes naturligvis noget der er smartere, man kan bruge template funktioner:

template <typename T>
T add(T a, T b)
{
   T c = a + b;
   return c;
}

Dette er en template funktion der kan lægge alle typer sammen, man bruger den på samme måde som andre funktioner:

   std::cout << add(2, 4) << std::endl;

Det der sker er at når compileren skal oversætte finder den ud af hvilen type T er og så laver den en funktion der tager netop denne type.
Man skal være opmærksom på at de to argumenter i dette tilfælde skal være den samme type, og det er også typen på det der returneres.
Hvis vi skriver:

   std::cout << add(2.4, 4) << std::endl;

Vil compileren brokke sig, for de to argumenter har ikke samme type, 2.4 er en double, 4 er en int. Vi kan løse problemet ved at skrive:

   std::cout << add(2.4, 4.0) << std::endl;

For så er begge argumenter double, og compileren er glad igen. Eller vi kan fortælle compileren at den skal bruge en bestemt type for T, f.eks:

   std::cout << add<double>(2.4, 4) << std::endl;

Så vil den lave 4 om til en double og bruge double udgaven af add.
Vi kan naturligvis godt have flere template argumenter:

template <typename T1, typename T2>
T1 add(T1 a, T2 b)
{
   return a + b;
}

Så behøver de to argumenter ikke have samme type, og funktionen vil returnere en værdi af den type som det første argument havde.
Bemærk at for at kalde en template funktion er det ikke nok med en prototype, compileren skal have hele funktionen for at kunne oversætte.

Opgaver
Lav regne maskine eksemplet om til at bruge template funktioner.
Prøv at ændre typen af det der regnes på fra int til double og unsigned short.



Hvad synes du om denne artikel? Giv din mening til kende ved at stemme via pilene til venstre og/eller lægge en kommentar herunder.

Del også gerne artiklen med dine Facebook venner:  

Karma barometer (30 dage)

IT jobs | Kontakt | Om Udvikleren.dk | Om karma | IT nyheds arkiv | Annoncering

X