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 1

Nu är det dax att dra igång en lite skola i hur man kommer igång med att programmera på Amigan. Detta gör vi i programmeringsspråket C.
För er som redan kan C eller programmering i stort kommer den här kursen kanske inte ge så mycket eftersom den från början är tänkt till dem som kanske inte programmerat förr.

En kompilator

För att kunna programmera i C så måste man först införskaffa sig en kompilator. Den gör om källkoden till det språk som datorn använder sig utav för att kunna exekvera ett program.
Som utgångspunkt för denna skola kommer vi att använda oss utav StormC, men koden kan köras i andra kompilatorer också om man vill köra någon annan kompilator istället.
För de som inte vill lägga ut 3000:- för StormC så finns det ett billigare alternativ. Det är att köpa Amiga Developer CD V2.1. Den kan hittas hos GGS-Data och innehåller en lightversion av StormC V3. Dock så får man inte göra sig pengar på de program man gör med den versionen, inte heller genom sharewareprogram. För att få sälja programmen måste man köpa den fulla versionen.
StormC hittas i alla fall på cd-skivan under katalogen Contributions/Haage_&_Partner/StormC. Det är bara att installera!
StormC har även bra stöd för texteditorn GoldEd, så ni som har GoldEd kan använda den editorn, det är bara att ändra i StormCPP-ikonen till GoldEd=TRUE.

Komma igång

Vi kan börja med att göra ett litet program som skriver ut en text och sedan gå igenom vad vi gjort.
Börja med att i StormC's meny välja Project/New. i "Project Assistent" sätter du vart du vill ha projektet, skapa en ny katalog där du vill ha projektet, samt vad det ska heta, i vårat fall 'Printf'. Klicka för 'C Program' och sedan 'Ok'. När den frågar om den ska skapa .c-filen så svara genom att trycka på 'Create'.
Nu har vi skapat en källkodsfil som heter 'Printf.c' samt en projektfil som heter 'Printf.¶'.
Dubbelklicka på 'Printf.c' i projektets fönster, den står under 'Sources'. Nu ska ett editorfönster öppnas med den tomma filen 'Printf.c'.
Skriv in följande:
#include <stdio.h>int main()
{
	printf("Vårat första program!\n");
	return 0;
}
Spara programmet med 'Save' i menyn eller genom att trycka ner 'höger Amiga' och sedan 's' samtidigt.
För att kompilera så trycker vi på 'F8'. Då kommer den att fråga om att få skapa objekt-filer, tryck 'Create'.
StormC kompilerar nu källkoden och vi kan se detta genom att ett kompileringsfönster hoppar upp. Här ser vi även fel som kompilatorn hittar.
Om kompileringen gick bra, inga fel, så är det bara tycka på 'r' eller knappen 'Run'. Ett konsollfönster ska dyka upp och texten 'Vårat första program!' ska dyka upp i det.

Vad har vi gjort?

Nu ska vi ta och kolla vad vi egentligen har gjort för något. Vi börjar från början.

#include
#include används för att komma åt förskrivna rutiner, i vårat fall 'printf'. Man kan tänka sig att funktionerna finns i dessa .h-filer, men det är bara halva sanningen, det är bara huvuden för funktionerna som gör att kompilatorn kan hitta funktionerna. Vi tar inte upp mer om detta utan går vidare.
<stdio.h>
<> betyder att den ska leta i 'defaultkatalogen' och det betyder helt enkelt där kompilatorn har sina egna includefiler. Skulle vi ha " " istället för <> så skulle den leta i projektkatalogen.
stdio.h är den fil där vi "hittar" funktioner som har med I/O att göra. Till exempel att skriva ut text, läsa in text och så vidare. Här finns funktionen printf som vi vill använda i vårat program.
int main()
Här startar vi våran funktion 'main'. Funktionen 'main' är den funktion som startas när man exekverar programmet, så den måste alltid finnas med i programmen.
int betyder att funktionen returnerar en integer, ett heltal.
() betyder att den inte tar några argument, mer om detta vid ett senare tillfälle.
{ }
Detta är start och stopp på ett block. Block används för att gruppera funktionsanrop. Allting mellan ett { och det tillhörande } ingår i det blocket.
printf("Vårat första program!\n");
printf är den funktion som vi vill använda. Den skriver ut text på något som kallas stdout, standard-out.
" är början och slutet på en sträng, som text kallas. Allt innanför " och dess avslutande " ingår i strängen. I vårat fall är strängen 'Vårat första program!\n'.
\n är ett specialtecken. \ betyder att det kommer något specciellt och i vårat fall ett n. N betyder newline, det vill säga att den ska hoppa ner en rad. Ett annat exempel är \t. T betyder 'tab' och då stoppas det in en 'tab' där.
; betyder slutet på funktionen. Alla funktionsanrop måste avslutas med ett ';'.
return 0;
return betyder att den ska hoppa ut ur funktionen och '0' betyder att funktionen ska returnera talet 0. Eftersom vi hade 'int' före main så måste vi ha ett heltal här.

