Tags:    c++

Afsnit 13
Udover at regne er det at arbejde med strenge en af de ting programmet oftest gør, så vi må hellere se lidt mere på hvordan man arbejder med strenge.
Vi har allerede set på at man kan holde en streng i en variabel af typen std::string:

   std::string S = "Hej Der";

Vi kan også sætte strenge sammen:

   std::string S = "Hej";
   S += " Der";

S vil så indeholde "Hej Der".
Men hvis vi har:

int x = 12;

Og gerne vil have S til at indeholde "x = 12", hvad gør man så. Man kunne skrive:

   std::string S = "x = ";
   S += x;

Men det virker ikke. Det er fordi x er en int og man kan ikke lægge en int til en std::string.
Så vi skal selv lave denne int om til en std::string og derpå lægge dem sammen.
Løsningen er at bruge en std::stringstream.

#include <iostream>
#include <string>
#include <sstream>
int main()
{
   std::stringstream SS;
   int x = 12;
   SS << "x = " << 12;
   std::string S = SS.str();
   std::cout << S << std::endl;
}

En stringstream bruges ca. på samme måde som std::cout, dvs man skriver til den med <<.
Men hvor std::cout skriver på skærmen, gemmer en stringstrem det man putter i den i en std::string.
Denne kan man så hente med SS.str().
Men da vi ofte vil få brug for at lave en int om til en std::string var det måske en god idé at lave det med en funktion:

std::string ToString(int n)
{
   std::stringstream SS;
   SS << n;
   return SS.str();
}

For så kan man skrive:

int main()
{
   std::string S = "x = ";
   int x = 12;
   S += ToString(x);
   std::cout << S << std::endl;
}

Hvilket vist er noget kønnere, eller man kan skrive det lidt kortere:

   std::string S = "x = " + ToString(x);

Men hvad så med double, short og andre typer? Som du så før er der noget der hedder template funktioner, så det ville være logisk at lave ToString om til at være en template funktion, så den kan håndtere alle typer:

template<typename T>
std::string ToString(T n)
{
   std::stringstream SS;
   SS << n;
   return SS.str();
}

Og der er jo ret elegant.
Men hvad så med den modsatte vej, hvis man har:

   std::string S = "123";

Og gerne vil have int x til at være 123? Igen er std::stringstream løsningen:

   std::string S = "123";
   std::stringstream SS(S);
   int x;
   SS >> x;
   std::cout << x << std::endl;

Men der er en ting som vi lige skal være opmærksomme på. Alle tal kan laves om til en std::string, men det er ikke alle std::string der kan laves om til et tal.
Hvis den f.eks. indeholder "Hej der", kan man jo ikke lave det om til et tal.
Heldigvis fortæller >> om det gik godt:

   bool Success = SS >> x;
   if(Success)
      std::cout << x << std::endl;
   else
      std::cout << "Det var ikke et tal: " << S << std::endl;

Og da vi jo er i gang med at lave template funktioner var det nok en god ide at lave en:

template<typename T>
bool FromString(T& tal, const std::string& str)
{
   std::stringstream SS(str);
   return SS >> tal;
}

Denne funktion konverterer str til et tal, og returnerer true hvis str indeholder et tal.
Vi kan så bruge den med:

   std::string S = "123";
   int x;
   if(FromString(x, S))
      std::cout << x << std::endl;
   else
      std::cout << "Det var ikke et tal: " << S << std::endl;

Det kan næsten ikke blive lettere.

Vi har set at det er ret let at sætte strenge sammen, men hvordan splitter man dem så ad?
For at kunne det har vi brug for to ting: At vide hvor vi vil splitte, og en måde hvorpå vi kan tage en del af en std::string.
Det første kan gøres med en af std::string's mange finde funktioner.
En af dem er find, som finder det første tegn af en type i strengen. Et eksempel:

   std::string S = "Hej Du Der";
   std::string::size_type n = S.find(' ');
   if(n != std::string::npos)
      std::cout << "Fandt et mellemrum paa position: " << n << std::endl;

Da det første mellemrum i "Hej Du Der" er på plads 3, idet vi tæller fra 0, vil n blive sat til at være 3.
Hvis ikke der var mellemrum i S ville n blive sat til at være std::string::npos.

Vi kan bruge rfind på samme måde til at finde det sidste tegn i strengen.
rfind vil i vores eksempel give 6, da det sidste mellemrum er på plads 6.

På samme måde kan man bruge find_first_of("aeoiyu") til at finde den første vokal i strengen, og find_last_of("0123456789") til at finde det sidste tal i strengen.

Hvis vi vil finde et ord i strengen kan man bruge find("ord") eller rfind("ord").
Når man søger skelnes der mellem store og små bogstaver.

Hvis vi nu vil have det første ord i S over i en anden variabel kan man bruge:

   std::string S = "Hej Du Der";
   std::string::size_type n = S.find(' ');
   if(n != std::string::npos)
   {
      std::string S2 = S.substr(0, n);
      std::cout << S2 << std::endl;
   }

