Introduktion till programmering - Mittuniversitetet

Introduktion 

till 

programmering 

v. 1.12- 2007-02-10 

Mittuniversitetet 

Institutionen för Informationsteknologi och medier 

Datateknik 

Martin Kjellqvist

Introduktion till programmering 

Martin Kjellqvist 

Innehållsförteckning 

1 Inledning ....................................................................................................................................4 

2 Språket C++ ..............................................................................................................................5 

2.1 Valet av språket C++ för kompendiet.................................................................................5 

2.2 Språket ..................................................................................................................................5 

2.3 Att programmera..................................................................................................................5 

2.4 Hello World..........................................................................................................................5 

2.5 Att skapa ett program, kompilering och länkning .............................................................8 

2.6 main()....................................................................................................................................8 

3 Datorn som miniräknare.......................................................................................................10 

3.1 Räkneoperationer ...............................................................................................................10 

3.2 Variabler .............................................................................................................................10 

4 Datatyper och Uttryck ...........................................................................................................13 

4.1 Datatyper ............................................................................................................................13 

4.2 Deklarationer......................................................................................................................13 

4.3 Identifierare ........................................................................................................................14 

4.4 Uttryck och operationer.....................................................................................................17 

5 Inmatning och utskrift...........................................................................................................25 

5.1 Utskrift till skärm...............................................................................................................25 

5.2 Inmatning från tangentbordet............................................................................................27 

6 Villkor och styrsatser.............................................................................................................31 

6.1 Villkorssatsen if .................................................................................................................31 

6.2 Logiska villkor ...................................................................................................................33 

6.3 Iteration...............................................................................................................................37 

7 Texthantering..........................................................................................................................45 

7.1 Typen char..........................................................................................................................45 

7.2 Fältvariabler .......................................................................................................................47 

7.3 In och utmatning ................................................................................................................48 

7.4 Texthanteringsfunktioner ..................................................................................................52 

7.5 Datatypen string .................................................................................................................55 

8 Funktioner och procedurell abstraktion.............................................................................57 

8.1 Funktioner ..........................................................................................................................57 

8.2 Funktioner som behöver indata.........................................................................................60 

8.3 Funktioner som returnerar värden.....................................................................................63 

8.4 Speciella datatyper för funktionsargument ......................................................................65 

9 Fältteori....................................................................................................................................69 

9.1 Fält av andra datatyper än char .........................................................................................69 

10 Standardalgoritmer................................................................................................................73 

10.1 Swap funktion ....................................................................................................................73 

10.2 Sök minsta värdet i en array..............................................................................................73 

10.3 Array sortering ...................................................................................................................74 

10.4 Övrigt..................................................................................................................................75 

11 Operatorprioriteter................................................................................................................76 

12 Teckenkoder – Asciitabell .....................................................................................................77 

2



3



1 Inledning 

Detta kompendium är tänkt att fungera som ett förberedande material och komplement 

till föreläsningar inom teoretiska studier av grundläggande programmering. 

Programmeringsspråket som är valt för kompendiet är C++ men det mesta utav teorin 

är applicerbar på de flesta strukturerade och objektorienterade programspråk, såsom 

Pascal, c, Java, Fortran, JavaScript(ECMA skript). 

Texten förutsätter inga förkunskaper annat än gymnasiekompetens och datorvana. 

Texten läses med fördel vid en dator där man har möjlighet att testa de olika program 

och konstruktioner som dyker upp i texten. 

4



2 Språket C++ 

2.1 Valet av språket C++ för kompendiet 

2.2 Språket 

Språket C++ är ett språk som utvecklats för storskalig objektorienterad utveckling av 

sofistikerade och komplexa system. Det ligger då i sakens natur språket har flera 

vinklar och vrår som inte kommer att vara viktiga under studier av grundläggande 

programmering, men som än dock kommer att påverka den praktiska 

programmeringen. 

Det kommer att dyka upp flera exempel på saker som inte har någon naturlig förklaring 

bland den del av språket som texten behandlar, saker som då kan kännas obekväma 

eller onödiga. Men tanken är att en stor andel av er som använder detta kompendium 

kommer att fortsätta studera programmering i C++. C++ är ett av de mest omfattande 

programmeringsspråk som finns, men det är samtidigt förmodligen det mest 

uttrycksfulla språk, trots det är den del som berörs i denna text i all väsentlighet snarlik 

de flesta andra datorspråk. 

C++ är en blandning av ett objektorienterat språk och ett strukturerat språk, en sk 

hybrid, och har troligtvis en större marknadsandel av komersiella applikationer än 

något annat språk. C++ är ett relativt nytt språk, standardiseringen gjordes sent 1998. 

Språket har tidigare funnits i olika former och dialekter sedan tidigt 80-tal. 

Bjarne Strostrup är den ursprunglige konstruktören (eller uppfinnaren) av C++. Han 

har skrivit flera böcker som i det närmaste erhållit bibelstatus bland C++ 

programmerare, bla "The C++ programming language", Addison-Wesley. 

2.3 Att programmera 

För att kunna programmera behöver du en dator (duh?) och en utvecklingsmiljö ( en 

kompilator och en textredigerare ). För kompendiet har valts Microsoft Visual C++ 6.0 

(VC) som testmiljö eftersom den används på Mitthögskolan och är dessutom en vanlig 

professionell miljö för programvaruutvecklning på PC. För eget bruk finns VC (Visual 

C++) med studentlicens för under tusenlappen. Ett annat alternativ är ett gratispaket 

som heter DJGPP som finns att hämta på nätet http://www.delorie.com/djgpp/. Det 

finns dessutom en grafisk gratismiljö som heter Dev-C++ som finns på 

http://www.bloodshed.net/devcpp.html. 

2.4 Hello World 

Då man först introduceras till ett nytt programspråk eller en ny programmeringsmiljö 

bör man först se till att man behärskar proceduren att skapa ett körbart program. Det 

sker väldigt ofta med Hello World. Syftet med Hello World programmet är att se hur 

allting fungerar då man ska skapa ett program. 

5



2.4.1 Börja programmera 

För att komma igång att programmera börjar man med att starta programmet VC 6.0 

(om det är VC man använder:-) Inställningarna är snarlika i VS.NET 

För att kunna börja skriva ett program i VC måste man skapa ett projekt. I denna kurs 

kommer vi uteslutande att skapa textbaserade program i projekt av typen Win32 

Console application. 

1. Menyalternativ File / New ... 

2. Dialogrutan New / flik Projects, välj Win32 Console application. 

3. Ange projektets namn i rutan för detta. Det kommer att skapas en 

katalog med detta namn. Lämpligt namn kan vara tex "HelloWorld". 

4. Peka ut var någonstans på hårddisken du vill att projektet ska 

skapas. Detta kan vara väldigt viktigt att det görs rätt om du arbetar 

i en labbsal, fråga din handledare. 

5. Välj Ok då du är nöjd med dina val. 

Win32 Console Application Wizard - Välj Empty project, tryck Finish / Ok 

I VS.NET finns det en extra flik med inställningar där du fyller i detta. 

6



#include 

using namespace std; 

I varje C++ miljö är ett program indelat i en eller flera filer där den vanligaste filtypen 

är källkodsfiler eller cpp filer. Man kallar dem cpp filer eftersom de har suffixet .cpp. 

För att kunna börja skriva programmet ska programmets huvudfil skapas. Det görs 

genom att man går till menyn File / New … , väljer C++ source file och anger namnet ( 

i rutan File Name ) till förslagsvis main. Filen du nu skapar kommer alltså att få 

namnet main.cpp. 

Nu är det dags att mata in programmet. 

I det nya textfönstret som dykt upp ( editorn ) kan vi nu mata in följande 

int main() 