Lite mer avancerat

Vi kan ta och byta ut texten i strängen lite och visa lite mer hur man kan använda '\'.
Byt ut texten innanför () mot "Första\traden!\nAndra raden!\n Tredje\\raden!\n".
Spara och tryck 'F8' för att kompilera. Kör programmet och se resultatet. På första raden blir mellanrummet mellan första ordet och andra ordet lite längre eftersom det är en '\t' där, det vill säga en 'tab'. Andra raden hittar vi under första raden och den har bara ett blanksteg, precis som vi skrev den. Tredje raden börjar ett steg in eftersom vi hade '\n ' där. Dessutom är det ett '\'-tecken mellan orden. Detta för att vi skrev in '\\'. Hade vi bara skrivit in '\' hade den försökt tolka mellanslaget som något specialtecken. '\\' betyder alltså '\' i strängen.

Datatyper

Det kan ju vara ide att kolla lite mer på de mest använda datatyperna som vi kommer att stöta på. De vanligast använda är integer (heltal), float (flyttal), character (tecken).
Alla dessa är uppbyggda av bitar. Till exempel en char är åtta bitar lång. Åtta bitar är en byte (uttalas 'bajt', red. anm.). Det innebär att en char är en byte stor.
En byte kan innehålla ett värde mellan 0 och 255. Hur man kan räkna ut detta? En bit kan vara antingen 0 eller 1. Två bitar kan ha värden mellan 0 och 3, eftersom de tillsammans kan kombineras som 00 (0), 01 (1), 10 (2) och 11 (3).
För att räkna ut hur många tal x antal bitar kan representera kan man räkna 2 upphöjt i x. En bit är 2 upphöjt i 1 = 2, det vill säga 0 och 1. 2 upphöjt i 8 är 256, det vill säga tal mellan 0 och 255.
Integer är 4 bytes långa, float är också 4 bytes men här används bitarna på ett annat sätt eftersom float representerar flyttal. Flyttal skrivs med '.' och inte ',', så ett '0,1' skrivs '0.1' i C.

Använda datatyper

Nu när vi kan lite mer om datatyper så kan vi testa och använda dem lite. För att göra detta så ska vi lära oss lite om variabler. Variabler används för att lagra data och värden som man vill kunna ändra på. De måste deklareras i början av det block som de ska användas i. En variabeldeklaration kan se ut så här: 'int tal;'. Här skapar vi ett namn på en integer (heltal). Namnet 'tal' representerar nu en integer.
Nu när vi har en integer som heter tal kan man göra lite med den. Vi gör om vårat program så att den använder lite variabler istället.
#include <stdio.h>int main()
{
	float tal;
	int tal2 = 10;
	char bokstav = 'A';	tal = 0.01;
	tal2 = 5;
	bokstav = 66;
	
	printf("Flyttal: %f\nHeltal: %d\nBokstav: %c (%d)\n", tal, tal2, bokstav, bokstav);	return 0;
}
Kopilera och kör. Resultatet borde bli:
Flyttal: 0.010000
Heltal: 5
Bokstav: B (66)

Vad är det nu vi gjort?