substr giver en del af strengen fra en plads, i dette tilfælde 0, og et antal bogstaver frem, i dette tilfælde n, som vi før så var 3.
Så S2 bliver sat til at være "Hej".

Hvis vi vil have resten af strengen fra det første mellemrum kan vi skrive:

      std::string S3 = S.substr(n + 1);

Vi lægger 1 til n for at springe mellemrummet over. Da vi kun bruger én parmeter i kaldet til substr får vi resten.

Opgaver
1: Lav regnemaskinen om så regnestykket læses som én streng, f.eks. "123 + 321".
Du skal så splitte denne streng op i tre, det første tal, +-* eller / og det andet tal.
Du kan bruge den FromString funktion som vi lavede før, til at lave disse tal om til int.

2: Vi så tidligere at det ikke var nogen god ide at bruge >> til at læse tal med, hvis brugeren skrev noget der ikke var et tal.
Løsningen på det problem er at bruge std::getline til at læse en std::string, og så bruge samme metode som i FromString til at
lave dette om til et tal.
Lav derfor en template funktion der gør dette.
Den kommer til at ligne FromString men tager kun et argument, det tal som der bliver læst.

Afsnit 14
Fra tid til anden har man brug for at give ting numre, det kunne f.eks. være ugedage, hvor mandag kunne være nummer 0,
tirsdag nummer 1, osv. Man kan selvfølgelig gå og huske på hvad der er hvad, men der findes en mere elegant løsning:

enum UgeDag
{
   mandag,
   tirsdag,
   onsdag,
   torsdag,
   fredag,
   loerdag,
   soendag
};

Dette hedder en enum, som er en forkortelse af enumeration, der betyder noget i retning af "optælling".
I dette eksempel vil mandag være 0, tirsdag 1, osv. Vi kan bruge dette i vores kode:

   int Dag = mandag;
   if(Dag == onsdag)

UgeDag fra vores eksempel er faktisk en ny type, så man kan også skrive:

UgeDag Dag = fredag;

Hvilket kan være meget praktisk.
Hvis man ikke gør noget specielt for de enkelte værdier i en enum bare fortløbende numre.
I nogle tilfælde kan det være praktisk at give dem specielle værdier.
Hvis vi f.eks. vil gøre en ting for alle ugedage kunne man skrive:

   int i;
   for(i = mandag; i <= soendag; i++)
      Whatever(i);

Men det forudsætter at vi husker på at mandag er den første dag i ugen, og søndag den sidste.
Man kan løse det ved at tilføje to værdier til enum'en:

enum UgeDag
{
   Mandag,
   Tirsdag,
   Onsdag,
   Torsdag,
   Fredag,
   Loerdag,
   Soendag,
   FoersteUgeDag = Mandag,
   SidsteUgeDag = Soendag
};

For så kan man skrive:

   int i;
   for(i = FoersteUgeDag; i <= SidsteUgeDag; i++)
      Whatever(i);

Nu sidder du måske og tænker, hvorfor bruge han ikke UgeDag som type for i?
Men det virker ikke, fordi ++ ikke virker med enum's.
Man kan også give de enkelte værdier i enum'en en talværdi:

