F¨orsta C/C++ f¨orel¨asningen
Jag g˚ar igenom s˚a l˚angt jag hinner av f¨oljande inneh˚all:
• Kompilering, exekvering
• Lite om variabler, typer.
• Lite om l¨asning och skrivning (I/O)
• if-sats, while-sats
Programmering i C
F¨orsta programmet:
Nedan finns ett f˚anigt litet program som l¨aser in tv˚a tal (sannolikheter) och som skriver ut produkten av dessa. I Matlab ser programmet ut s˚a h¨ar:
p1 = input(’Sannolikhet f¨or att Fido uppt¨acker tjuv ’);
p2 = input(’Sannolikhet f¨or att Fido skr¨ammer tjuv ’);
disp(’Fido uppt¨acker och skr¨ammer tjuven’) p = p1*p2;
disp(p);
I C++ ser samma program ut s˚a h¨ar:
#include <iostream>
using namespace std;
int main() {
double p1, p2, p;
cout << "Sannolikhet f¨or att Fido uppt¨acker tjuv ";
cin >> p1;
cout << "Sannolikhet f¨or att Fido skr¨ammer tjuv ";
cin >> p2;
p = p1*p2;
cout <<"Fido uppt¨acker och skr¨ammer tjuven "<<p<<endl;
return 0;
}
N˚agra detaljer i C-programmet:
• Sj¨alva spr˚aket C/C++ inneh˚aller inga speciella konstruktioner f¨or att l¨asa och skriva data, men det finns speciella bibliotek (inkluderings- filer) med hj¨alpmedel f¨or l¨asning och skrivning. En s˚adan inkluder- ingsfil ¨ar iostream Den f¨orsta raden i koden
#include <iostream>
betyder att inkluderingsfilen iostream ska inkluderas i programmet.
(Det finns m˚anga inkluderingsfiler - och man m˚aste l¨asa manualer etc.
f¨or att veta vilka man ska inkludera.)
Alla deklarationer som finns i standardbiblioteken g¨ors i en sk. nam- nrymd som heter std. P˚a andra raden i programmet ovan
using namespace std;
g¨ors alla standardeklationer direkt tillg¨angliga i programmet.
(Om man vill se vad filen iostream inneh˚aller (det vill man normalt inte) s˚a hitter man den i filsystemet (linux) under
/usr/include/c++/version/iostream,
d¨ar version m˚aste ers¨attas med den version av c-kompilator man anv¨ander)
• Ett C/C++ program m˚aste inneh˚alla exakt en funktion med namnet main, och n¨ar man k¨or programmet kommer exekveringen att starta i denna funktion. De tomma parenteserna efter main anger att funk- tionen saknar parametrar. Ordet int som st˚ar framf¨or main anger att funktionen returnerar ett v¨arde av typen int (heltal).
• P˚a 4:e raden st˚ar en v¨ansterklammer { och p˚a sista raden en h¨ogerk- lammer }. Dessa tecken anger var kroppen till funktionen b¨orjar re- spektive slutar. Precis som i Matlab utf¨ors rad f¨or rad (med start i main) i programmet n¨ar det k¨ors.
• P˚a 5:e raden st˚ar
double p1, p2, p;
Det ¨ar en variabeldeklaration. I C/C++ m˚aste man deklararera alla variabler man t¨anker anv¨anda (i Matlab beh¨ovdes inte detta). Man talar d˚a om vilken typ variabeln ska ha och vad den ska heta. P˚a raden ovan deklareras 3 variabler (p1, p2 och p). Alla tre ska vara av typen double, dvs decimaltal.
• F¨or att skriva ut p˚a terminalen anv¨ands cout.
cout << "Sannolikhete f¨or att Fido uppt¨acker tjuv ";
anger att texten Sannolikhet f¨or att Fido uppt¨acker tjuv ska skrivas ut p˚a terminalen. H¨ar anv¨ands utskriftsoperatorn << som finns i iostream. Utskriften sker till cout som ¨ar en f¨ordefinerad sk utmatningsstr¨om. Det som matas ut p˚a denna str¨om kommer automa- tiskt att skrivas i ett textf¨onster p˚a bildsk¨armen.
• F¨or att l¨asa in data fr˚an tangentbordet anv¨ands cin. Man anv¨ander inmatningsoperatorn >> f¨or att l¨asa indata fr˚an inmatningsstr¨ommen cin till variabler.
cin >> p1;
betyder att programmet v¨antar tills anv¨andaren skriver ett tal p˚a ter- minalen (f¨oljt av enter), och detta tal l¨ases in till variabeln p1.
• Satsen
p = p1*p2;
ser ut precis som i Matlab (och betyder ocks˚a samma sak). Det ¨ar en tilldelningssats, variabeln p tilldelas v¨ardet av p1*p2.
• Om man vill skriva ut flera saker i samma utmatningssats g˚ar detta bra.
cout <<"Fido uppt¨acker och skr¨ammer tjuven "<<p<<endl;
betyder att texten Fido uppt¨acker och skr¨ammer tjuvf¨oljt av v¨ardet p˚a p ska skrivas ut. Ordet endl ¨ar en s.k. manipulator som anger att mark¨oren p˚a sk¨armen ska flyttas fram till en ny rad efter utskriften.
• P˚a n¨ast sista raden i programmet st˚ar return 0;
Det ¨ar en return-sats. Denna anger att exekveringen av funktionen ska avslutas (V¨ardet 0 indikerar att exekveringen avslutats p˚a ett normalt s¨att).
• Observera att alla satser avslutas med semikolon (;). I Matlab var det valfritt att avsluta satserna med semikolon. I C/C++ m˚aste man avsluta satserna med semikolon.
• N¨ar man programmerar i C (och inte C++) skriver man ist¨allet
#include <iostream.h>
p˚a f¨orsta raden. Det betyder (precis som i C++) att inkluderingsfilen iostream.h ska inkluderas i programmet.
Kompilering och exekvering
Matlab ¨ar interaktivt och kan exekvera ett program direkt. Detta ¨ar inte fallet med C/C++. F¨orst m˚aste man anv¨anda en editor f¨or att skriva in koden, man man m˚aste sedan anv¨anda en kompilator f¨or att l˚ata ¨overs¨atta programmet till maskinkod innan det kan k¨oras. F¨orst n¨ar man ¨oversatt hela programmet kan det k¨oras.
F¨or att skriva in koden kan man tex anv¨anda matlabs editor (eller n˚agon annan editor om man k¨anner till n˚agon s˚adan. Det finns ett par stycken olika editorer installerade p˚a datorerna i labsalen). I Matlab m˚aste pro- gramfilerna sluta p˚a .m f¨or att Matlab ska kunna k¨ora dem. I fallet med c-program m˚aste filnamnet sluta p˚a .c eller .cc
Antag vi skapat en fil som heter fido.c som inneh˚aller programkoden ovan.
S˚a h¨ar ¨overs¨atter man programmet till maskinkod (kompilerar):
g++ fido.c
g++¨ar namnet p˚a kompilatorn. Om man inte skrivit r¨att (dvs f¨oljt C/C++’s syntax) kommer kompilatorn att ge felutskrifter. Man m˚aste d˚a r¨atta dessa, och det ¨ar f¨orst n¨ar alla syntaxfel ¨ar borta som kompilatorn kan
¨overs¨atta programmet till en kod som g˚ar att exekvera (k¨ora). Kompila- torn kommer d˚a att placera det f¨ardig¨oversatta programmet i en fil som heter a.out
g++ fido.c % kompilera
a.out % exekvera
Sannolikhet f¨or att Fido uppt¨acker tjuv 0.6 Sannolikhet f¨or att Fido skr¨ammer tjuv 0.4 Fido uppt¨acker och skr¨ammer tjuven 0.24
(Om man inte har . i sin linux-path beh¨over man skriva ./a.out f¨or att exekvera programmet)
Kompileringsfel
Om man gjort syntaxfel i sin kod och f¨ors¨oker kompilera den f˚ar man kompileringsfel. Kompilatorn kommer att ge felutskrifter. Dessa kan vara t¨amligen sv˚ara att tolka, men man f˚ar f¨ors¨oka s˚a gott det g˚ar.
Ett vanligt nyb¨orjarfel ¨ar att gl¨omma semikolon (eller s¨atta dem p˚a fel st¨alle). Detta ger upphov till m˚anga, ibland sv˚artolkade kompileringsfel:
S˚a h¨ar s˚ag det ut n¨ar jag gl¨omde skriva semikolon efter double p1, p2, p och f¨ors¨oker kompilera f˚ar jag
g++ fido.c
fido.c: In function ’int main()’:
fido.c:6:3: error: expected initializer before ’cout’
cout << "Sannolikhet f¨or att Fido uppt¨acker tjuv ";
^
fido.c:10:3: error: ’p’ was not declared in this scope p = p1*p2;
Ett s¨att att minska m¨angden syntax-fel ¨ar att vara noga med indenteringen av sitt program. C-kompilatorn bryr sig inte om hur man indenterat. I princip kan man skriva sitt c-program p˚a en enda rad. (G¨or Inte det).
#include <iostream>
using namespace std; int main() { double p1, p2, p; cout <<
"Sannolikhet f¨or att Fido uppt¨acker tjuv "; cin >> p1; cout <<
"Sannolikhet f¨or att Fido skr¨ammer tjuv "; cin >> p2; p = p1*p2; cout
"Fido uppt¨acker och skr¨ammer tjuven "<<p<<endl; return 0; }
¨ar t¨amligen ol¨asligt f¨or alla utom en c-kompilator.
Variabler och typer i C/C++
• En variabel ¨ar en enhet som man sj¨alv inf¨or och som man kan tilldela v¨arden. I C/C++ m˚aste man deklarera varje variabel innan man kan anv¨anda den. I en variabeldeklaration anges vilken typ variabeln ska ha och vad den ska heta:
int a = 5;
double x = 3.14;
unsigned char teck;
P˚a f¨orsta raden deklareras en heltalsvariabel med namnet a, p˚a andra raden deklareras en reell variabel x och p˚a tredje raden deklareras en teckenvariabel teck. (Med hj¨alp av tilldelningsoperatorn (=) ges a och x startv¨arden. teck har inte f˚att n˚agot v¨arde).
• F¨or varje variabel man inf¨or reserverar C/C++ ett utrymme i min- net med plats f¨or variabelns v¨arden. Variabeln a ovan kan bara lagra heltalsv¨arden, x kan bara lagra decimaltal (och heltal, som ju ¨ar deci- maltal med decimaldelen 0).
• Varje variabel ges ett namn (ett namn som man hittar p˚a sj¨alv), som man anv¨ander d˚a man refererar till variabeln. Variabelnamn f˚ar best˚a av bokst¨aver (a-z, A-Z), understreck (_) och siffor (0-9).
(Stora och sm˚a bokst¨aver betraktas som olika och variabelnamn f˚ar ej b¨orja med en siffra. Observera ocks˚a att vissa ord ¨ar reserverade och kan inte anv¨andas som variabelnamn (tex. orden if och while ¨ar reserverade)).
• En variabels typtillh¨orighet best¨ammer vilka v¨arden variabeln kan anta. Det finns ett antal inbyggda typer att v¨alja bland:
– F¨or heltal finns typerna: short, int och long
– F¨or decimaltal finns typerna: float, double och long double – F¨or att lagra tecken anv¨ands typen unsigned char
– F¨or sanningsv¨arden finns typen bool. Variabler av typen bool kan anta tv˚a v¨arden; true och false.
• Typdeklarationen int a ovan ger oss ett heltal a (32 bitar). int och doublelagras p˚a olika s¨att internt. De har ocks˚a olika ber¨akningsegen- skaper. Om tex a och b ¨ar tv˚a variabler av typen int s˚a har kvoten a/b ocks˚a ett heltalsv¨arde (alla decimlaer stryks), s˚a kvoten mellan heltalen 3 och 2, 3/2, blir exakt 1. Om man inte vill ha heltalsdivision m˚aste man anv¨anda sig av tex double. Resultatet av 3.0/2 blir 1.5, ett decimaltal. (2 kommer att konverteras till decimaltalet 2.0 f¨ore divisionen utf¨ors).
Det g˚ar bra att hoppa ¨over avsnitten ’Typer f¨or att lagra heltal’, ’Typer f¨or att lagra decimaltal’, ’Typer f¨or att lagra tecken’ och ’Typen bool’ nedan om du vill .
Typer f¨or att lagra heltal
• Egentligen finns det 8 f¨ordefinierade typer f¨or att lagra heltal. De ¨ar indelade i tv˚a grupper - typer med tecken (signed typer som till˚ater b˚ade positiva och negativa tal), samt teckenl¨osa typer (unsigned som bara till˚ater positiva tal). Heltalstype- rna med tecken ¨ar signed char, short int,int och long int. F¨or var och en av dessa fyra finns en motsvarande teckenl¨os typ. De teckel¨osa heltalstyperna ¨ar un- signed char, unsigned short int, unsigned int och unsigned long int. N¨ar man deklarerar variabler av de olika heltalstyperna ¨ar det ibland till˚atet att utel¨amna n˚agra av nyckelorden. Ordet int ¨ar tex. underf¨orst˚att om det utel¨amnas. Detta betyder att om vi skriver
unsigned m;
betyder det samma som unsigned int m;
Vidare g¨aller att ordet signed ¨ar underf¨orst˚att utom f¨or typen char. Tillexempel raden
long n;
¨ar samma som
signed long int n;
F¨or typen char ¨ar det lite oklart. Om man skriver char c;
s˚a vet man inte om variabeln c blir signed eller unsigned. Hur det tolkas beror p˚a den akutella C/C++ installationen man anv¨ander. S˚a om man vill anv¨anda vari- abeln till att lagra teckenkoder ¨ar det d¨arf¨or klokt att deklarera den som unsigned char
• Det som skiljer de olika typerna ˚at ¨ar hur m˚anga bitar som anv¨ands f¨or att lagra talet. Exakt hur m˚anga bitar som anv¨ands f¨or att representera de olika typerna anges inte i C++ standarden, och det kan s˚alunda skilja sig ˚at beroende p˚a vilken C++ installation som man anv¨ander. Ofta g¨aller dock:
– short 16 bitar – int 16 eller 32 bitar – long int 32 eller 64 bitar
• Heltal lagras bin¨art (dvs med ettor och nollor). Varje bit som anv¨ands f¨or att lagra talet kan anta v¨ardet 0 eller 1. L˚at oss titta p˚a ett exempel. Om vi vill lagra talet 23 bin¨art i en signed typ som anv¨ander 16 bitar f˚ar vi f¨oljande bitm¨onster:
0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 – Talet 23 blir 10111 bin¨art.
– Den f¨orsta biten (den l¨angs till v¨anster) anger tecknet p˚a talet, 0 om talet ¨ar positivt och 1 om det ¨ar negativt. De andra 15 bitarna anv¨ands f¨or att lagra sj¨alva talet.
Talet -23 skulle s˚alunda f˚a f¨oljande bitm¨onster 1 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1
Eftersom man anv¨ander ett begr¨ansat antal bitar f¨or att lagra ett tal finns det ett st¨orsta lagringsbara tal. Om man anv¨ander 16 bitar f¨or att lagra ett heltal med tecken (signed) blir det st¨orsta lagringsbara talet 215− 1 = 32767 (st¨orsta negativa tal blir −215). Om man i sitt program f¨os¨oker lagra ett f¨or stort positivt eller negativt tal f˚ar man overflow (talet ”sl˚ar runt” och byter tecken).
Om man ist¨allet anv¨ander en unsigned typ f¨or att lagra heltalet anv¨ands alla bitarna f¨or att lagra sj¨alva talet, och endast positiva tal lagras. Det inneb¨ar att det st¨orsta lagringsbara talet blir 2n om n bitar anv¨ands f¨or att lagra talet.
• Vilken heltalstyp ska man v¨alja n¨ar man deklarerar en variabel? Om man t¨anker anv¨anda variabeln till att r¨akna i brukar man anv¨anda int. Om man vill kunna lagra stora heltal som inte rymms i typen int kan man v¨alja long int. Ska man lagra m˚anga sm˚a heltal kan man spara lite minnesutrymme genom att v¨alja short inteller signed char. De teckel¨osa typerna v¨aljer man n¨ar man vill r¨akna modulo 2n (men ocks˚a f¨or att representera bitm¨onster). Typen char anv¨ander man f¨or att lagra tecken i texter.
• Om man vill veta hur m˚anga bytes (en byte ¨ar 8 bitar) en typ best˚ar av kan man anv¨anda sizeof operatorn. Man skriver sizeof(typnamn). Tillexempel
sizeof (short)
ger antalet bytes som anv¨ands f¨or att lagra en signed short int.
I inkluderingsfilen climits (limits.h i C) finns information om de olika standard- typerna f¨or heltal. H¨ar finns bla. information om typen int. De tv˚a konstanterna INT_MIN
INT_MAX
anger det minsta respektive st¨orsta lagringsbara tal f¨or int.
Typer f¨or att lagra decimaltal
• F¨or att slippa alltf¨or m˚anga nollor n¨ar man anger ett tal som ¨ar mycket stort eller litet anv¨ander man ju ofta exponentform. Talen 350000000 och 0.00000073 skrivs tex som 0.35 · 10 9 och 0.73 · 10−6. Samma teknik anv¨ands vid lagring av reella tal (fast man anv¨ander basen 2 ist¨allet f¨or 10). Det (decimala) talet 10.5 kan ¨overs¨attas till bin¨ar form och blir d˚a 1010.1. Talet kan skrivas
0.10101 · 2100
0.10101 kallas mantissa och 100 kallas exponent. N¨ar ett reellt tal lagras lagras talets tecken (en bit), dess mantissa och exponenten. Antag vi vill lagra det decimala talet 10.5 med 32 bitar. F¨orsta biten anv¨ands f¨or tecknet (0 betyder positivt tal, 1 negativt tal). N¨asta 8 bitar anv¨ands f¨or exponenten och 23 bitar f¨or mantissan. Heltalssiffran i mantissan beh¨over ej lagras eftersom man ser till att den alltid blir 0 (man kan ocks˚a se till att 1:a binalen i mantissan alltid blir 1 och d˚a beh¨over man inte lagra den heller). Vi f˚ar f¨oljande bitm¨onster:
0 00000100 00000000000000000010101
Den f¨orsta 0:an anger talets tecken (positivt), de f¨oljande 8 tecknen anv¨ands f¨or att lagra exponenten (med tecken) och de sista 23 tecknen anv¨ands f¨or att lagra mantissan.
• Det finns, precis som f¨or heltalstyperna, ett st¨orsta och ett minsta lagringsbart tal.
Decimaltal lagras inte alltid exakt utan man har ett visst antal siffrors nogrannhet.
Ofta anv¨ands 32 bitar f¨or float och 64 f¨or double, det inneb¨ar att float ofta ger 6-7 decimalers nogrannhet, och att double ger ca 15 decimalers nogrannhet.
• N¨ar man anv¨ander decimaltal i sitt program ¨ar double den vanligaste typen.
• Precis som f¨or heltalstyper kan man anv¨anda operatorn sizeof f¨or att best¨amma hur m˚anga bytes en typ best˚ar av (se sidan 9). Inkluderingsfilen cfloat (float.h i C) inneh˚aller information om de olika typerna f¨or reella tal.
DBL_DIG DBL_MAX DBL_MIN
ger antal siffrors nogrannhet samt st¨orsta och minsta lagringsbara tal f¨or double.
Typer f¨or att lagra tecken
• Typen char anv¨ands f¨or att lagra tecken. Tecknen lagras som talkoder, vilket inneb¨ar att char i sj¨alva verket ¨ar ¨annu en heltalstyp.
• Den vanligaste standarden f¨or teckenlagring ¨ar ascii-standarden. Varje tal mellan 0 och 127 motsvaras av ett tecken. Tillexempel tecknen ’9’ och ’A’ motsvaras i ascii-standarden av 57 respektive 65.
• Observera att tecknen i typen char lagras som heltal, men i och med att heltalet lagrats i som en char tolkas i vissa fall som tecken.
char teck = ’M’;
Variabeln teck tilldelas tecknet ’M’ (men det lagras som talet 77). Observera att ’ anv¨ands f¨or att markera att det ¨ar ett tecken. Med ’M’ menas tecknet M och med
’9’ menas tecknet 9 (inte siffran 9).
• #include <iostream>
using namespace std;
int main() {
char teck1, teck2;
cout << "Skriv ett tecken ";
cin >> teck1;
teck2 = teck1+1;
cout << " Efter "<< teck1 << " kommer " << teck2 << endl;
return 0;
}
Programmet l¨aser in ett tecken och skriver ut tecknet och det tecken som kommer efter det inl¨asta tecknet i ascii-standarden. En k¨orning ser ut s˚a h¨ar:
Skriv ett tecken A Efter A kommer B
Det intressanta h¨ar ¨ar att vi skriver in ett ’A’ (inte motsvarande teckenkod som
¨ar 65). Programmet skriver ut A och B (inte 65 och 66). ¨And˚a skulle vi hitta 65 om vi tittade efter vad som lagrats i variabeln teck1. Det ¨ar cin och cout som utf¨or omvandlingen mellan tecken och heltal (teckenkod). Vid inmatning omvandlar cintangentnedtryckningen till 65 och vid utmatning omvandlar cout v¨ardet 65 till tecknet A och v¨ardet 66 till tecknet B. Eftersom char egentligen ¨ar en heltalstyp fungerar alla operatorer som finns definierade f¨or heltal (se sidan 13) ¨aven f¨or char.
Det ¨ar d¨arf¨or som satsen teck2 = teck1+1; fungerar.
• F¨oljande program l¨aser in ett tecken och skriver ut motsvarande teckenkod:
#include <iostream>
using namespace std;
int main() { {
char teck;
int teckenkod;
cout << "Skriv ett tecken ";
cin >> teck;
teckenkod = teck;
cout << "Teckenkoden f¨or "<< teck <<" ¨ar "<< teckenkod;
}
Variabeln teckenkod har typen int och d¨arf¨or g¨or cout ingen omvandling till tecken vid utskrift. En k¨orning av programmet kan se ut s˚a h¨ar:
Skriv ett tecken A Teckenkoden f¨or A ¨ar 65
• I asciistandarden finns 128 olika tecken representerade: F¨orst kommer 32 icke skrivbara styrtecken (numrerade fr˚an 0 t.o.m. 31). D¨arefter kommer 95 skrivbara tecken, bland andra tecknen ’0’ t.om. ’9’, versalerna i det engelska alfabetet ’A’ t.o.m. ’Z’ samt gemener i det engelska alfabetet ’a’ t.o.m. ’z’. Standarden ISO8859 definerar ¨aven teckenkoderna 128-255. Bland dessa teckenkoder finns bla ’˚A’, ’ ¨A’ och ’ ¨O’, samt ’˚a’,
’¨a’ och ’¨o’.
· N˚agra av de icke skrivbara styrtecknen kan man ange genom s.k. escape-sekvenser.
N˚agra av de vanligaste escapesekvenserna ¨ar:
\n new line, flyttar utskriftspositionen till b¨orjan p˚a n¨asta rad.
\a alert, ger en ljudsignal.
\b backspace, flyttar utskriftspositionen ett steg bak˚at.
\r return, flyttar utskriftspositionen till b¨orjan p˚a raden.
\f form feed, flyttar utskriftspositionen till b¨orjan p˚a n¨asta sida.
\t tab, flyttar utskriftspositionen till n¨asta tabulatorstopp.
\v vertical tab ger en vertikal tabulering.
P˚a sidorna ?? och ?? finns exempel p˚a anv¨andning av escapesekvenser.
• Om man deklarerar en teckenvariabel som en char ¨ar det inte helt klart om man d˚a f˚ar en unsigned char eller en signed char. S˚a om det ¨ar viktigt i programmet att just unsigned char (endast positiva v¨arden kan antas i en unsigned char) anv¨ands m˚aste man deklarera tecknena med den typen.
Typen bool
I C++ finns ¨aven typen bool. Variabler av typen bool kan anta tv˚a v¨arden; true och false
bool hittad = false;
Den boolska variabeln hittad tilldelas v¨ardet false.
Uttryck i C/C++
I program f¨orekommer ofta uttryck d¨ar man ber¨aknar vanliga tal. S˚adana uttryck kallas aritmetiska uttryck.
• Aritmetiska uttryck
– Best˚ar av konstanter, variabler, funktionsanrop och aritmetiska operatorer. Exempel p˚a aritmetiska uttryck ¨ar
9
x - 2*2*2 + 5*9/2 - pow(10,3)
V¨ardet p˚a uttrycket blir numeriskt (dvs. ett decimaltal eller ett heltal).
– Uttrycken ber¨aknas p˚a samma s¨att som i Matlab (fr˚an v¨anster till h¨oger, och operatorerna har samma prioritetsordning som i Matlab).
– Operatorerna ¨ar (det finns n˚agra fler):
+ - * (addition, subtraktion, multiplikation) / (division (heltalsdivision om b¨agge
operanderna ¨ar heltal, vanlig division annars) )
% (modulo, dvs rest vid heltalsdivision) ++ (¨okar operandens v¨arde med 1)
-- (minskar operandens v¨arde med 1)
Observera att det finns tex. ingen operator f¨or ”upph¨ojt till”
– Matematiska funktioner finns inte inbyggda i sj¨alva programspr˚aket, utan de finns i standarbibliotek. De tv˚a vanligaste ¨ar cmath och cstdlib (i C math.h respektive stdlib.h).
N˚agra funktioner i cmath
/* Alla funtioner returnerar ett reellt tal.
Argumenten (x och y nedan) ska vara av typerna float, double eller long double)
*/
exp(x) // e upph¨ojt till x
log(x) // naturliga logaritmen f¨or x log10(x) // 10-logaritmen f¨or x
sqrt(x) // roten ur x
ceil(x) // x avrundat till n¨armsta st¨orre heltal floor(x) // x anvrundat till n¨armsta mindre heltal fabs(x) // absolutv¨ardet av x
pow(x,y) // x upph¨ojt till y
fmod(x,y) // resten vid divisionen x/y
sin(x), cos(x), tan(x) // x m˚aste anges i radianer asin(x), acos(x), atan(x) // arcussinus, osv.
sinh(x), cosh(x), tanh(x) // Hyerboliska funktioner
N˚agra artimetiska funktioner i cstlib
abs(n) // Absolutv¨ardet av n. n har typen int.
labs(n) // Absolutv¨ardet av n. n har typen long int.
• Logiska uttryck Ett logiskt uttryck har v¨ardet sant eller falskt. I C/C++ (liksom i Matlab) representeras falskt av v¨ardet 0 och sant av ett v¨arde skilt ifr˚an 0. (I C++ finns ocks˚a typen bool. Uttryck av typen bool kan anta v¨ardena true eller false).
– Relationsoperatorerna ser likadana ut som i Matlab, utom skilt ifr˚an som skrivs !=
< (mindre ¨an)
> (st¨orre ¨an)
<= (mindre ¨an eller lika med)
>= (st¨orre ¨an eller lika med)
== (lika med)
!= (skilt ifr˚an)
De fungerar som i Matlab – Logiska operatorer:
&& (och) || (eller) ! (icke)
Man kan ocks˚a anv¨anda and, or respektive not. De logiska oper- atorerna fungerar p˚a samma s¨att som i Matlab
In- och ut- matning
F¨or in- och ut- matning anv¨ands cin och cout.
• cin ¨ar vanligtvis kopplad till tangentbordet (standard input) och cout
¨ar vanligtvis kopplad till standard output, vanligtvis ett textf¨onster p˚a sk¨armen. (B˚ade cin och cout kan omdirigeras).
• I inkluderingsfilen iostream (iostream.h i C) finns hj¨alpmedel f¨or I/O.
• F¨or utskrift p˚a sk¨armen anv¨ands cout cout << ut1 << ut2 << ut3 ... ;
uti ¨ar en konstant, en variabel eller ett uttryck. Man kan v¨alja att skriva flera saker i samma utskriftssats, eller bara en sak. Med hj¨alp av utmatningsoperatorn << dirigeras texten som ska skrivas ut till str¨ommen cout. Exempel:
cout << "Ange sannolikheten f¨or regn";
cout << a << " + "<< b << " = "<< a+b << endl;
P˚a f¨orsta raden skrivs texten Ange sannolikheten f¨or regn ut p˚a sk¨armen. P˚a andra raden f¨oruts¨atts att variablerna a och b ¨ar nu- meriska. V¨ardet av a skrivs ut f¨oljt av ett +, f¨oljt av v¨ardet p˚a b f¨oljt av = f¨oljt av summan av talen f¨oljt av ett nyradstecken. (endl kallas manipulator. N¨ar man skriver ut endl g¨ors en ny-rad).
• F¨or att l¨asa in v¨arden fr˚an tangentbordet anv¨ands cin. Man kan v¨alja att l¨asa in en variabel i taget
cin >> variabel1;
cin >> variabel2;
eller l¨asa in flera variabler i samma inmatningssats:
cin >> variabel1 >> variabel2;
Man anv¨ander inmatningsoperatorn >> f¨or att l¨asa indata fr˚an in- matningsstr¨ommen cin till variabler. Indata avslutas normalt med att man skriver enter (mellanslag, tabulator och radslut skiljer nor- malt indata ˚at d˚a flera variabler l¨ases in i samma sats).
• cin och cout ¨ar egentligen f¨ordefinerade objekt av klasserna istream respektive ostream.
if-satsen i C/C++
Precis som i Matlab finns det if-sats i C/C++.
if ( x>0 && y>0 ) { z = x*y;
else z = 0;
}
Vilkoret skrivs inom parentes efter if (parenteser m˚aste anv¨andas). Man anv¨ader v¨anster- och h¨oger- klamrar ({ och }) f¨or att markera var respek- tive del b¨orjar och slutar. If-satsen fungerar precis som i Matlab; Om villkoret efter if ¨ar sant utf¨ors satserna i det block som f¨oljer efter if, annars utf¨ors de satser som st˚ar efter else. Om man bara har en sats i n˚agon gren kan man utesl¨amna klamrarna.
Alternativet elseif (som ju finns i Matlab) finns inte i C/C++, utan i C/C++ m˚aste man n¨astla if-saterna ist¨allet:
if(temp<0) {
cout << "J¨atte kallt!"
} else {
if(temp<10)
cout << "Kyligt";
else
cout << "Varmt";
}
H¨ar f¨oruts¨atts att variabeln temp har deklarerats tidigare i programmet.
Observera indenteringen. Samma if-sats kan skrivas s˚a h¨ar:
if(temp<0)
cout << "J¨atte kallt!"
else if(temp<10) cout << "Kyligt";
else
cout << "Varmt";
while-satsen i C/C++
Precis som i Matlab finns det while-sats i C/C++.
F¨oljande c-program ber¨aknar hur m˚anga termer det beh¨ovs f¨or att summan 1 + 1/1 + 1/3 + ... +1/n > 10.
#include <iostream>
using namespace std;
int main() {
double s = 0.0;
int k = 0;
while (s<=10.0) { k = k+1;
s = s + 1.0/k;
}
cout << "Antal termer som kr¨avs f¨or att 1+1/2+ ... 1/n < 10 blir " << k << endl;
return 0;
}
Exekvering av while-satsen g˚ar till p˚a samma s¨att som i Matlab: F¨orst ber¨aknas det uttryck som st˚ar innanf¨or parenteserna efter while (obs par- enteser m˚aste anv¨andas i C/C++). Om uttrycket ¨ar falskt g¨ors inget mer, utan exekveringen forts¨atter med den sats som st˚ar efter while-satsens slutklammer. Om uttrycket d¨aremot ¨ar sant utf¨ors de satser som st˚ar mel- lan klammrarna en g˚ang. N¨ar dessa utf¨orts ber¨aknas uttrycket innanf¨or parenteserna p˚a nytt. Om det ¨ar falskt avslutas while-satsen, om det ¨ar sant utf¨ors satserna mellan klamrarna en g˚ang till osv.
Observera s = s + 1.0/k i loopen. Hade vi skrivit s = s + 1/k hade vi f˚att heltalsdivision eftersom b˚ade 1 och k ¨ar heltal.