Vi går igenom det nya:
float tal;
Här deklarerar vi en variabel 'tal' som är av typen 'float', flyttal.
int tal2 = 10;
Här deklarerar vi en variabel 'tal2' som är av typen 'int', heltal. Dessutom sätter vi variabelns värde till 10.
char bokstav = 'A';
Här deklarerar vi en variabel 'bokstav' som är av typen 'char', tecken. Dessutom sätter vi variabelns värde till 'A'. 'A' representerar egentligen ett bytevärde på 65. Värdet 65 representerar således tecknet 'A' (stora a). Detta kommer sig av att 'A' ligger på plats 65 i ASCII-tabellen, tabellen över de tecken som en 'char' kan vara.
Tänk på att även siffror kan användas som tecken (exempel bokstav = '2';), samt alla special tecken som !"£$%&/()=? och så vidare.
tal = 0.01;
Här ändrar vi variabeln tal's värde till 0.01. Man ska inte läsa ut värden ur variabler innan de har fått sig ett värde tilldelat. Detta eftersom man inte kan veta säkert vilket värde de har då.
tal2 = 5;
Här ändrar vi variabeln tal2's värde till 5. Det var 10 innan eftersom vi satte det till 10 vid deklarationen men nu är det 5.
bokstav = 66;
Här ändrar vi variabeln bokstav's värde till 66 vilket betyder 'B'.
printf(...);
Här har vi lagt till lite nytt. För att skriva ut variablers värden så lägger man till % och en bokstav, som representerar vilken datatyp man vill skriva ut, i strängen. Sedan måste man även specifisera vilka variabler man ska skriva ut. Detta gör man efter det avslutande '"'. För varje '%X' måste man ha något efter strängen som visar vad man vill ska skrivas ut där.
'%f' (flyttal) har vi först och därför har vi 'tal' direkt efter strängens slut. Därefter har vi '%d' (heltal) och därför har vi 'tal2' efter 'tal'. Sedan har vi '%c' (tecken) och 'bokstav' följer således efter 'tal2'. För att visa att bokstaven egentligen är ett värde skriver vi ut 'bokstav' som ett heltal med det sista '%d', därför är det 'bokstav' igen efter första 'bokstav'.

De olika '%' som kan användas för 'printf' är:
c - character (tecken)
d - decimal integer (heltal)
e - floating point number in scientific notation (flyttal på format e+XX)
f - floating point number (flyttal)
g - shortest of e or f (kortaste representationen mellan e och f)
s - string (text)

Nästa steg

Nu kan vi lite om att skriva ut saker på skärmen. Då börjar det väl vara tid för att läsa lite från tangentbordet också.
Till detta använder vi oss av funktionen scanf(). Scanf fungerar som printf, fast tvärt om.
Här måste vi dock tänka till. Scanf(), som också ligger i 'stdio.h' ska skriva i variablerna den får som argument. Detta innebär att den måste ha minnesadresserna till variablerna och inte värdet av variabeln som argument.
För att uppnå detta använder man sig utav '&' före variabelnamnet. Då skickas adressen till funktionen och inte värdet.
Det vill säga att 'scanf("%d",&heltal)' läser in, från det vi skriver, ett heltal och lägger in det i variabeln heltal. Hade vi glömt bort '&' så hade scanf tolkat värdet i heltal som adressen där den ska skriva in värdet vilket kan leda till en krasch eftersom det skriver rakt ut i minnet! Här gäller det att se upp.
Vi tar ett program som exempel på att läsa in 3 olika värden i 3 variabler. Skapa ett nytt projekt för detta, kalla det Scanf.
#include <stdio.h>int main()
{
	int heltal;
	float flyttal;
	char bokstav;	printf("Skriv in ett heltal, ett flyttal och en bokstav: ");
	scanf("%d %f %c",&heltal,&flyttal,&bokstav);
	printf("Du skrev in:\nHeltalet %d\nFlyttalet %f\nBokstaven %c\n",heltal,flyttal,bokstav);	return 0;
}
Kompilera programmet. När du kör programmet kommer texten från första printf(). Därefter väntar programmet i scanf() på att man ska skriva in ett heltal (%d), ett flyttal (%f) och ett valfritt tecken (%c).
Skriv in '10 1.13 a' och tryck 'Enter'. Nu ska programmet skriva ut de tal du skrivit in. Observera att ordningen på vad du skriver in är av betydelse, programmet väntar sig ett heltal först, sedan ett flyttal och sist ett tecken.

De olika '%' som kan användas för 'scanf' är:c - character (tecken)
d - decimal integer (heltal)
f - floating point number, float (flyttal)
lf - floating point number, double (flyttal, 8 bytes)
LF - floating point number, longf double (flyttal, 8 bytes)
s - string (text)

Avslutning del 1

Det ska väl vara allt som jag hade tänkt ta upp den här gången. Jag hoppas att det mesta går att förstå. Kommentarer och frågor skickas till mig på [email protected] med rubrik 'programmeringsskolan'.

Hemsidorna underhålls av Magnus Andersson