2.1.1. Et brohoved.

Forhåbentlig kender du Kernighan & Ritchies bog The C Programming Language. Det første kapitel, den berømte "tour" gennem C sproget, starter med et program, der skriver "Hello, World!" på en uddataenhed (altså en skærm eller lignende).[1]

Det program kunne man jo så udnævne til stamfaderen for en hel kategori. "Hello-world" programmer isolerer en feature og afprøver, hvordan den virker. Et "hello-program" skal helst kunne køre, selv om vi nogen gange nøjes med at skrive en funktion for at se, om oversætteren accepterer den syntaks, vi anvender.

Et "hello-program" kan være et, som skriver noget på skærmen, eller det kan hente dato-information, så kan vi få bekræftet, om dato funktionerne opfører sig, som vi forventer, eller ej. Vi kunne kalde det for et minimalprogram. Vi kunne også sige, at vi isolerer de features i C sproget, som vi ønsker at lære/undersøge/afprøve. Metoden er vigtig at lære. Det er en ekstremt nyttig metode; med den kan man løse flere problemer, end man kan med en debugger.

2.1.2. Returværdi fra en funktion

Det, vi skal i gang med nu, er at undersøge, hvordan funktioner afleverer data til hinanden, og hvordan C sproget gør det lettere at lave sådan nogle "kasser", ofte kaldet black box, om hvilken man ved, at den kan dit og dat, og at den er helt uafhængig af resten af vores program.

Et helt grundlæggende "Hello-world" program er et, som simpelt hen afslutter med det samme! Sådan et kommer her:

/* frame.c Minimalt program til afproevning af statuskode. */

int main()
{
    return 0;
}

/* end of file frame.c */

Program-source, kildeteksten består af 8 linjer, hvis man tæller kommentarer og tomme linjer med. Aller øverst er der en kommentar, som fortæller kort hvad meningen med programmet er. En kommentar startes med "/*" og slutter med "*/".

Programmet består af en definition af ét eksternt objekt, nemlig en funktion, som har navnet "main". Parenteserne efter main fortæller, at main er et objekt af typen funktion. Parenteserne kaldes derfor "funktions-operator" [2] Selve koden i main er indrammet i krøllede parenteser, braces. Koden består af kun én sætning, eller statement , nemlig

return 0;

return er en specifikation af, at funktionen skal aflevere noget til den, som har bedt om at få udført funktionen (har kaldt den.)

return er et reserveret ord , d.v.s. et ord, som oversætteren er født med at kende. C sproget har 32 reserverede ord. (se Afsnit A.1 .)

Nullet er et "udtryk", (aritmetisk udtryk) med en talværdi. Vi kunne også have skrevet return 234 eller return 7000143. I dette tilfælde vil det dog være klogt at holde talværdien under 256.

Eksempler på andre expressions: kroner = timer * timeloen; hvor det forudsættes at kroner, timer og timeloen er variable, som indeholder fornuftige værdier. Et expression, som afsluttes med semikolon, kaldes et statement.

Hvis der er flere statements i en funktion, udføres de i rækkefølge, oppefra nedefter.

Et kald til en funktion, som f.eks. flg.: abs(-5); er også et expression, i dette tilfælde med værdien 5. Kald til en funktion vil ofte returnere en variabel af typen heltal, integer , og en integer i et expression kan erstattes af et kald til en funktion, som returnerer en integer.

Det er en konvention, at kørsel af et program, som benytter standardbiblioteket (med bl.a. læse- og skrivefunktioner) begynder med funktionen main. Når man kommer til slutningen af denne funktion, slutter programmet her med at returnere en statuskode til styresystemet. Denne statuskode bruger man til at markere om programmet blev afbrudt af en fejl (og lignende). Hvis et program slutter uden et "return <expression>;" er det sjusk.

Kernighan & Ritchie dropper return-sætningen en del gange i bogen, men det er faktisk sjusk alligevel! De gør det selvfølgelig fordi det er lettere at forklare et program, hvori der kun er de nødvendigste linjer.

Statuskoden bør fortælle, om programmet kunne køre uden fejl, (dvs. uden fejl, der er påført af ydre omstændigheder, som f.eks. at en datafil mangler). Det er altså programmørens mulighed for at sende et signal om at "alt er vel" eller "her opstod en fatal fejl".

Hvis programmøren vil fortælle systemet, at der var en fejl, skrives simpelthen:

return 255;

Tallet kan i Unix-kommandofortolker-sammenhæng læses i variabelen $?, som kan styre processtrømmen i et Unix-skalprogram (en shell) .[3] Øvelse: Ret, så programmet returnerer 117 og se, om du kan udskrive systemvariablen $? med kommandoen

dax@pluto$ echo $?
 0
dax@pluto$

Det lille program ovenfor kunne oversættes/compileres [4] med flg. kommando:

dax@pluto$ gcc frame.c -o frame 
dax@pluto$