{ 

cout



2.5 Att skapa ett program, kompilering och länkning 

Det som du skrev in i utvecklingsmiljöns editor var C++ källkod, dvs programrader 

med C++ satser. Datorn förstår inte dessa satser naturligt utan måste först översätta 

dem till ett för datorn förståeligt språk, s.k. objektkod. Den objektkod som skapas 

måste därefter sättas ihop till ett körbart program. Dessa procedurer kallas kompilering 

respektive länkning. 

2.5.1 Kompilering 

2.5.2 Länkning 

2.6 main() 

När ett program kompileras kontrolleras först att dess syntax är riktig. Det innebär att 

kompilatorn ser till att de programrader som är skrivna i källkoden följer de regler som 

finns för språket C++. Ungefär på samma sätt som en modern ordbehandlare kan 

kontrollera stavning, avstavning och andra språkregler. 

Då felkontrollsproceduren är avklarad ( den sker egentligen i flera steg ) börjar 

översättningen till objektkod. Resultatet av översättningen är vanligvis en fil som i vårt 

exempel heter HelloWorld.obj eller något liknande. I den filen finns lösryckta fragment 

av för datorn förståelig programkod. Dessa måste nu sättas ihop för att kunna köras 

som ett program. Det görs av länkaren. 

När objektfilerna skapats tar länkaren vid för att skapa ett körbart program. Det gör den 

genom att foga ihop det skrivna programmet med andra befintliga objektfiler s.k. 

biblioteksfiler. Bland annat kommer vårt Hello World programs objektfil att kopplas 

ihop med funktioner för att skriva ut text på skärmen. Resultatet av länkningen läggs i 

exemplet i en fil med namnet HelloWorld.exe som är ett helt vanligt 

Windowsprogram 1 . 

Man kan i alla miljöer göra en kompilering utan att göra en länkning med ett compile 

kommando, hur detta görs varierar från miljö till miljö. Man kan dessutom utföra en 

länkning utan att behöva köra programmet med ett build kommando. Syftet med dessa 

kommandon är vanligtvis att kontrollera eventuella fel. 

2.6.1 Hello World programmet rad för rad 

Ett C++ program läses och körs som regel uppifrån och ned. Datorn tar den första C++ 

satsen den stöter på, tolkar och utvärderar resultatet, och utför därefter nästa sats. Hello 

World programmet har faktiskt bara en enda programsats som datorn ska utföra. Det 

övriga i källkoden är till för att kompilering och länkning ska fungera. 

1 I vissa sammanhang ser man benämningen DOS-program. Den benämningen är i de allra 

flesta fall helt felaktig 

8



Rad 1: #include 

Rad 2: using namespace std; 

Rad 4: int main() 

Rad 5: { 

Dessa två rader hör ihop rad ett säger att vi ska använda oss av en fil döpt "iostream". 

Filen iostream är en s.k. headerfil som innehåller fördefinierade funktioner, exempelvis 

att skriva text till skärmen. Rad två säger att dessa funktioner tillhör C++ standarden. 

Namnet std i using namespace std; är till för att undvika hopblandning med äldre 

varianter av C++, dvs C++ innan standardiseringen. 

Rad 4 anger programstart. Detta är en överenskommelse som finns till länkaren att man 

anger programmets start på detta sätt. Raden är en "definition av en funktion döpt 

main()". En funktion är en samling programsatser som kan utföras som en enhet. Rad 5 

anger att här börjar programsatserna för main funktionen. Varje { tecken i ett C++ 

program har ett motsvarande } tecken. Dessa klamrar grupperas på samma sätt som 

parenteser i räkneuttryck. 

Rad 6: 

cout



3 Datorn som miniräknare 

I detta avsnitt tas upp hur man kan skriva program som utför enkla räkneoperationer 

och skriver resultat på skärmen. Syftet är i huvudsak att se hur flera C++ satser kan 

bygga upp ett C++ program utan att behöva fördjupa oss i djupa teoretiska 

resonemang. 

3.1 Räkneoperationer 

a = 2 + 3 * 4; 

I C++ kan man utföra de vanliga räkneoperationerna som addition, subtraktion, 

multiplikation och division med ungefär samma syntax ( skrivsätt ) som i algebran. 

Exempel: 

3.2 Variabler 

int a; 

Är en giltig C++ sats som ger en variabel döpt a värdet 14. Notera att den måste 

avslutas med ett semikolon. 

Räknereglerna är desamma som i algebran dvs. först utförs operationen 3 * 4 (12) 

därefter utförs operationen 2 + 12. Likhetstecknet skiljer sig en hel del från algebran. I 

C++ kallas likhetstecknet = tilldelningsoperator och innebär att man för över innehållet 

från högersidan (14) till variabeln på vänstersidan. Då satsen är utförd kommer 

variabeln a att innehålla värdet 14. 

I exemplet ovan används namnet a för att ange en variabel, en slags behållare för ett 

värde, snarlik variabler inom algebra. För att kunna använda en variabel i C++ måste 

den deklareras. I deklarationen anger man vilken typ av information som variabeln 

innehåller. För variabeln i exemplet som ska innehålla ett numeriskt värde kan 

deklarationen se ut som 

Denna deklaration säger att a är ett heltal ( int, förkortning för integer, heltal). Man kan 

se det som att en deklaration skapar en variabel med ett visst namn. En deklaration 

måste alltid komma före det att man använder variabeln. Det data som a refererar till 

kallas för en instans av ett heltal ( int ). 

10



#include 


int main() 

{ 

} 

Exempel, enkelt räkneprogram: 

int a; 

int b; 

b = 4; 

a = b * 3 + 2; 

cout



3.2.1 Sammansatta utskriftssatser 

#include 


int main() 

{ 

} 

I programmet ovan kan det bli en smula skrymmande att använda 4 programkodsrader 

för att skriva ut en rad med text. Man kan kombinera utströmsoperatorerna för att 

åstadkomma utskriften på en enda rad. Den satsen skulle då ersätta satserna Rad 9 till 

Rad 12. Programmet skulle då se ut som 

int a; 

int b; 

b = 4; 

a = b * 3 + 2; 

cout



4 Datatyper och Uttryck 

4.1 Datatyper 

I räkneprogrammet tidigare såg vi att C++ kräver deklarationer av alla variabler som 

används. I räkneprogrammet användes bara variabler av heltalstyp, int, men det finns 

naturligtvis andra typer av variabler som kan användas i C++. 

I kompendiet "Datorsystem och programhantering" finns ett kapitel om intern 

datarepresentation som med fördel läses innan detta avsnitt. 

De vanligaste datatyperna är 

int Heltal ( integer ) 

short int Mindre heltal ( short integer ) 

long int Stort heltal ( long integer ) 

float Mindre rella tal ( floating point number ) 

double Rella tal/flyttal ( double precision floating 

point number ) 

char Tecken ( character) 

bool Logiskt värde ( boolean ) 

void 

Tomrum/ingenting 

För variationerna long int och short int kan ordet int utelämnas. För heltalstyperna och 

teckentypen char finns även en icke teckensatt form som anges med unsigned 

unsigned int 

unsigned short int 

unsigned char 

unsigned int a; 

a = -3; 

Dessa datatyper kallas med ett gemensamt namn för enkla datatyper. 

En variabel som deklareras som unsigned kan inte anta negativa värden. Dvs satserna: 

Ger ett oväntat resultat. 

4.2 Deklarationer 

Deklarationer görs alltid på formen 

datatyp variabelnamnslista; 

En variabelnamnslista består av ett eller flera variabelnamn åtskilda av kommatecken. 

En lista är ett återkommande begrepp som omfattar fler saker än just variabelnamn. 

Generellt är en lista noll, ett eller flera element åtskilda av kommatecken. 

13



4.3 Identifierare 

Det finns flera typer av identifierare där variabelnamn är en av dessa typer. De 

variabelnamn vi sett hittills har varit enstaka bokstäver, C++ tillåter emellertid ganska 

utförliga namn på variabler. Ett annat exempel på identifierare är funktionsnamn tex. 

main 

Reglerna för namngivning av identifierare är 

 

 

 

 

Det första tecknet måste vara en bokstav eller tecknet '_' 

(understreck/ underscore). 

Efterföljande tecken kan vara bokstäver eller siffror 

Tecknen å, ä och ö är ej tillåtna 

4.3.1 Godkända identifierare / variabelnamn 

Namnen kan vara i princip hur långa som helst. 4096 tecken är en 

vanlig övre gräns. 

hello 

HeLlO 

_x 

_12 

_hello_dude_2 

number_of_variables_in_my_program 

Observera att man skiljer på versaler och gemener i identifierare. Variabeln a är inte 

samma variabel som variabeln A. 

4.3.2 Icke godkända identifierare 

2dudes 

hello dude 

x-y 

"hel" 

poäng 

man får inte börja med en siffra 

mellanslag är inte tillåtna i variabelnamn 

tecknet – är ej tillåtet 

" är inte tillåtet, anger dessutom texten 

hel 

ä är inte ett tillåtet tecken 

När man skriver ett C++ program är det inte tillåtet att använda åäö i variabelnamn. 

Det kan därför vara en smula bökigt att använda svenska ord som variabelnamn, även 

fast det kan vara enklare att associera svenska ord med olika betydelser i programmet. 

Författaren använder av den anledningen uteslutande engelska identifierare i "skarp" 

programkod. Det är dessutom en betydande del av jordens befolkning som inte förstår 

svenska variabelnamn. I detta kompendium har jag däremot försökt att använda mig av 

identifierare med svenska namn för enkelhetens skull. 

4.3.3 Initieringssatser 

En initiering är att ge en deklarerad variabel ett startvärde. Då en variabel deklareras 

med ex. int i; har variabeln i ett okänt startvärde. För att i ska få ett meningsfullt värde 

måste man göra en tilldelning. En variation på tilldelningar är initieringar, som är en 

kombination av en deklaration och en tilldelning. Syntaxen ser ut som 

14



datatyp variabelnamn = startvärde; 

4.3.4 Exempel på giltiga satser med variabeldeklarationer och intieringar 

int n; 

int i, j; 

double x; 

// i, j är en variabellista med två element 

// x deklareras som ett flyttal 

unsigned long int number_of_paalokas, number_of_cards; 

// två positiva heltalsvariabler deklareras 

bool logic_1, logic2, illogical; 

// tre variabler som kan anta värdet sant och falskt 

char c; 

// variabel som innehåller tecken ex 'A' 

double my_float_number = 2.3203; 

// initierad variabel 

int magic_number = 42; 

// initierad variabel 

Då man väljer variabelnamn för variabler i programmet ska man se till att använda så 

utförliga namn som möjligt. 

4.3.5 Nyckelord 

Det finns i språket en uppsättning fördefinierad ord med speciella betydelser 

som inte får användas som identifierare, dessa kallas nyckelord. 

asm auto bad_cast bad_typeid bool break 

case catch char class const 

const_cast continue default delete do double 

dynamic_cast else enum except explicit 

extern false finally float for friend 

goto if inline int long mutable 

namespace new operator private protected public 

register reinterpret_cast return short signed 

sizeof static static_cast struct switch 

template this throw true try type_info 

typedef typeid typename union unsigned using 

virtual void volatile while 

4.3.6 Datatypernas egenskaper 

Man använder variabler av olika datatyper till olika syften, och man måste välja 

datatyp med omsorg då man deklarerar sina variabler. 

4.3.7 Lagring av enkla datatyper 

I en 32-bitarsmiljö ( vanlig processor ) lagras heltalstyperna enligt 

15



char, unsigned char, signed char 

short, unsigned short 

int, unsigned int 

long , unsigned long 

float 

double 

1 byte 

2 bytes 

4 bytes 

4 bytes 

4 bytes 

8 bytes 

Då en variabel av typen int lagras i datorns minne kommer den således att uppta 4 

bytes minne. 

Man kan enkelt räkna fram vilka talområden detta ger för heltalstyperna om man följer 

metoden i kompendiet "Datorsystem och programhantering", avsnitt intern 

datarepresentation. Samma avsnitt anger dessutom hur talområdet för flyttalen ska 

tolkas. 

char +- 127 

short +- 32 767 

int +- 2 147 483 647 

long +- 2 147 483 647 

float 

E+-37, 6 siffrors 

noggrannhet 

double 

E+-308, 15 siffrors 

noggrannhet 

#include 


Heltalstyperna är de enklaste av datatyperna. Det är ofta tydligt när man ska använda 

sig av heltalstyper. Flyttalstyperna kan vara lite krångligare men med lite vana blir 

även det en ganska smal sak. 

Exempel räkneprogram med olika datatyper 

int main() 

{ 

int antal_bananer, antal_apelsiner; 

double medel_antal; 

antal_bananer = 89; 

antal_apelsiner = 56; 

medel_antal = (antal_bananer + antal_apelsiner) / 2.0; 

} 

cout



Rad 7 skapar ett flyttal, dvs ett tal med decimaldel som ex 3.14159265. Flyttalet 

medel_antal deklareras som double trots att talområdet för float mer än väl räcker till. 

Motivet till att välja float skulle vara att en double ansågs ta upp för mycket minne. 

Floatdeklarationen påverkar emellertid ytterst sällan programmets storlek i någon 

väsentlig grad, därför väljer man alltid double av bekvämlighet. 

Rad 9 och 10 är vanliga tilldelningar. 

Rad 12: medel_antal = (antal_bananer + antal_apelsiner) / 2.0; 

Parenteser används för att additionen ska utföras innan divisionen (annars blir det ju 

inget medelvärde). Därefter sker division med 2.0. Det inskrivna värdet 2.0 ska 

betraktas som att vara av typen float medan ett värde skrivet som 2 ska betraktas som 

att vara av typen int. 

Prova att ändra värdet 2.0 till värdet 2. Blir det någon skillnad vid programkörning? 

Rad 14: cout



Uttryck 2: medel_antal = (antal_bananer + antal_apelsiner) / 2.0; 

och 

Uttryck 3: cout



Aritmetiska operatorer 

+ Addition 

– Subtraktion 

* Multiplikation 

/ Division 

% Modulus 

+= Addition med tilldelning 

–= Subtraktion med tilldelning 

*= Multiplikation med tilldelning 

/= Division med tilldelning 

%= Modulus med tilldelning 

Strömoperatorer 

> Inströmsoperator 

Tilldelningsoperator 

= Tilldelning 

Logiska operatorer 

!= Icke lika med 

< Mindre än 

Större än 

>= Större än lika med 

&& 

Logiskt AND 

|| Logiskt OR 

Bitoperatorer 

^ 

Exklusivt OR 

& 

Bitvis AND 

| Bitvis OR 

^= Exklusivt OR med tilldelning 

&= 

Bitwise AND med tilldelning 

|= Bitvis OR med tilldelning 

De enkla räkneoperatorerna har behandlats tidigare, förutom modulusoperatorn. Varje 

räkneoperator har en tilldelningsvariant, exempelvis har + operatorn en variant +=. 

Denna operator är en ren bekvämlighet. I program stöter man ofta på situationer när en 

variabel ska öka eller minska i värde. Exempelvis 

int i; 

i = 65; 

cout



Rad 4 i exemplet kan man alltså läsa ut som: Tilldela variabeln i det tidigare värdet på i 

plus 8. Mer korrekt ses satsen som att den består utav två operationer, där operation 1 

är i + 8 med resultatet 73 av typen int, operation 2 är i = 73, i tilldelas värdet 73. 

Att öka värdet på en variabel på detta sätt är så vanligt att man har skapat en operator 

som utför denna sammansatta sats i en enda operation +=. Det lösryckta 

programavsnittet ovan omskrivet med += operatorn ser då ut som 

int i; 

i = 65; 

cout



int a; 

a = 8; 

++a; 

// prefix 

cout



Operationen som utförts kan beskrivas som 

(int ) = ( int ) 

Observera att detta inte är programsatser utan bara ett sätt att beskriva uttryck. 

Varje operation ger som resultat ett värde som kallas returvärde, detta värde har en 

datatyp som kallas returtyp eller resultattyp. Man får en exakt beskrivning av 

operationen om man dessutom anger returtypen som för Uttryck 1 är int ( egentligen en 

variant av int som int behandlats än, mer om det senare). Detta kan man skriva som 

(int ) = (int ): int 

Generellt: 

( datatyp operand till vänster ) operator ( datatyp operand till höger ) : returtyp 

Det som står till vänster om kolon kallas för operationens signatur. 

I tilldelningssatsen utnyttjas inte returvärdet. Det gör det däremot i den sammansatta 

satsen i Uttryck 2. 

medel_antal = (antal_bananer + antal_apelsiner) / 2.0; 

Satsen är sammansatt av tre enkla uttryck med var sin operator =, + och / . 

För att exakt hur satsen tolkas delar man upp den i dess enkla uttryck och utvärderar 

dom i tur och ordning. Denna ordning bestäms av operatorprioriteter som är angivna i 

bilaga operatorprioriteter. I korthet kan sägas att de flesta operatorer ska läsas från 

vänster till höger. Tilldelningsoperatorn = är ett tydligt undantag då den läses från 

höger till vänster. Uppenbara undantag finns också i aritmetiska uttryck som 3 + 4 * 5. 

Uttrycket 4*5 beräknas före additionen med 3, detta kommer sig av just 

operatorprioriteten. Utvärderingsordningen för operatorer kan alltid ändra med hjälp av 

parenteser. Jämför: ( 3 + 4 ) * 5 

I tur och ordning utvärderas 

antal_bananer + antal_apelsiner 

denna operation är en addition mellan två heltal, och resultatet är ett heltal alltså 

( int ) + ( int ) : int 

Då operationen är utförd har 89 och 56 adderats och resultatet 145 av typen int 

erhållits. Därefter utvärderas nästa operation, / operationen. 

Den kan man läsa ut som 

eller 

145 / 2.0 

(int ) / ( double ): double 

22



Resultatet av en division med flyttal är ett flyttal. Av denna operation erhålls resultatet 

72.5 av typen double. Därefter utförs operationen = 

eller 

medel_antal = 72.5 

( double )= ( double ) : double 

För räkneoperatorerna gäller allmänt att om någon av operanderna är av flyttalstyp 

kommer resultatet vara av flyttalstyp, och omvänt, om båda operanderna är av 

heltalstyp kommer resultatet att vara av heltalstyp. 

Exempelvis 

( double ) + ( double ) : double 

En addition av två flyttal ger resultat av flyttalstyp 

( double ) - ( int ) : double 

En subtraktion av ett flyttal och ett heltal ger resultat av flyttalstyp. Egentligen 

omvandlas heltalet först till ett flyttal innan subtraktionen. 

Regeln för typer vid räkneoperationer kan ge en del oväntade resultat, i synnerhet vid 

division. Division mellan två heltal ger resultat av typen heltal 

( int ) / ( int ) : int 

Exempelvis ger divisionen 13 / 5 resultatet 2. 

Betrakta: 

#include 


int main() 

{ 

int i, j; 

i = 14; 

j = 19; 

double resultat; 

resultat = j / i; 

cout



Vid programkörning skrivs på skärmen 

19 / 14 = 1 

Press any key to continue 

Detta trots att variabeln resultat deklarerats som double. Eftersom operationen ( int ) / 

(int ) ger resultattyp int kommer variabeln resultat att innehålla värdet 1. Om vi stället 

hade skrivit 

Rad 10: resultat = double( j ) / i; 

Skulle variabeln j omvandlats till flyttal och divisionsoperationen skulle då vara 

( double ) / ( int ) : double 

Och värdet på variabeln resultat skulle då vara 1.35714… 

Uttycket double( j ) är ett exempel på typomvandling. 

24



5 Inmatning och utskrift 

Inmatning från tangentbord och utskrift till skärm sker i C++ med hjälp av strömmar. 

Vi har tidigare sett exempel på utskrift. Vi kommer i det här avsnittet även ta upp 

inmatning från tangentbordet så att vi kan skapa program som kommunicerar med en 

användare istället för att använda värden inskrivna i programkoden. 

5.1 Utskrift till skärm 

För att skriva data till skärmen ( konsolen) används variabeln cout tillsammans med 

strömoperatorn



Med utströmsoperatorn kan man alltså med en enda sats skriva ut så många variabler 

och texter som man vill. Det är ändå oftast en god ide att hålla raderna så pass korta att 

de blir lättlästa. Det brukar som regel innebära maximalt 2 – 3 variabler och en kortare 

text. 

5.1.1 Formatering av utmatning 

#include 


Man vill gärna att den utskrift som programmet gör på skärmen ska vara snygg och 

lättläst. Tyvärr blir det inte alltid som man tänkt sig, i synnerhet då värden på 

flyttalsvariabler ska skrivas ut på skärmen. 

Exempel, valutaomvandling 

int main() 

{ 

double kron_dollar_kurs = 10.43; 

double kronor = 345.50; 

double dollars; 

dollars = kronor / kron_dollar_kurs; 

} 

cout



cout.setf(ios::fixed ); 

setf och precision är funktioner( eller metoder ) kopplade till utströmmen cout. Det 

som ges innanför parenteserna ( ios::fixed och heltalet 2 )kallas funktionsargument. 

Ett annat sätt att formatera utskriften är att ange hur många positioner ett uttryck ska 

uppta. 

Comment [KP1]: Borde vara 

en utskrift, eller 

cout.width( 20 ); 

#include 


Ger att nästföljande utströmsoperation kommer att ta minst 20 teckenpositioner till sitt 

förfogande. Om talet eller texten är kortare fogas tillräckligt antal blanksteg in. 

Observera att den angivna bredden bara gäller för den utströmsoperation till cout som 

kommer direkt efter cout.width( … ) 

Sammantaget kan då programmet se ut som: 

int main() 

{ 

double kron_dollar_kurs = 10.43; 

double kronor = 345.50; 

double dollars; 

dollars = kronor / kron_dollar_kurs; 

cout.setf(ios::showpoint); 

cout.precision( 2 ); 

cout.setf(ios::fixed ); 

} 

cout



int i; 

cin >> i; 

Inströmsoperationen liknar till viss del en tilldelningsoperation, men med den stora 

skillnaden att värdet som variabeln i får bestäms av användaren som kör programmet. 

Programmet väntar i inströmsoperationen tills det att användaren faktiskt matat in ett 

värde. Denna egenhet gör att man för varje inmatningssats ( inströmsoperation från cin 

) måste se till att användaren blir varskodd att programmet väntar på inmatning. Det 

görs ganska enkelt genom att skriva ut lite ledtext på skärmen. 

int i; 

cout



Ange hur mÕnga kronor du har: 

6500 

Dina 6500.00 svenska kronor blir 623.20 amerikanska dollar 


Programmet skriver först ut ledtexten, väntar på inmatningen, 6500[Enter]. [Enter] 

anger att tangenten Enter/Return/Vagnretur skall tryckas. Sedan skrivs resultatet av 

beräkningen ut. 

Inströmsoperationen kan i likhet med utströmsoperationen ta emot flera inmatningar i 

en sats. 

double variabel1, variabel2; 

cout variabel1 >> variabel2; 

Inmatningen till denna sats kan antingen göras genom att man skriver två tal och 

trycker return mellan varje tal, eller kan man separera talen med blanksteg eller tab och 

avsluta inmatningen med return. Se även om vittecken i avsnittet Texthantering, in och 

utmatning. 

Problemet med denna typ av inmatning är att man inte kan skriva ut någon ledtext 

mellan varje inmatning. Utan man kan bara ge ledtexter typ "Ange 4 tal". Det kan 

därför vara ett bättre alternativ att dela upp det så att man bara har en inmatning per 

sats, och ledtext till varje inmatning. 

5.2.1 Exempelprogram 

Beräkna area och omkrets hos en rektangel. 

29



#include 


int main() 

{ 

double sida; 

double bredd; 

double omkrets; 

// ange ledtexten 

cout



6 Villkor och styrsatser 

I de program vi sett tidigare har programkörning inneburit att sats efter sats utförts i 

den ordning de skrivits i källkoden. Vi har inte kunna ändra programmets uppförande 

beroende på inmatningar eller beräkningsresultat. Vi kallar en sådan samling satser för 

en sekvens, eftersom de utförs en efter en. 

Sekvens: 

Start: Sats1 -> sats 2 -> sats 3 -> sats 4… Slut. 

Vi ska nu titta på en ny struktur som kallas för selektion. Selektion innebär att 

programmet kan under programkörning fatta beslut om vilken av en, två eller flera 

alternativa sekvenser som ska utföras. 

6.1 Villkorssatsen if 

En villkorssats är den konstruktion som finns i C++ för att göra en selektion av två 

alternativa sekvenser. 

Formen för if- satsen är 

alternativt 

if ( logiskt_uttryck ) 

sats / satsblock 

else 


if ( logiskt_uttryck ) 


Det logiska uttrycket anger ett villkor som är antingen sant eller falskt. Den första 

sats/satsblocksdelen är det programavsnitt som ska utföras om villkoret är sant. Den 

andra sats/satsblocksdelen är det som ska utföras om villkoret är falskt. else och det 

efterföljande sats/satsblock är valfritt. 

Några enkla exempel: 

int antal_husdjur; 

cout



1. Villkoret är sant. Användaren har matat in en siffra större än 5. 

Ange hur många husdjur du har hemma 

12 

Jaså du har 12 husdjur 

Oj det var många 

slut 

2. Villkoret är falskt. Användaren har matat in en siffra som är 5 eller lägre. 

Ange hur många husdjur du har hemma 

2 

Jaså du har 2 husdjur 

slut 

6.1.1 Satsblock 

Villkorssatsen i exemplet utnyttjar att else delen av if satsen är valfri. Dessutom läggs 

det en sats och inte ett satsblock efter if satsen. if satsen väljer bara den sats som ligger 

direkt efter villkoret. Notera indragningen av satsen cout



6.1.2 Övning: 

Sätt in ovanstående exempel i ett komplett program och provkör. Blev resultatet 

det du förväntade dig? 

Rätta till indenteringen i föregående program. 

Ett vanligt fel är att man råkar lägga en ensam sats mellan if satsen och satsblocket. 

Kompilatorn har svårt att ge en rimlig felbeskrivning för detta fel. Ett annat vanligt fel 

är att man påbörjar satsblocket innan villkorssatsen eller else. Satsblocket blir då som 

regel betydelselöst. 

{ if ( antal_husdjur > 5 ) 

// FEL! Satsblocket börjar inte direkt efter villkoret 

cout



Logiska binära operatorer 

== Lika med 

!= Icke lika med 

< Mindre än 

Större än 

>= Större än lika med 

&& 

Logiskt AND 

|| Logiskt OR 

and Borttaget ur C++: Logiskt AND synonymt med && 

or Borttaget ur C++: Logiskt OR synonymt med || 

I villkoret i exemplet ovan användes den logiska operatorn > på formen 

( int ) > ( int ) : bool 

Varje logisk operation ger ett resultat av typen bool. Man kan använda sig av variabler 

deklarerade med typen bool för att lagra logiska värden. 

Villkoret i exemplet ovan hade kunnat skrivas utförligare som: 

bool manga_husdjur; 

manga_husdjur = antal_husdjur > 5; 

if ( manga_husdjur ) 

// satsblocken som tidigare 

med samma betydelse. Variabeln manga_husdjur kan alltså anta värdena true eller 

false. Om ett logiskt värde av typen bool i något uttryck kan betraktas som ett heltal 

kommer värdet true att vara värdet 1, och false kommer att vara värdet 0. 

De flesta logiska operationer är tämligen rättframma. Här följer några exempel på hur 

uttrycken kan se ut: 

Antag att förekommande variabler är deklarerade med en rimlig datatyp 

( vikt < 60.0 ) 

( antal_hundar== 2 ) 

( antal_valar != 2 ) // motsatsen till ovan 

( antal*2 >= 52 ) // räkneoperationen utvärderas först 

Man kan dessutom kombinera uttryck med de logiska operatorerna && ( OCH ) och || 

(ELLER). Dessa operatorer har formen 

( bool ) && ( bool ): bool 

( bool ) || ( bool ): bool 

Man använder alltså dessa operatorer på logiska värden eller uttryck 

34



( antal == 2 && vikt < 20.0 ) // Jämförelserna utvärderas först och 

// därefter utvärderas && 

// båda jämförelserna måste vara sanna för 

// att hela uttrycket ska vara sant 

( antal == 2 || vikt < 20.0 ) // om någon av jämförelserna är sanna 

// är uttrycket sant 

Det finns även en unär logisk operator ! eller not. Operatorn fungerar så att den vänder 

ett sant värde falskt, och tvärtom. Exempel 

( !( 3 > 4 ) ) // är sant 

( not( 7 == 12 ) ) // är sant 

( ! (4==4) ) // är falskt 

Det bör sägas ett varningens ord om likhetsjämförelser av flyttal. Om man har två 

flyttal är det ofta svårt att kontrollera om de är lika, eftersom jämförelsen kräver att de 

är exakt lika i varje bit. 

Då varningar utfärdas får man inte glömma bort att varna för en viss typ av 

sammansatta jämförelser. Betrakta följande programavsnitt 

int hur_gammal; 

cout



// kolla om tonåring, äldre än 12 och yngre än 20 år 

if ( 12 < hur_gammal && hur_gammal < 20 ) // RÄTT ! 

{ 

cout



Exempel, enkel sortering av två tal 

#include 


int main() 

{ 

double tal1, tal2; 

// ledtext 

cout



6.3.1 for-satsen 

2. Sats som påverkar iterationsvillkoret, tar iterationen närmare 

slutförandet. ( 2.2: Bläddra till nästa sida ) 

3. Den sats som ska itereras. ( 2.1: Läs en sida ) 

Man skulle även kunna ta med den första satsen 1: Öppna boken, som möjliggör 

iterationen. Denna typ av sats som förbereder iterationen kallas för initieringssats. 

När man diskuterar iterationssatser i programkod kallar man dom ofta för "loopar". De 

iterationssatser som finns i kan delas in i två kategorier, nämligen 

 

 

Räknande loopar 

Villkorsloopar 

Exemplet ovan är ett typiskt exempel på en stegande loop. Man kan betrakta det som 

att man tar steg från sidan 1 till sidan 2 till sidan 3 osv. till den sista sidan i boken. 

Skillnaden mellan dessa två typer av loopar är i huvudsak satsen som påverkar 

iterationsvillkoret. I exemplet är det satsen att bläddra till nästa sida, dvs. ta ytterligare 

ett steg i boken, som påverkar iterationsvillkoret. 

En for-sats är en av de vanligaste satserna i programkod och är mycket viktigt att 

behärska. Syftet med for-satsen är att skapa räknande loopar. Formen för en for-sats är 

for ( initieringslista; iterationsvillkor; 

inkrementsatslista ) 


Man kan i formen skönja flera likheter med if satsen. Den stora skillnaden ligger i 

initieringslistan och inkrementlistan, och naturligtvis det faktum att for-satsen är 

iterativ. Kom ihåg att en lista är noll, ett eller flera element separerade med 

kommatecken. 

Vi kan nu visa på bokexemplet först schematiskt med en forsats: 

for(öppna bok; om det finns sidor kvar att läsa; bläddra till nästa sida ) 

Läs en sida; 

Stäng bok; 

Lämna tillbaka boken till biblioteket; 

Detta är principen bakom varje forsats. Denna typ av kod kallas för pseudokod och 

används med fördel om man vill diskutera programkodslösningar. En C++ kompilator 

förstår naturligtvis inte pseudokod, använd penna och papper istället. 

Bokexemplet som ett komplett program 

Det går att skapa ett enkelt komplett program av bokexemplet, om man på förhand 

bestämmer antalet sidor i boken. Vi fastställer härmed att antalet sidor är 12. 

38



#include 


int main() 

{ 

int antal_sidor = 12; 

cout



Satserna i programmet utförs i exakt samma ordning som i det första schematiska 

bokexemplet utan for-sats. 

Övning: Övertyga dig själv om att det första schematiska exemplet fungerar på samma 

sätt som for-satsen i exemplet ovan 

Iterationsvariabeln 

Betrakta programavsnittet 

for( int i=0; i< 10;i++) 

{ 

cout



Rad 2: Initieringssatsen låter värdet på i börja med 1 eftersom summeringen skulle 

börja med termen 1. 

Rad 2: Iterationsvillkoret ska medge att satsblocket utförs för värdet i = 100 men inte i 

= 101, villkoret avbryter nu vid jämförelsen 101 < 101. 

Rad 4: Operatorn += används för att öka på värdet på variabeln total_summa med 

värdet av i. 

Kom ihåg utvärderingsordningen: initiering, villkor, satsblock, inkrement, villkor, 

satsblock, inkrement, villkor, satsblock, inkrement, villkor … 

Resultatet blir: 

summan är:5050 

Man kan även skriva for-satsen med båda variabeldeklarationerna i initieringslistan 

for ( int total_summa = 0, int i = 0; i < 101; i++)... 

6.3.2 Övning 

med samma resultat. Man bör undvika att lägga onödiga deklarationer i initeringslistan 

till for-satsen eftersom det kan försämra läsbarheten hos programmet. 

Skriv ett program som skriver ut treans multiplikationstabell upp till 10. 

Programutskrift 

1*3 3 

2*3 6 

3*3 9 

… 

Tips: Skriv ut varje värde som en utmatning i en for-sats, låt iterationsvariabeln stega 

från 1 till 10. Tecknen "*3 " på varje rad kan skrivas ut som vanlig text. Formatera 

utskriften med cout.width( … ). 

6.3.3 while och do while- satserna 

Den andra typen av iterationssatser är villkorsloopar. Skillnaden mellan dessa satser 

och for- satsen är att de används när man inte utför en räknande iteration, i synnerhet 

då man på förhand inte känner till hur många iterationer som ska utföras. Ett vanligt 

förekommande sammanhang för dessa iterationer är för felkontroll av inmatningar från 

användaren. 

Villkorslooparna kommer två olika varianter, en med preevaluering , while, och en 

med postevaluering, do while. Preevaluering innebär att ett villkor utvärderas innan ett 

satsblock utförs medan postevaluering innebär att ett villkor utvärderas efter ett 

satsblock utförs. 

41



While-satsen 

While-satsen använder preevaluering dvs. först utvärdera villkor därefter utförs 

tillhörande satsblock. Formen på en while-sats är följande 

while ( iterationsvillkor ) 


Funktionen hos satsen är densamma som hos for-satsen, men den saknar både 

initieringslista och inkrementsatslista. 

Exempel, inmatning av en födelsemånad. 

Programmet ska ta emot en inmatning om vilken månad som användaren är född i och 

därefter konstatera om användaren föddes tidigt på året eller sent på året. Programmet 

innehåller en felkontroll av inmatad månad. En programkörning kan se ut som 

Vilken månad är du född? Ange ett tal mellan 1 och 12. 

19 

Du har angett ett felaktigt tal, försök igen! 

-4 

Du har angett ett felaktigt tal, försök igen! 

2 

Du är född tidigt på året. 

Programlösning 

#include 


int main() 

{ 

int fodelse_manad; 

cout



For-satsen som while-sats 

For-satsen och while-satsen skiljer sig bara på for-satsens initieringslista och dess 

inkrementlista. Eftersom en lista kan bestå av inget element är det syntaktiskt korrekt 

att helt utelämna dessa satser. Gör man det får man exakt samma funktion som hos 

while-satsen. Exemplet ovan hade även kunnat skrivas med for-sats genom att byta ut 

while-satsen mot 

for ( ; fodelse_manad < 1 || fodelse_manad > 12 ; ) 

{ ... som tidigare 

Observera att for-satsens semikolon inte får utelämnas. 

Do while-satsen 

#include 


Do while-satsen har ett samma funktion som while-satsen med den skillnaden att den 

använder sig av postevaluering, villkoret om att fortsätta iterationen utförs efter det 

tillhörande satsblocket. Det får till följd att satsblocket till en do while-sats alltid 

kommer att utföras minst en gång. Formen på en do while-sats är 

int main() 

{ 

int fodelse_manad; 

do 


while ( iterationsvillkor ); 

Exemplet ovan skrivet med en do while-sats kan bli 

do { 

cout



#include 


Exempel, nästlade loopar, multiplikationstabellen 

På samma sätt som en villkorssats kan innehålla vilken annan sats som helst kan 

iterationssatser även innehålla iterationssatser. Det blir då en sk. nästlad iteration. Ett 

tydligt exempel på hur det kan fungera är multiplikationstabellen 

int main() 

{ 

for( int i = 1; i



7 Texthantering 

I detta avsnitt tas det upp två sätt att arbeta med text i C++ program. Det första sättet 

som behandlas är hanteringen av textfält. Texter i C++ består utav en serie med enstaka 

tecken av typen char. Dessa serier med tecken kallas fält eller arrayer. 

7.1 Typen char 

#include 


Variabler av datatypen char representerar ett tecken som exempelvis bokstaven 'A'. 

Datatypen char är i grund och botten ett heltal bestående av en enda byte, alltså med ett 

väldigt litet talområde. Skillnaden mellan variabler av chartyp och heltalsvariabler 

visar sig när man skriver ut dem till skärmen. När en char-variabel skrivs ut till 

skärmen visas ett tecken exempelvis 'A', när en heltalsvariabel skrivs till skärmen visas 

ett tal. 

Programexempel med char-variabler. 

int main() 

{ 

char tecken_1, tecken_2, tecken_3; 

tecken_1 = 'H'; 

tecken_2 = 'e'; 

tecken_3 = 'j'; 

cout



#include 


int main() 

{ 

for (char c='A'; c



char min_text[] = "Hello World"; 

här skapas ett fält bestående av 12 tecken, och variabeln min_text kallas för en 

fältvariabel. 

Operatorn [], kallad indexeringsoperator, anger att det är frågan om ett fält. 

Vid deklarationer används indexeringsoperatorn för att ange en storlek på fältet. I 1 

ovan behövs inte det eftersom storleken är antydd av texten "Hello World" = 11 tecken 

+ nolltecknet = 12 tecken. Fältet min_text är således 12 tecken(bytes) stort. 

2: 

char tom_text[12]; 

här skapas ett fält bestående av 12 ej initierade char instanser. Det faktum att de ej är 

initierade som i 1, gör att innehållet inte är definierat eller, om man så vill, innehåller 

skräp. Denna typ av deklaration har ett liknande syfte som en vanlig 

variabeldeklaration typ int i; dvs. att fungera som en behållare för texter. 

7.2 Fältvariabler 

En fältvariabel fungerar inte riktigt på samma sätt som en vanlig variabel. Man ska 

betrakta en fältvariabel som att den anger var fältet börjar. En fältvariabel pekar ut 

det första tecknet i fältet, eller mer korrekt, den första char instansen. Den anger vilken 

minnescell, adress, som den första instansen befinner sig i. Man kan i ett schematiskt 

diagram åskådliggöra deklarationen char min_text[]="Hello World"; som 

Variabel: min_text 

Adress: 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 

Innehåll: 206 H e l l o W o r l d \0 

Numreringen av cellerna är påhittad och är olika från programkörning till 

programkörning. 

Ett enklare men lika användbart diagram ser ut som 

min_text 

H e l l o W o r l d \0 

En egenskap hos fältvariabler är att de refererar alltid till samma fält. Detta innebär att 

47



char min_text[]="Hello World"; 

char tom_text[12]; 

// tilldelning? 

tom_text = min_text; // otillåtet, kan inte referera till nytt fält 

tom_text = "Hello World"; // otillåtet, samma operation som ovan 

inte fungerar. Man ska betrakta denna tilldelning som att man försökt låta pilen för 

tom_text peka på min_text fältet. 

min_text 

H e l l o W o r l d \0 

tom_text 

Detta är alltså ej tillåtet eftersom man "slarvar bort" det ursprungliga tomma 

fältet. 

7.2.1 Hantering av enstaka fältelement 

En fältvariabel tillåter genom indexeringsoperatorn att man manipulerar enstaka 

element. 

char hej_text[4]; // tomt 

hej_text[0] = 'H'; // obs första elementet är element 0 

hej_text[1] = 'e'; 

hej_text[2] = 'j'; 

hej_text[3] = 0; // alternativt skrivsätt = '\0' 

Programraderna resulterar i att det fält som deklarerats att innehålla 4 char element 

tilldelas tecken för tecken innehållet. Obs, tecknet H är element nummer 0. 

min_text 

H e j \0 

7.3 In och utmatning 

Man kan använda de vanliga in och utströmsoperatorerna på samma sätt som man gör 

för enkla variabler ex 

char in_text[256]; 

cout



Hej vad heter du? 

Gunvald 

Hejsan Gunvald! 

Inmatningen fyller då de 8 första elementen i fältet in_text med texten "Gunvald" + 

nolltecken. 

Ett problem med denna typ av inmatning dyker upp om användaren skriver fler än ett 

ord per inmatning, exempelvis om programkörningen sett ut som 

Hej vad heter du? 

Gunvald Larsson 

Hejsan Gunvald! 

Det är inte utströmsoperatorn som felar utan det är sättet som inströmsoperatorn 

fungerar på som är otillräckligt. Det som händer är samma sak som tidigare att in_text 

fylls med texten "Gunvald" + nolltecken och texten Larsson lämnas kvar i 

inmatningsbufferten för senare inläsning. 

Inströmsoperatorn ser alltså "Gunvald Larsson" som två texter eftersom de är åtskilda 

med ett så kallat vittecken (eng. whitespace). All inmatning med >> operatorn, sk. 

formaterad inmatning, skiljer element med vittecken. Vittecken är blankstegstecken, 

tab tecken, nyrad tecken och vagnreturtecken. Jämför sidan 51, inmatning av två 

flyttal. 

Det finns två sätt att komma runt denna egenskap hos inströmsoperatorn 

1. Gör två inmatningar 

2. Använd medlemsfunktionen getline 

Exempel getline 


cout



Exempel, in och utmatning med teckenfält 

#include 


int main() 

{ 

char hej[]="Välkommen till 10000 kronorsfrågan"; 

char fraga[]="Ange ditt för och efternamn"; 

char fornamn[80], efternamn[80]; 

cout



 

 

 

 

 

Rad 10: Variabeln idx (index) initieras till noll, vilket kan ses som att iterationen 

börjar på fältets första element. Jämför avsnitt Hantering av enstaka fältelement 

ovan. 

Rad 10: source[idx]!=0, iterationsvillkoret anger att repetionen skall fortgå tills 

nolltecknet (textslut) påträffas. Detta är en väldigt viktig egenskap att komma ihåg 

för alla textfält. Eftersom ett fält inte innehåller någon information om storleken på 

fältet har man alltid ett nolltecken som avslutar varje textfält. 

Rad 10: idx++ nästa tecken i fälten 

Rad 11: för över det tecken som finns på position idx i source fältet till samma 

position i target fältet. 

Rad 12: Iterationen slutar innan nolltecknet förs över. Satsen garanterar att även 

target avslutas med ett nolltecken. 


Tänk igenom programexekvering rad för rad, sats för sats, och se till att du förstår 

meningen hos varje programrad. Detta är en standardkonstruktion av en for-sats för fält 

som du måste behärska. 

Exempel, att räkna längden på en text. 

#include 


int main() 

{ 


// 

cout



7.4 Texthanteringsfunktioner 

I det tidigare avsnittet visades hur for-satser var nödvändiga för att göra vanliga 

textoperationer. Naturligtvis har man sett ett behov av att göra detta på en enklare sätt. 

Det finns ett bibliotek eller headerfil som heter cstring (string.h på äldre kompilatorer) 

där många texthanteringsfunktioner finns för att göra de vanligaste funktionerna. 

Funktioner i cstring (urval) 

strcpy string copy tilldelning 

strcat string concatenate konkatenering 

(ihopslagning) 

strcmp string compare alfabetisk 

jämförelse 

strlen string length textlängd 

Syntax funktioner i cstring 

strcpy(char * target, const char * source):char * den kopierade 

texten 

strcat(char * target, const char * source):char * den 

konkatenerade texten 

strcmp(const char * txt1, const char * txt2):int se nedan 

strlen(const char * ):int 

längden, 

antal tecken 

Typen char * i tabellen ovan är en variant av char-fält som vi kan betrakta som 

likvärdiga variabler som deklarerats som 

char text[80]; 

dvs ett vanligt textfält. (Typen char * är en pekartyp, en pekare är en variabel som 

pekar ut olika positioner i minnet, som här; början på texten/första tecknet i texten). 

Typen const char innebär en garanti att inget tecken i texten kommer att ändras. 

strcat: Att konkatenera texterna "Hello " och "World" ger resultatet "Hello World". 

strcmp: Det heltal som anges som returvärde kan anta tre olika slags värden 

 

 

 

0: txt2 kommer före txt1. 

52



Syntaxtabellen ska tolkas som ex Funktionen strcmp tar 2 argument av textfältstyp, 

returvärdet är ett heltal. Ett lösryckt avsnitt kan då se ut som: 

char passwd[80]; 

cin>>passwd; 

if( strcmp(passwd, "hemligt") == 0) 

{ cout



Exempel, användning av texthanteringsfunktioner. 

#include 

#include // för texthanteringsfunktioner 


int main() 

{ 

char namn1[255]; 

char namn2[255]; 

// 

cout



for-satsen i exemplet, att räkna längden på en text, är förbluffande lik det 

underprogram som utförs då funktionen strlen anropas. 

Teknisk not: 

Jämför gärna funktioner och operatorer. Ex 

och 

strcat( txt1, txt2 ): resultat 

tal1 + tal 2: resultat 

en giltig omskrivning av tal1 + tal 2 skulle vara 

operator+ (tal1, tal2 ): resultat 

Där enda skillnaden är funktionsnamnet strcat respektive operator+ och dess 

datatyper. 

Skillnaden mellan funktioner och operatorer är språkmässigt mest syntaktisk. Det finns 

en viss fast uppsättning operatorer +,-, * osv. medan funktionsnamn och funktioner kan 

skapas helt efter behov. Annars är den bakomliggande principen densamma. Det finns 

en operator ( ) funktionsoperatorn (se operatortabell i bilaga) som utvärderas på samma 

sätt som övriga operatorer, sånär som på det syntaktiska. 

7.5 Datatypen string 

Det finns i moderna C++ miljöer en datatyp speciellt utvecklad för att handskas med 

text som en enkel datatyp. För denna datatyp fungerar de enkla operatorerna på ett 

naturligt och enkelt sätt. Datatypen heter string och är en sk. klasstyp. Det innebär att 

typen är skapad med de enkla datatyperna som bas men med funktioner och operatorer 

omskrivna så att de kan användas på ett naturligt sätt. Typen är definierad i en header 

string. Headern cstring behövs inte om man använder typen string. 

55



Exempel, operationer för text av typen string 

#include 

#include 


int main() 

{ 

string text1 ="Hello World"; // deklaration + initiering 

string text2; // deklaration 

text2 = text1; // enkel tilldelning, ingen strcpy 

if ( text2== text1) // sant, jämför textinnehållet 

cout



8 Funktioner och procedurell abstraktion 

Det som gör programkonstruktion hanterlig och övergripbar och överhuvudtaget 

genomförbar är möjligheten att dela upp program i olika avsnitt, i underprogram. Vår 

förmåga att hantera ett stort komplext problem bygger till stor del på vår förmåga att 

dela upp problemet i mindre delar och därefter lösa var del för sig. Detta är kärnan i 

procedurell abstraktion. 

Procedurell abstraktion – förenkling genom uppdelning 

Man kan enkelt ge exempel på procedurell abstraktion i vardagslivet 

Exempel, frukosttillagning medelst procedurell abstraktion 

1 Koka kaffe 

2 Stek två ägg 

3 Gör en skinkmacka 

Detta är en anständig beskrivning av tillagningen av en frukost. Beskrivningen består 

av tre olika procedurer. Beskrivningen är abstrakt, det vill säga förenklad. 

Förenklingen/abstraktionen består i att man inte beskriver varje enskild detalj i 

exempelvis proceduren Koka kaffe. Denna förenkling kan ske på flera olika nivåer. 

Den enklaste kan vara att helt enkelt ange Laga frukost. En mindre abstrakt variant är 

de tre stegen som är beskrivna ovan. En ännu mindre abstrakt variant vore om man 

ytterligare beskrev de olika stegen, ex 

1. Koka kaffe: Ta fram kaffepulver, häll 5 dl vatten i bryggaren, mät 

upp 7 mått kaffepulver i filtret, slå på bryggaren, vänta 2 minuter. 

Denna förfining kan dras in absurdum såsom exempelvis att ange exakt vila 

armrörelser och benrörelser man ska utföra föra att hälla 5 dl vatten i någon speciell 

kaffebryggare. Om man utformar dessa procedurer mer och mer exakt kommer 

samtidigt beskrivningen att bli mer och mer specialiserad. En angivelse av benrörelser 

fungerar troligtvis bara för ett speciellt kök, med speciellt placerade köksverktyg, 

medan den första beskrivningen fungerar i de flesta kök. 

Vid programmering kommer man aldrig att behöva förfina mer än att det direkt går att 

översätta till programsatser, eller till välkända lösningar på standardproblem. 

För att åstadkomma denna uppdelning i procedurer eller underprogram skriver man 

funktioner. 

8.1 Funktioner 

Av de funktioner vi redan stött på kan vi utläsa på vilket sätt funktioner kommer att 

anropas. En funktion/ett funktionsanrop representerar ett återanvändbart 

programavsnitt som utförs då programmet stöter på ett anrop. 

57



Utdrag ur Exempel för användning av texthanteringsfunktioner 

// tilldelning namn1 -> namn1och2 

strcpy( namn1och2, namn1 ); 

// lägg till texten ", " 

strcat(namn1och2, ", "); 

// lägg till namn2 

strcat(namn1och2, namn2); 

strcpy( namn1och2, namn1 ); är ett funktionsanrop till en redan skriven funktion som 

utför det arbete som funktionen strcpy antyder, att genom en iteration kopiera över alla 

tecken i texten namn1 till textfältet namn1och2. Det är en liknande iteration som vi såg 

göras av en for-sats vid tilldelningsoperationen för ett textfält på sidan 51. 

8.1.1 Funktionsdeklaration och funktionsdefintion 

En funktion består huvudsakligen av två delar 

1. en deklaration som berättar hur funktionen ska användas i ett program 

2. en definition som beskriver vilken programkod som ska utföras vid 

anropet. 

En deklaration har följande form 

returtyp funktionsnamn(argumenttypslista ); 

I vårt tidigare skrivsätt för operationer skulle detta se ut som 

funktionsnamn( argumentlista): returtyp 

En definition har följande form 

returtyp funktionsnamn(argumentdeklarationslista) 

sats/satsblock; 

Returtyperna och argumentlistorna måste stämma överens exakt med avseende på 

datatyperna. 

Den enklaste datatypen är void (ingenting) den använder man om man inte vill ge 

något värde till eller från funktionen. De funktioner som har returtyp void ger alltså 

inget returvärde. Dessa funktioner är av en speciell kategori funktioner kallade 

procedurer. Författaren anser att distinktionen mellan sk. void-funktioner(procedurer) 

och icke void-funktioner (funktioner) är onödig, men eftersom många andra gör denna 

distinktion vill jag påpeka att den förekommer. Det finns däremot anledning att först i 

en text behandla void-funktioner eftersom de är den syntaktiskt enklaste typen. 

Den enklast möjliga funktionsdeklarationen ser ut som 

58



// dra_linje ritar ett streck med - tecken 

void dra_linje(); 

Kommentaren krävs förstås inte av kompilatorn men det är en god vana att 

kommentera varje funktionsdeklaration, så att man enkelt kan läsa ut syftet med 

funktionen. 

En enkel definition för deklarationen kan se ut som 

void dra_linje() 

{ 

cout



Resultatet blir: 

---------------------------------------------- 

Hello World 

---------------------------------------------- 



int dra_linje() 

Prova att i din utvecklingsmiljö ändra definitionens första rad till 

int dra_linje(); 

Observera vilka fel som rapporteras vid kompilering / länkning 

Ändra tillbaka definitionen till det ursprungliga och ändra istället deklarationen till 

Observera vilka fel som rapporteras vid kompilering / länkning 

Funktionsnamn är om möjligt ännu viktigare än variabelnamn. Använd utförliga och 

tydliga funktionsnamn som beskriver dess syften väl. 

En funktion som aldrig anropas körs aldrig. Det kan mycket väl tänkas att du skrivit 

dina funktion korrekt i ditt program, men programmet gör ändå inte som du vill. Ibland 

beror det på att du glömt anropet av funktionen. Detta är ett fel som kompilatorn inte 

kan upptäcka. 

8.2 Funktioner som behöver indata 

Vi har sett tidigare i samband med texthanteringen hur vi kunde berätta för funktionen 

att den skulle göra beräkningar på någon viss variabel, exempelvis den tidigare satsen 

int len = strlen( namn_1 ); 

utför en beräkning på variabeln namn_1 för att kontrollera hur många tecken som 

texten innehåller. Denna data meddelas genom argumenttyper och argumentnamn 

Den tidigare funktionen dra_linje() som drar ett streck av minustecken är inte vidare 

flexibel. Man kan till exempel inte ange hur långt strecket ska vara. Det kan man enkelt 

åstadkomma med funktionsargument. 

Detta skulle i huvudprogrammet kunna se ut som: 

60



int main() 

{ 

dra_linje( 12 ); // skriv tolv minustecken 

cout



#include 


I ett komplett program kan de båda funktionerna skrivas och användas som 

// dra_linje ritar ett streck med - tecken 

void dra_linje(); 

// dra_linje(int ) ritar ett streck med ett visst antal – tecken 

void dra_linje(int ); 

int main() 

{ 

dra_linje(); // anropa funktion 

cout



När funktionens satsblock tar slut upphör variablerna antal_minus och index att vara 

meningsfulla, och de förstörs därför. Man säger att de har sin räckvidd (eng. scope) 

inom funktionen. Funktionen styr programflödet tillbaka till 

 

 

cout



double bredd, hojd, yta; 

bredd= 5.0; 

hojd= 2.5; 

yta= area( bredd, hojd ); 

Funktionen utvärderas som ett flyttal och tar två flyttal som argument. Deklarationen 

blir då 

double area( double, double); 

Funktionsdefinitionen innehåller en enkel multiplikation. 

double area( double b, double h) 

{ 

double a = b * h; 

return a; 

} 

Alternativt kan man skriva funktionen på ett enklare (men mindre tydligt) sätt som 

double area( double b, double h) 

{ 

return b*h; 

} 

return satsen anger alltså vilket värde som funktionen ska utvärderas till. Datatypen för 

uttrycket i return satsen måsta vara av samma datatyp som, eller kunna omvandlas till, 

returtypen angiven i deklaration och definition. Satsblocket som hör till en funktion 

kallas ofta funktionens implementation. Då man talar om implementering eller 

implementation avser man programkoden eller skrivandet av programkoden. 

Funktioner ska skrivas med målet att de ska fungera i så många situationer som 

möjligt. Man talar om generella funktioner. Det leder oss direkt in på ett mycket 

vanligt nybörjarmisstag vid implementation av funktioner. 

En funktion ska aldrig innehålla in eller utmatningssatser om det inte 

uttryckligen är funktionens syfte. 

Area funktionen i tidigare exempel fungerar bra för att visa på nackdelarna med detta. 

Antag att man skrivit funktionen som 

64



//Deklaration 

double area(); 

//Definition 

double area() 

{ 

double b,h; 

coutb; 

couth; 

return b*h; 

} 

Funktionen kan mycket väl vara lämpad för uppgiften i ett speciellt fall, men den är 

långt ifrån så generell som den tidigare area beräkningen. Antag att programmet redan 

kände till värden för bredd och höjd. Då skulle inmatningssatserna förmodligen göra 

programmet väldigt förvirrande för användaren, om inte rent obrukbart. Undantaget är 

alltså funktioner som uttryckligen är till för in och utmatning. Typexempel är 

funktioner typ dra_linje ovan. Funktioner för utmatning är väldigt ofta void-funktioner 

(procedurer). 

8.4 Speciella datatyper för funktionsargument 

8.4.1 Fälttyper 

#include 


Man kan ge textfält som argument till funktioner på samma sätt som man ger vanliga 

variabler som argument. Det man måste hålla i minnet är att fältvariabeln inte 

representerar själva texten utan bara vart texten börjar. Detta får vissa konsekvenser för 

texter i funktioner. Betrakta programmet 

void skriv_10_ggr(char []); 

int main() 

{ 

char text1[]="Ett"; 

char text2[]="Två"; 

skriv_10_ggr( text1 ); 

skriv_10_ggr( text2 ); 

return 0; 

} 

void skriv_10_ggr( char txt[]) 

{ 

for(int i = 0;i



EttEttEttEttEttEttEttEttEttEttTvåTvåTvåTvåTvåTvåTvåTvåTvåTvåPres 

s 

any key to continue 

Det aktuella argumentet i första funktionsanropet är alltså adressen till den minnescell 

som innehåller tecknet 'E' i texten Ett. Argumentet är alltså ett slags heltal. Detta 

innebär att den information som behöver föras över till funktionen inte är hela texten, 

vilket skulle kunna bli väldigt resurskrävande om texten var lång, utan bara adressen 

till textens första tecken. Variabeln txt och variablerna text1 och text2 representerar 

alltså inte bara lika texter utan samma texter vid respektive funktionsanrop. Alltså 

txt==text1 sedan txt==text2, text1 och text2 är naturligtvis aldrig lika. 

Detta har ytterligare en effekt, förutom att vara resurseffektivt. Man kan nämligen 

manipulera innehållet i fältet inuti funktionen. 

Se exempelvis funktionen och anropet 

void mata_in_textrad(char txt[]); 

void mata_in_tal( int ); 

int main() 

{ 

char inmatningsyta[200]; 

int talet; 

mata_in_textrad( inmatningsyta ); 

mata_in_tal( talet ); // går ej 

cout



const double PI = 3.14159265358; 

const int NOLL = 0; 

const char ALFABET[] = "abcdefghijklmnopqrstuvwxyzåäö"; 

Konstanter har ofta identifierare som bara består av versaler. Den sista deklarationen 

skall läsas som ett fält bestående av const char. Tecknen i fältet får inte ändras. Att 

deklarera en variabel som konstant gör att man inte har tillåtselse att ändra variabelns 

värde. Samtliga följande satser är otillåtna 

PI = 3.14; 

NOLL += 1; 

ALFABET[3] = 'D'; 

// otillåtet för const double 

// otillåtet för const int 

// otillåtet för const char 

För funktioner innebär det att om den tidigare funktionen mata_in_textrad( char [] ) 

istället skulle skrivits som 

void mata_in_textrad(const char txt[]); 

// och definition 

void mata_in_textrad(const char txt[]) 

{ 

cin.getline(txt, 80); 

} 

8.4.3 Referenser 

int i = 3; 

int & ref = i; 

är det en otillåten operation att ändra värdet på tecknen i fältet. cin.getline( txt, 80) är 

då en otillåten operation, kompilatorn ger felmeddelande, eftersom satsen ändrar 

innehållet i fältet. Jämför deklarationerna av texthanteringsfunktionerna i cstring. 

En annan speciell deklaration får man om man deklarerar en variabel som referens. 

Detta ser ut som 

Rad 2: Deklarerar identifieraren ref att vara en så kallad referens. En referensvariabel 

är en synonym till en redan existerande variabel. Referensen fungerar på exakt samma 

sätt som den ursprungliga variabeln. Genom referensen får man alltså här två 

variabelnamn/identifierare att referera till exakt samma data. 

Betrakta 

int i = 3; 

int j = 4; 

int & ref = i; 

ref = j; // obs tilldelning värdet i j kopieras till ref/i 

i++; 

cout



Programsnutten ger resultatet 

i:5 

j:4 

ref:5 

i:6 

j:4 

ref:6 

Detta kommer sig alltså av att ref och i representerar samma instans (samma faktiska 

heltal). Tilldelningssatsen på rad 4 ger alltså endast värdet av j till instansen i/ref. Med 

tanke på att referenser är synonymer till redan existerande instanser måste de initieras i 

samband med en deklaration, detta görs automatiskt om man gör dem till 

funktionsargument (de initieras då med de aktuella argumenten), men inte om man 

deklarerar dem som ovan. Följande sats är otillåten eftersom den inte refererar till 

något existerande heltal. 

int & j; 

int & k = 4; // otillåtet 4 är ingen heltalsvariabel 

I exempel som detta är det svårt att se nyttan med referenser. Nyttan blir tydligare om 

man visar hur det fungerar för ett funktionsargument. Betrakta funktionen och 

programmet 

void mata_in_tal( int& , int &); 

int main() 

{ 

int tal1, tal2; 

cout



9 Fältteori 

9.1 Fält av andra datatyper än char 

Vid beräkningar med större datamängder än några enstaka tal är det bekvämt att kunna 

betrakta en talmängd som en enhet. Detta åstadkommer man genom att deklarera fält 

av taltyper som exempelvis 

int i_array[10]; // deklarera ett heltalsfält 

double x_array[10]; // flyttalsfält 

int j_array[]={ 1, 3, 5, 7, 9, 11, 13, 15}; // initierat fält 8 element 

Andra datatyper går naturligtvis också bra. 

För dessa fält gäller samma som för vanliga variabler, dvs är de inte initierade kan 

vilka värden som helst finnas bland heltalen/flyttalen. Det som skiljer dessa fält från 

textfältet är att det inte är meningsfullt med någon "nolltecken". På samma sätt som för 

textfälten anger fältvariabeln vart fältets element börjar i minnet. 

Den skarpsinte noterar att ett textfält kan initieras som 

char text[]= {'H','e','l','l',''o',' ','W','o','r','l','d','\0'}; 

eller för all del med teckenkoderna motsvarande tecknen 'H', 'e', 'l' etc. 

Exempel, inmatning och beräkning av medelvärdet av 10 flyttal 

#include 


int main() 

{ 

double talserie[10]; 

for (int tal_nr = 0; tal_nr



Resultatet av en programkörning kan bli 

Mata in tal nr:0 

1.0 


4.0 


7.0 


6.0 


7.0 


13.3 


12.98 


5.4 


3.3 


3.2 

Medelvõrdet õr:6.318 


Flera saker måste klargöras för exemplet. Det första flyttal som matas in är element 

nummer noll dvs flytttalsinstansen talserie[0] därför initieras tal_nr till 0. Tänk på en 

komplett utvärdering av cin>>satsen på rad 11 ger till slut (istream)>>(double). 

Medelvärdet beräknas först genom att först beräkna summan och därefter dividera med 

antalen termer i summan. Observera att iterationsvillkoren i for-satserna är tal_nr < 10 

och inte som i fallet med textfält en nollteckenkontroll. 

70



#include 


Förbättrad version med procedurell abstraktion. 

Flera av delarna i programmet ovan kan delas upp i funktioner. 

void mata_in_flyttal( double [], int); 

double medel( const double [], int ); 

void skriv_ut_array( const double [], int); 

int main() 

{ 

const int ANTAL_TAL = 10; 

double talserie[ ANTAL_TAL ]; 

mata_in_flyttal( talserie, ANTAL_TAL ); 

// beräkna medelvärdet 

double medel_tal = medel( talserie, ANTAL_TAL ); 

cout



Analysera exemplet noga. Det är ett gott exempel på hur ett relativt komplicerat 

huvudprogram kan delas upp i mindre uppgifter, och hur resultatet blir ett överskådligt 

huvudprogram med klara avsikter. Funktionerna är dessutom generella och kan 

återanvändas i någon annan del av programmet eller i något annat program. En 

heltalskonstant används för att på ett säkert sätt ange antalet element i fältet. Notera 

gärna att programmet i denna andra tappning är mycket enklare att göra ändringar i och 

dessutom mycket enklare att upptäcka fel i. 

Funktionerna som inte ändrar innehållet i fältet är const deklarerade för att garantera att 

fältets element inte ändrar värden. const deklarationen påverkar inte direkt funktionen 

hos programmet men är en viktig del i god programmeringssed. Om du inte har 

tillgång till källkoden till exemplen bör du mata in programmet i din utvecklingsmiljö. 

Studera funktionen hos programmet och hur ändringar påverkar programkörning. 

Programmet är uppbyggt av algoritmer som du måste känna till, exempelvis 

summaberäkningen. 

Se även avsnittet standardalgoritmer för andra exempel med numeriska fält. 

72



10 Standardalgoritmer 

10.1 Swap funktion 

int i = 4; 

int j = 9; 

En swapfunktion är en funktion som byter innehållet i två variabler. Funktionen kan 

anropas som 

swap( i, j); // byt plats 

// j innehåller 4, i innehåller 9 

funktionen är användbar för i synnerhet heltalsvariabler och flyttalsvariabler 

// Deklaration: 

void swap( int & a1, int & a2); 

// Definition: 

void swap( int & a1, int & a2) 

{ 

int tmp = a1; // spara a1 tillfälligt 

a1 = a2; 

a2 = tmp; 

} 


Se till så att du förstår funktionen hos swap-funktionen. Se avsnitt Funktioner/Speciella 

datatyper/Referenser. 

Skriv om swap funktionen så att den fungerar för flyttal, datatypen string och char-fält 

10.2 Sök minsta värdet i en array 

En funktion som söker efter det minsta värdet i en array av flyttal. Funktionen 

returnerar det index som det minsta talet befinner sig på. Principen är att 

 

 

antag att det minsta talet befinner sig på den första positionen 

iterera igenom övriga element, om ett mindre tal än det minsta upptäcks, låt det 

nya talet representera det minsta talet. Då arrayen är genomlöpt har det minsta 

elementet funnits. 

funktionen är användbar för i synnerhet heltalsvariabler och flyttalsvariabler 

73



// Deklaration: 

void find_min( double [], int); 

// Definition: 

void find_min( const double arr[], int size); 

{ 

int min_idx = 0; // minsta finns på position 0 

} 

for(int i = 0; i< size; i++) 

{ 

if ( arr[ i ]< arr[min_idx]) // jämför element i med det minsta 

min_idx = i; 

} 

return min_idx; 


Skriv om funktionen så att den kan hantera heltal och fält av datatypen string. 

Skriv en funktion som letar det största talet find_max 

10.3 Array sortering 

En enkel metod att sortera element i en array är metoden sök-minsta-byt. Metoden går 

ut på att man börjar med att leta igenom hela arrayen efter det minsta elementet i 

arrayen, man tar då det minsta elementet och byter plats med elementet sist i arrayen. 

Man kan nu betrakta detta minsta sista element som att vara sorterat. 

Den osorterade delen av arrayen är nu alla element utom det sista. Den kvarvarande 

sorteringsuppgiften är alltså att sortera en array som består av ett färre element än 

tidigare. Proceduren upprepas på denna mindre array, tills bara ett element återstår. 

Detta ensamma element är även det i ordning. Metoden sorterar arrayen i fallande 

ordning. Funktionen kräver att funktionerna swap(double &, double &) och find_min( 

duoble [], int); är definierade. 

Deklaration: 

void sort_array( double [], int); 

Definition: 

void sort_array( double arr[], int size) 

{ 

for( ; size>0; size--) 

{ 

int min_idx = find_min( arr, min ); 

int last_idx = size-1; 

swap( min_idx, last_idx); 

} 

} 


Skriv om funktionen så att den sorterar i stigande ordning, sort_ascending( double [], 

int ). Skriv om funktionen så att den sorterar textsträngar av datatypen string 

74



10.4 Övrigt 

Det finns i texten beskrivet flera funktioner som är av yttersta vikt att kunna använda, 

förstå och kunna skapa på egen hand. Bland annat 

 

 

 

7.3.2 Exempel, tilldelning av textfält. Skriv rad 10 - 12 som en funktion. 

Standardfunktionen heter strcpy ur 

7.3.3 Exempel, att räkna längden på en text. Skriv rad 11 som en funktion. 

Standardfunktionen heter strlen ur 

s 71 Medelvärdesfunktion double medel( double[], int) 

75



11 Operatorprioriteter 

Högsta prioritet överst, höger kolumn anger utvärderingsriktning 

[ ] ( ) . –> postfix ++ och postfix –– Vänster till höger 

prefix ++ och prefix –– 

Vänster till höger 

sizeof & * + – ~ ! Höger till vänster 

typomvandlingar 

Höger till vänster 

* / % Vänster till höger 

+ – Vänster till höger 

> Vänster till höger 

< > = Vänster till höger 

== != Vänster till höger 

& 


^ 


| Vänster till höger 

&& 


|| Vänster till höger 

? : Höger till vänster 

= *= /= %= += –= = &= ^= |= Höger till vänster 

, Vänster till höger 

76



12 Teckenkoder – Asciitabell 

Tecken Dec Hex 

NUL 0 00 

SOH 1 01 

STX 2 02 

ETX 3 03 

EOT 4 04 

ENQ 5 05 

ACK 6 06 

BEL 7 07 

BS 8 08 

HT 9 09 

LF 10 0A 

VT 11 0B 

FF 12 0C 

CR 13 0D 

SO 14 0E 

SI 15 0F 

DLE 16 10 

DC1 17 11 

DC2 18 12 

DC3 19 13 

DC4 20 14 

NAK 21 15 

SYN 22 16 

ETB 23 17 

CAN 24 18 

EM 25 19 

SUB 26 1A 

ESC 27 1B 

FS 28 1C 

GS 29 1D 

RS 30 1E 

US 31 1F 


SP 32 20 

! 33 21 

" 34 22 

# 35 23 

$ 36 24 

% 37 25 

& 38 26 

' 39 27 

( 40 28 

) 41 29 

* 42 2A 

+ 43 2B 

, 44 2C 

- 45 2D 

. 46 2E 

/ 47 2F 

0 48 30 

1 49 31 

2 50 32 

3 51 33 

4 52 34 

5 53 35 

6 54 36 

7 55 37 

8 56 38 

9 57 39 

: 58 3A 

; 59 3B 

< 60 3C 

= 61 3D 

> 62 3E 

? 63 3F 


@ 64 40 

A 65 41 

B 66 42 

C 67 43 

D 68 44 

E 69 45 

F 70 46 

G 71 47 

H 72 48 

I 73 49 

J 74 4A 

K 75 4B 

L 76 4C 

M 77 4D 

N 78 4E 

O 79 4F 

P 80 50 

Q 81 51 

R 82 52 

S 83 53 

T 84 54 

U 85 55 

V 86 56 

W 87 57 

X 88 58 

Y 89 59 

Z 90 5A 

[ Ä 91 5B 

\ Ö 92 5C 

] Å 93 5D 

^ 94 5E 

_ 95 5F 


` 96 60 

a 97 61 

b 98 62 

c 99 63 

d 100 64 

e 101 65 

f 102 66 

g 103 67 

h 104 68 

i 105 69 

j 106 6A 

k 107 6B 

l 108 6C 

m 109 6D 

n 110 6E 

o 111 6F 

p 112 70 

q 113 71 

r 114 72 

s 115 73 

t 116 74 

u 117 75 

v 118 76 

w 119 77 

x 120 78 

y 121 79 

z 122 7A 

{ ä 123 7B 

| ö 124 7C 

} å 125 7D 

~ 126 7E 

DEL 127 7F 

NUL = Null 

SOH = Start of Heading 

STX = Start of Text 

ETX = End of Text 

EOT = End of Transmission 

ENQ = Enquiry 

ACK = Acknowledge 

BEL = Bell 

BS = Backspace 

HT = Horizontal Tabulation 

LF = Line Feed 

VT = Vertical Tabulation 

FF = Form Feed 

CR = Carriage Return 

SO = Shift Out 

SI = Shift In 

DLE = Data Link Escape 

DC = Device Control 

NAK = Negative Acknowledge 

SYN = Synchronous Idle 

ETB = End of Transm. Block 

CAN = Cancel 

EM = End of Medium 

SUB = Substitute 

ESC = Escape 

FS = File Separator 

GS = Group Separator 

RS = Record Separator 

US = Unit Separator 

SP = Space (Blank) 

DEL = Delete 

77

Introduktion till programmering - Mittuniversitetet

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?