Programmering i ANSI-C/Programexempel

Programexempel

Hej världen

#define TITEL       "Hej världen för ANSI-C."
#define MEDDELANDE  "Hej världen\n"

#include <stdio.h>

int main( void )
{
    printf ( MEDDELANDE );
    return ( 0 );
}

Hej världen, programmet visar några av dom grundläggande funktionerna i ANSI-C. Dom två första raderna skapar makron som består av ett namn och ett stycke programkod. Om preprocessorn finner ett motsvarande makronamn längre ned i källkoden så ersätts det med makrots programkod innan kompileringen. Nästa rad inkluderar huvudfilen (standardbiblioteket) "stdio.h" som innehåller definitionerna för den in och utmatningsstandard som ANSI-C använder, bla funktionen "printf" som används här. Sedan följer programmets huvudslinga där först meddelandet (som är lagrat i makrot) skrivs ut till standrardströmmen och sedan retureras heltalet 0 till det anropande programmet. Vi ser också hur funktionerna i C är uppbyggda med först funktionshuvudet som består av 1; returparameterns typ, 2; funktionens namn 3; en parentes med en lista (av obegränsad längd) på anropsparametrar. Sedan följer dom klamrar " { kod } " som anger funktionens början och slut. Inom dessa klamrar finns funktionens programkod.

Se även: Samma program i andra språk på sidan Hello World i wikisoure.

Sökväg

#define TITEL 	    "Skriv ut aktuell sökväg, för ANSI-C."
#define MEDDELANDE  "Aktuell sökväg är: "

#include <stdio.h>
#include <string.h>

int main ( int argc, char * argv[] )
{
    printf ( strcat ( MEDDELANDE, argv[0] ) );
    return ( 0 );
}

Sökväg, programmet skiljer sig från "Hej världen" främst i det avseedet att huvudfunktionen har två ingångsparametrar, "argv[]" och "argc", värdet på dom här parametrarna bestämms av det anropande programmet. "argv" är en lista med pekare till ett antal texsträngar och "argc" är ett heltal som anger hur många textsträngar det finns i listan. När programmet sedan körs så anger standraden att listan alltid innehåller minst 1 strängpekare = "argv[0]". Den pekar på en sträng som innehåller den aktuella sökvägen (inklusive programnamnet) som programmet startats ifrån. Övriga strängars förekomst beror på det anropande programmet, vanligtvis en kommandotolk (promt), kommandoformatet är då "programnamn arg0 arg1 arg2 ..." där "argn" är dom olika strängarna (åtskida med mellanslag), som skickas till programmet. Huvudfilen "string.h" inkluderas till programmet att få tillgång till funktionen "strcat" som används för att lägga en texsträng (den andra) till en annan (den första, "målsträngen"), i det här fallet meddelandetexten och sökvägen. Resultatet av operationen skickas sedan direkt som ingångsparameter till funktionen "printf" för utskrift.

Se även: Exemplet "Hej världen" ovan.

Skriv

#define TITEL       "Skriv (echo), för ANSI-C."

#include <stdio.h>
#include <string.h>

int main ( int argc, char * argv[] )
{
    if ( argc != 2 )
        printf ( "Fel antal argument!\n" );
    else
        printf ( strcat ( "\n", strcat ( argv[1], "\n" ) ) );

    return ( 0 );
}

Skriv, programmet skiljer sig från "Sökväg" främst i det avseedet att ett feltest uförs i en "if(operand)" sats där "operand" är ("argc" != 2) vilket innebär att en test utförs på operand 1 om den inte (!) är likamed (=) operand 2, i det här fallet siffran två. Programmet används efter kompilerning som kommando i en kommandotolk (eller i en *.BAT fil) för att skriva ut textsträngar till den aktuella strömmen (vanligtvis skärmen). Antag att programmet har kompilertas till filnamnet "Skriv.EXE", kommandots syntax är då "Skriv.EXE sträng" med ett mellanslag som skiljetecken mellan kommandot och argumentet (textsträngen). Om strängen innehåller flera ord så måste den omges med citattecken = "Sträng med flera ord." annars kommer orden tolkas som separata argument och "argc" kommer vara satt till 1 + "antal ord" vilket kommer att ha till följd att felmedelandet "Fel antal argument" kommer att skrivas ut i stället för den önskade strängen.

Se även: Dom två exemplen ovan som beskriver övriga funktioner hos koden.

Beräkna

#define TITEL 	"Beräkna, för ANSI-C."

#include <stdio.h>
#include <stdlib.h>

int main ( int argc, char * argv[] )
{
    double resultat, operand1, operand2;

    if (argc == 4)
    {
        operand1 = atof ( argv[1] );
        operand2 = atof ( argv[3] );
        printf ( "\n%f ", operand1 );
        switch(argv[2][0])
        {
            case '+' :
                printf ( "+ " );
                resultat = operand1 + operand2;
            break;
            case '-' :
                printf ( "- " );
                resultat = operand1 - operand2;
            break;
            case '*' :
                printf ( "* " );
                resultat = operand1 * operand2;
            break;
            case '/' :
                printf ( "/ " );
                resultat = operand1 / operand2;
            break;
            default :
                printf ( "Illegal operator!\n" );
                return ( 0 );
        }
        printf ( "%f ", operand2 );
        printf ( "= %f \n",  resultat );
    }
    else
        printf ( "Fel antal argument!\n" );

    return (0);
}