enum DageIMaaned
{
  DageIJanuar = 31,
  DageIFebruar = 28,
  DageIFebruarSkudAar = 29,

Enum kan antage alle heltals værdier.

Hvis man skulle skrive en funktion der udskriver navnet på en ugedag, kunne man skrive koden som:

void SkriveUgedag(UgeDag dag)
{
   if(dag == mandag)
      std::cout << "mandag";
   else if(dag == tirsdag)
      std::cout << "tirsdag";

Og så videre. Men der er en mere elegant måde at gøre det på:

void SkriveUgedag(UgeDag dag)
{
   switch(dag)
   {
   case mandag:
      std::cout << "mandag";
      break;
   case tirsdag:
      std::cout << "tirsdag";
      break;
   }

Det kaldes en switch, det fungerer på den måde at man hopper fra switch'en til den case som passer med det man switcher på.
Og udfører koden indtil den møder break, så hopper den ud.

Man kan switch'e på alle heltal, også bogstaver:

   char ch = GetBogstav();
   switch(ch)
   {
   case 'j';
      std::cout << "Ok" << std::endl;
      break;
   case 'n';
      std::cout << "Naa ikke" << std::endl;
      break;
   default:
      std::cout << "Det forstod jeg ikke" << std::endl;
      break;
   }

I dette tilfælde vil den hoppe til default hvis ikke ch er j eller n.

Man kan lave alt det kode man vil efter case, det behøver ikke kun være en linie.
I nogle tilfælde springer man break over:

   int n;
   GetTal(n);
   switch(n)
   {
   case 2;
      std::cout << "Hej Verden" << std::endl;
   case 1;
      std::cout << "Hej Verden" << std::endl;
      break;
   case 0:
      break;
   default:
      std::cout << "Det forstod jeg ikke" << std::endl;
      break;
   }

Her vil den skrive "Hej Verden" to gang hvis n er 2, 1 gang hvis den er 1, 0 gange hvis den er 0, og "Det forstod jeg ikke" i alle andre tilfælde.
Men som regel er det en forglemmelse hvis ikke der står break, så husk det nu.

Opgvave
Lave en enum for de fire regnearter. Lav regneprogrammet om så det laver bogstavet for regnearten om så det bruger denne enum.
Du kan lave det så plus = '+', så behøver du ikke oversætte.
Brug så en switch til at vælge hvilket regnestykke der skal laves.

Afsnit 15
Vi har set på hvordan man kan oprette variable til at indeholde ét tal eller én streng.
Men ofte har man brug for flere af disse for at beskrive en "ting".
Hvis vi f.eks. arbejder med grafik på en flade, ville vi bruge en x og en y til at beskrive et punkt.
Ville vi lave en telefonbog skulle den mindst indeholde navn og telefon nummer.
Den simple måde at samle sådan information i C++ er vha. en struct.
Hvis vi tager eksemplet med punktet fra før kunne man gøre det på denne måde:

struct Punkt
{
   int x;
   int y;
};

Her har vi lavet en ny type kaldet Punkt, der indeholder to variable, x og y.
Vi kan så oprette en variabel af denne type:

   Punkt p;

p er her variablen, man siger også at p er et objekt.
Vi kan nu få fat i p's x og y med .

   Punkt p;
   p.x = 123;
   p.y = 321;
   std::cout << p.x << ", " << p.y << std::endl;

Man siger at x og y er medlemmer af Punkt, eller medlems variable.
Variabler af typen Punkt opfører sig på samme måde som andre variabler:

#include <iostream>
struct Punkt
{
   int x;
   int y;
};
void Skriv(const Punkt& p)
{
   std::cout << p.x << ", " << p.y << std::endl;
}
int main()
{
   Punkt p1 = {2, 5};
   Punkt p2;
   p2.x = 2;
   p2.y = 5;
   Skriv(p1);
   p2 = p1;
   Skriv(p2);
}

Bemærk måden vi tilskriver p1 dens værdi, man skriver værdierne i samme rækkefølge som de står i struct'en.
Vi kan også sætte den ene til at være lig den anden, men vi kan ikke umiddelbart sammenligne dem med ==

Skulle vi lave en telefonbog kunne vi lade hver opslag se sådan ud:

struct Entry
{
  std::string Navn;
  unsigned int Nummer;
};

Selv om man nok i praksis vil bruge en std::string til nummer, for at det kan indeholde mellemrum og andre special tegn.

Der er også en standard struct det er rart at kende, den kaldes tm, og bruges til at holde styr på et tidspunkt.
Den kan bruges med:

#include <iostream>
#include <time.h>
int main()
{
   tm Time;
   memset(&Time, 0, sizeof(Time));
   Time.tm_mday = 12;
   Time.tm_mon =  6;
   Time.tm_year = 2006 - 1900;
   Time.tm_hour = 11;
   Time.tm_min = 10;
   Time.tm_sec = 0;
   std::string Tid = asctime(&Time);
   std::cout << Tid << std::endl;
}

Time er objektet af typen tm. memset bliver brugt til at nulstille den, det er nødvendigt, ellers vil programmet (måske) bryde ned når du kører det.

De næste linier bliver brugt til at sætte de enkelte fælter i Time. Bemærk at den regner år 1900 som år 0, så du skal trække 1900 fra årstallet for at få det rigtige resultat.

tm_mday er dag i måned, første dag er 1. tm_mon er måned, første måned, januar, er, sært nok, 0.

Kaldet til asctime laver tiden i tm format om til en streng, denne udskrives, resultatet kunne se sådan ud:
Sun Jul 12 11:10:00 2006

Man kan beregne forskellen på to tider i tm format, vha. difftime funktionen, men først skal man lave tiden om til time_t format:

   tm Time1;
   tm Time2;
   time_t t1 = mktime(&Time1);
   time_t t2 = mktime(&Time2);
   double diff = difftime(t1, t2);
   std::cout << diff << std::endl;

Forskellen er i sekunder.
Man kan hente den nuværende tid vha. time, man får tiden i time_t format:

   time_t t1;
   time(&t1);

Man kan lave denne time_t om til en tm med localtime:

   tm Time1 = *localtime(&t1);
   std::cout << asctime(&Time1) << std::endl;

Dvs localtime laver det modsatte af mktime.

Hvis du undrer dig over hvad de & der bruges i diverse kald og * foran localtime betyder, så må du indtil videre nøjes med at vide at de skyldes at der arbejdes med pointere.
Jeg skal nok forklare dem senere.
Opgave
Lav en funktion der beder brugeren om at indtaste sin fødselsdag, og få så programmet til at skrive hvor mange sekunder og timer han er gammel.
Det vil nok være praktisk at lave en funktion der beder brugeren om fødselsdag, og så lave resten i en anden funktion.



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

Del også gerne artiklen med dine Facebook venner:  

Karma barometer (30 dage)

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

X