Tags:    c++

Afsnit 7
Indtil nu har vi brugt typen int til vores tal. Men der findes en del andre typer til tal som det kan være gavnligt at bruge.
Først er der det problem med int at den kun kan bruges til heltal, dvs. en int kan ikke gemme 1,5.

For at kunne gemme decimal tal skal man bruge float, double, eller long double.
Til normal brug er double fin. float fylder ikke så meget i hukommelsen men er mere upræcis. long double er mere præcis end double,
men den fylder mere og er langsommere end double.

Der er et par ting man skal være opmærksom på når man bruger double. Hvis man skriver:

   double d = 11/4;

Ville man måske forvente at d blev 2,75. Det gør den ikke, d bliver 2. Det er fordi både 11 og 4 er heltal, og så regner den
11/4 ud som heltal, runder ned hvilket giver 2, d sættes til denne værdi.

Den letteste måde at løse problemet er at gange med 1,0 inden du regner:

   double d = 1.0*11/4;

Bemærk at vi skriver 1.0 når vi mener 1,0, det er fordi compileren "snakker" engelsk, hvor man bruger punktum i stedet for komma.
Det andet problem med double er at de ikke er uendelig nøjagtige, dvs. der er grænser for hvor mange decimaler den kan gemme efter ,

Og endelig er der et problem med udskrivning, hvis du har:

double d = 11.0/9.0;
std::cout << d << std::endl;

Så vil den nok skrive noget i stil med
1.2222
Hvilket kan være fint, men somme tider vil man gerne have den til at skrive flere eller færre decimaler.
Dette kan vi styre med std::setw og std::setprecision, f.ex:

#include <iostream>
#include <iomanip>
int main()
{
   double d = 11.0/9.0;
   std::cout << std::setw(4) << std::setprecision(3) << d << std::endl;
}

Som vil skrive:
1.22

Også til heltal er der andre typer end int. Der er faktisk en hel række, her listet med min og max værdi:
char -128 - 127
unsigned char 0 – 255
short -32768 - 32767
unsigned short 0 – 65536
int -2147483648 – 2147483647
unsigned int 0 - 4294967296
long -2147483648 – 2147483647
unsigned long 0 - 4294967296

Det ses at unsigned typerne ikke kan have negative tal, dvs tal mindre end 0.

Det er ikke garanteret at int kan have så store tal, det er ikke garanteret at de kan have tal der er større end dem der gælder for short.

Den væsentligste grund til at man ikke altid bruger den største type er at spare på pladsen i computerens hukommelse.

char er også den type der bliver brugt til at gemme bogstaver i, i f.eks. en std::string, men de kan også bruges til at gemme små tal.

Det betyder at man skal passe på når man vil skrive dem ud, for cout tror at man vil udskrive et bogstav og ikke et tal når man udskriver dem.
Prøv f.eks. at køre:

#include <iostream>
int main()
{
   char a = 72;
   char b = 69;
   char c = 74;
   std::cout << a << " " << b << " " << c << std::endl;
}

Den vil nok skrive H E J, fordi den opfatter a, b, c som bogstaver.
Hvis vi vil have den til at skrive tallene skal vi bede om at få dem skrevet som f.eks. short:

   std::cout << short(a) << " " << short(b) << " " << short(c) << std::endl;

Hvis du vil have ét bogstav i din kode skal du skrive dem som 'A', dvs. med ' omkring, lidt på samme måde som med strenge, f.ex:

   char ch = '@';

Den sidste type jeg vil nævne nu er bool. En bool kan kun have to værdier; false eller true. false er 0, true er 1, det kan man se ved at forsøge at skrive dem ud. false er falsk, true er sand.
Man kan f.eks. bruge bool med:

   bool flag = false;
   int i;
   std::cin >> i;
   if(i > 10)
      flag = true;

Her sættes flag til true hvis i er større end 10. Vi kunne også skrive det som:

int i;
std::cin >> i;
bool flag = i > 10;

Det virker fordi udtrykket i > 10 giver en bool som resultat.

Opgaver:
Prøv at se hvad der sker hvis du laver:

   unsigned int i = 0;
   i--;

Og udskriver i
Hvad sker der hvis du laver:

   unsigned short a = 10000;
   a *= 10000;

Og udskriver a?
Hvad sker der med:

   double d = 11.0/2;
   int a = d;

hvis du udskriver a og d?

Afsnit 8
Vi skal lige se lidt mere på læsning fra tastatur, da det kan være ret besværligt, og kan give mange problemer.
Hvis vi f.eks. ville læse et tal, et bogstav og et navn ville man måske bruge:

#include <iostream>
#include <string>
int main()
{
   int tal;
   char bogstav;
   std::string streng;
   std::cin >> tal;
   std::cin >> bogstav;
   std::getline(std::cin, streng);
   std::cout << tal << std::endl << bogstav << std::endl << streng << std::endl;
}