Beräkna, programmet skiljer sig från "Skriv" främst i det avseedet att minne reserveras för tre flyttalsvariabler av typen "double". Variablerna används för att utföra beräkningen på operanderna som skickas till programmet (kommandot) från kommandotolken. Kommandot är "Beräkna.EXE operand operator operand" (förutsatt att det kompilerade programmet lagrats i en fil med namnet "Beräkna.EXE"), där "operator" är något av det fyra räknesätten och "operand" är ett flyttal. Programmets funktion är sedan att först testas om antalet argument stämmer. Sedan används funktionen "atof" för att omvandla ASCII repersentationen av dom inmatade flyttalen i "argv[1]" och "argv[3]" till ett binärt format. Resultaten sparas i flyttalsvariablerna "operand1" och "operand2". "atof" finns definierad i "stdlib.h" som inkluderats längere upp i källoden. Sedan skrivs första ledet i beräkningen ut till I/O-strömmen. För att testa om det första tecknet i "argv[2]" är något av tecknen för dom fyra räknesätten så brukas en switchsats. I casesatserna så anges ASCII-koderna för dom önskade teknen med enkla citattecken ('), skulle dubbla (") använas skapas i stället en pekare till en sträng som innehåller tecknet vilket inte är tillåtet då "case" endast använder konstanter. Om tecknet hittas så skrivs det ut till strömmen och själva beräkningen utförs med rätt operator och resultatet sparas i variabeln "resultat". Hittas ingen giltig operator så skrivs ett felmedelande ut och programmet avslutas. Slutligen skrivs andra ledet i beräkningen och sedan resultatet därav ut till strömmen.

Se även: Dom tre exemplen ovan som beskriver övriga funktioner hos koden.

Summa

#define TITEL 	"Summa, för ANSI-C."

#include <stdio.h>
#include <string.h>

double main ( void )
{
   double summa = 0.0, belopp = 0.0;

   printf ( strcat ( "\n", TITEL ) );
   printf (" Summerar flyttal, (0 avslutar).\n" );
   do
   {
      printf ( "\n   Summa  : %f", summa += belopp );
      printf ( "\n   Addera : ");
      scanf ( "%lf", &belopp );
   } while ( belopp != 0.0 );

   printf ( "\nSlutsumma : %f \n", summa );
   return ( summa );
}

Summa, programmet skiljer sig från övriga i och med att det har en slinga (loop) samt att det inte tar några ingångsparametrar. I stället så matas beloppen som skall summeras in ett efter ett och det avbryts först när användaren skriver in en nolla. Funktion: Först skapas två flyttalsvariabler, summa och belopp, som båda sätts till noll. sen skrivs programmets titel och en liten text om dess funktion ut. Därefter kommer en do-while slinga. Den inleds med att summan skrivs ut men först adderas "belopp" inom parentesen för printf. Finessen är att det är möjligt att tilldela ett resultat av en beräkning till flera olika poster om dom skrivs i serie: var0 = var1 = 1+2. I det här fallet sätts summan till summa + belopp i en sammansatt tilldelning och sedan skickas värdet av summa till "printf" för utskrift. Nästa rad skriver ut en 'promt' där användaren kan mata in nästa värde som skall adderas. Inmatningen av strängen, som sedan omvadlas till ett flyttal och sparas i variabeln "belopp" görs med funktionen "scanf" i raden efter. Slingan avslutas sedan med ett villkor i "while" funktionen. While återgår till slingans start om villkoret är uppfyllt annars avbryts den och raden efter utförs. Här testas om "belopp" inte är lika med noll. Har användaren matat in en nolla skrivs slutsumman ut och programmet avslutas med att summan returneras till det anropande programmet. Uppfylls villkoret däremot så upprepas slingan och en ny inmatning kan ske.

Se även övriga exempel ovan.

Multiplikation av två komplexa tal

#include <math.h>
#include <stdio.h>

int main( void )
{
    float X;
    float Y;
    float O;
    float P;
    float NX;
    float NY;

    puts ( "\n *** Komplex multiplikation. ***\n" );
    puts ( "Separera posterna med mellanslag ' '" );
    puts ( "Använd decimalpunkt '.', inte komma ','" );

    printf ( "\nMata in det första talets real och imaginärdel Z = [ X, Y ] ? " );
    scanf ( "%f%f", &X, &Y );
    printf ( "Det första talets absolutbelopp är : %f \n", sqrt ( X * X + Y * Y ) );

    printf ( "\nMata in det andra talets real och imaginärdel Q = [ O, P ] ? " );
    scanf ( "%f%f", &O, &P );
    printf ( "Det andra talets absolutbelopp är : %f \n", sqrt ( O * O + P * P ) );

    NX = X * O - Y * P;
    NY = X * P + Y * O;

    printf ( "\nResultatet är : Z' = [ %f, %f ]\n", NX, NY );
    printf ( "Resultatets absolutbelopp är : %f \n", sqrt ( NX * NX + NY * NY ) );

    return ( 0 );
}