Derefter kan det køres fra current directory (i det aktuelle katalog, eller sagt på en tredie måde, fra det bibliotek, som vi står i [5] ) med en kommando som:

dax@pluto$ ./frame 
dax@pluto$

eller, hvis din PATH-systemvariabel ender på ':'

dax@pluto$ frame 
dax@pluto$

Eksemplet lider imidlertid af en alvorlig skavank, vi kan jo næsten ikke se, om programmet rent faktisk kører. Det laver jo ikke noget! Derfor tilføjer vi en lille output kommando:

/* frame2.c Skriv til stdout og afslut. */

#include <stdio.h>

int main()
{
    puts("Hello! Programmet frame2 kører nu...");
    return 0;
}

/* end of file frame2.c */

Her er flere ting, som er værd at lægge mærke til. Dels et include direktiv, d.v.s. en kommando, som fortæller oversætteren, at den skal læse en fil, der hedder stdio.h. Når filnavnet står i vinkler , så betyder det, at oversætteren skal lede der, hvor systemet normalt har sine filer med erklæringer, "include filerne". På Unix, Linux og andre systemer er det /usr/include, der gennemsøges først.

Oversætteren finder den pågældende file og læser den. Den indeholder kun type erklæringer.

Den erklæring, som vi skal bruge, ser ud som følger:

extern int puts (const char *__str);

Den kunne dog også have set enklere ud:

int puts (char *message);

Det kaldes en prototype. Denne gør det muligt for oversætteren at tjekke, at funktionskald vil fungere efter hensigten.

Prototypen "int puts(char*)" fortæller, at puts er en funktion, som returnerer en integer og forventer at få en character pointer som argument.

En prototype for vores main (som burde findes i en af glibc - systemets header filer) ville hjælpe oversætteren med at kontrollere, om vi overholdt interface mellem vores main og bibliotekets startup procedure. [6] Denne prototype ville se sådan ud:

int main(int argc, char *argv[], char *env[]);

Det er ikke nødvendigt at angive et navn, en identifier, på argumenterne, kun typen skal angives når vi skriver en prototype.

int main(int, char *[], char *[]);

Men det er oplagt at finde navne, som giver læseren en hjælp til at forstå meningen med funktionen. Argc står for argument count, argv for argument vector, en liste med alle parametre fra det program, som har startet vores program op; env står for systemvariable (eng. environment variables), her kan vi aflæse brugerpreferencer og ligenende. Når vi ikke bruger parametrene til main, kan vi nøjes med at skrive main(), altså en tom funktions-parentes.

/* frame3.c Demonstration af character pointer. */

#include <stdio.h>

int main()
{
    char *charpointer = "Hallo! Programmet frame3 kører nu...";
    puts(charpointer);
    return 0;
}

/* end of file frame3.c */

char *charpointer er erklæring af en variabel. Variabelen er en character pointer, det vil sige en adresse variabel. Den initialiseres på samme source linje, som den erklæres. Det er simpelthen en praktisk skrivemåde. Det svarer til:

main()
{
    char * charptr;              /* charptr er en variabel */
    charptr = "Hallo etc... ";

En literal string, "Hallo etc... "; er ikke en variabel, men er en besked til oversætteren om at initialisere et dataområde med den tekst, som vi nu ønsker os. For at kunne bruge teksten skal vi enten gemme adressen på den (altså cptr = "Hallo etc...") eller også give adressen på denne string til den funktion, som skal bruge den: puts("Hallo etc..");

En gengivelse af dette system af RAM-adresser og indhold kunne tegnes som en reol. Her er det en reol, hvor hver hylde har et indhold, der enten kan være 4 bytes eller 4 bogstaver, eller én adresse (32 bits).

        Adresse               
        eller
        hylde-nr.      Indhold

                    ~             ~
                    :             :
                    +-------------+
                    |             |
                    |  o !   P    |
           800440   +-------------+
                    |             |
                    |  H a l l    |
           800436   +-------------+
                    |             |
                    |             |
                    +-------------+
                    |             |
                    :             :
                    :             :
                    :             :
                    |             |
           120808   +-------------+  charptr er en adressevariabel,
                    |             |  som indeholder adressen
                    |  <800436>   |  på en string, "Hallo! Prog...etc."
 charptr:  120804   +-------------+
                    |             |
                    |             |
           120800   +-------------+
                    |             |
                    |             |
           120796   +-------------+
                    :             :
                    :             :
                    |             |
                    :             :
                    :             :
                    |             |

Det, der skrives på skærmen, er tekst, som bogstav for bogstav ligger i programmets data-del.

Lad os nu gå over til beregningsprogrammer. Hvis de ikke har noget input, er de en slags "hello" programmer, fordi de isolerer de aritmetiske operationer. Selv om vi begynder med simple eksempler, kan det sandelig godt være nyttige programmer. Den oprindelige idé om computere var jo blot at de skulle beregne ting, som var trælse at beregne i hånden, planetbaner, skatteopgørelser og lignende ;-)