Men det virker ikke, for at forstå hvorfor er vi nød til at forstå lidt mere om hvad der sker.

Først læser vi et tal, så programmet vil læse fra tastaturet så længe brugeren skriver tal, når han så trykker Enter, vil den stoppe med at læse ind i tal.

Men karakteren "ny linie", som programmet modtog da brugeren trykkede Enter sidder stadig og venter på at blive læst.

Når vi så vil læse bogstav bliver dette tegn puttet ind i bogstav. streng vil dog blive læst korrekt.

Vi kan delvist løse problemet ved at putte denne linie ind efter linjen der læser tal:

   std::cin.ignore(1024, '\\n');

Denne linie vil smide op til 1024 tegn væk, eller indtil den møder "ny linie", og så vil resten af programmet (delvist) virke.

Det næste problem er at der måske sidder et "ny linie" bogstav i bufferen når vi vil læse streng.

For at løse dette problem er vi nød til at læse en hel streng når vi vil læse bogstav, og så tage det først bogstav i streng:

   std::string Temp;
   std::getline(std::cin, Temp);
   if(Temp.empty())
      bogstav = '\\n';
   else
      bogstav = Temp[0];

if/else delen sikrer at det går godt selv om brugeren bare trykker Enter. Temp[0] er det første bogstav i Temp.

Alt i alt vil det skudsikre program se sådan ud:

#include <iostream>
#include <string>
int main()
{
   int tal;
   char bogstav;
   std::string streng;
   std::cin >> tal;
   std::cin.ignore(1024, '\\n');
   std::string Temp;
   std::getline(std::cin, Temp);
   if(Temp.empty())
      bogstav = '\\n';
   else
      bogstav = Temp[0];
   std::getline(std::cin, streng);
   std::cout << tal << std::endl << bogstav << std::endl << streng << std::endl;
}

De to regler som du kan lære af dette er:
1: Put denne linie ind mellem linjer der læses med >> og linjer der læses med getline:
std::cin.ignore(1024, '\\n');
2: Når du skal læse et enkelt bogstav, så læs en std::string og tag det første bogstav.

Opgave
Lav et program der beder brugeren om to tal, og derpå skal han skrive et bogstav for at fortælle om de to tal skal
lægges sammen, trækkes fra hinanden, osv. Dette skal programmet så gøre og skrive resultatet ud.

Afsnit 9
Vi så tidligere at man kunne lave løkker med for(), er findes to andre måder at laver løkker på, dem skal vi kikke lidt på her.
Den første løkke hedder do-while, og ser sådan ud:
do
{
kode
}
while(betingelse);
Kode vil blive udført så længe betingelse er sand.

Hvis man vil have brugeren til at skive et tal der er større end 1000, og vil spørge igen og igen indtil han gør det, kunne man bruge:

   int tal;
   do
   {
      std::cout << "Skriv et tal der over 1000: ";
      std::cin >> tal;
   }
   while(tal <= 1000);

Den anden løkke hedder bare while og ser sådan ud:
while(betingelse)
{
kode
}
Bemærk at der ikke er ; efter while()

Igen hvis vi vil have et tal der større end 1000, men vil fortælle brugeren at han har tastet forkert hvis han skriver noget der ikke er større end 1000 kunne man bruge:

   int tal;
   std::cout << "Skriv et tal der over 1000: ";
   std::cin >> tal;
   while(tal <= 1000)
   {
      std::cout << "Tallet er for lille, proev igen: ";
      std::cin >> tal;
   }

Forskellen på do-while og while løkker er at do-while altid udfører kode delen mindst én gang, mens while ikke altid udfører løkken, i eksemplet ovenfor vil while løkken ikke køres hvis brugeren inden har skrevet et tal der er større end 1000.

Opgaver:
1: Lav programmet der skrev den lille tabel om så det bruger while.

2: Lav det så det bruger do-while.

3: Et lille spil. Programmet skal vælge et tal som brugeren skal gætte.
Det skal fungere ved at brugeren skriver et tal, så skal programmet skrive om det er mindre eller større
end det tal der skal gættes og brugeren skal skrive et nyt tal,
hvis det er det rigtige tal skal programmet skrive at det var det rigtige tal,
og hvor mange gæt brugeren brugte til at gætte tallet.
For at finde et tilfældigt tal skal du bruge rand(), følgende vil give et tilfældigt tal mellem 0 og 99:

   int tal = rand()%100;

For at undgå at programmet vælger det samme tilfældige tal skal du bruge srand:

    srand(time(0));

Du skal inkludere time.h og stdlib.h. Et eksempel, der vil skrive et tilfældigt tal mellem 0 og 99:

#include <iostream>
#include <time.h>
#include <stdlib.h>
int main()
{
   srand(time(0));
   int tal = rand()%100;
   std::cout << tal << std::endl;
}

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