Introduktion till C++ och hur man använder Code::Blocks
Innehåll:
1.0 - Introduktion
1.1 - En snabb genomgång av Code::Blocks
1.2 - Grund för ett program
1.3 - Variabler
1.4 - Konstanter
1.5 - Operatörer
1.6 - I/O
2.0 - Funktioner och flödeskontrollering
2.1 - Flödeskontrollering
2.2 - Funktioner
3.0 - Datatyper
3.1 - Arrays
3.2 - Vektorer
3.3 - Pekare
3.4 - Datastruktur
4.0 - Objektorientering
4.1 - Klasser
1.0 - Introduktion
Den här guiden är avsedd för nybörjare och är menad att kunna förmedla det mesta en person bör kunna för att lära sig att programmera i C++.
Jag använder för tillfället Windows och guiden kommer således att vara bäst anpassad för det operativsystemet; det bör dock inte vara några problem med att använda det på Linux eller ett annat alternativt operativsystem. Tänk dock på att flera bibliotek, t.o.m. grundläggande sådana, kan vara beroende på operativsystemet.
Det här är bara en introduktion till språket, och det finns mycket mer att lära sig. Jag hänvisar vid varje kapitel och delkapitel till mer information om ämnet; den här guiden är bara avsedd för att sammanfatta språket för en nybörjare.
Genomgången av Code::Blocks kan hoppas över om du har en annan IDE eller om du redan vet hur man använder programmet.
1.1 - En snabb genomgång av Code::Blocks
Code::Blocks
Tänk på att välja GCC och mingw om du inte har någon kompilator!
Direktlänk.
Öppna Code::Blocks och gå till File -> New -> Project.
Välj Console application.
Välj ett namn för projektet och var det ska sparas.
För att kompilera och köra ett program, tryck på Build and Run.
Programmet kommer att se ut såhär:
1.2 - Grund för ett program
Jag kommer att skriva ett grundläggande och enkelt program i C++ nedan, jag kommer sedan att gå igenom alla olika delar i programmet del för del.
#include <iostream>
int main()
{
std::cout << "Hello World!\n" << std::endl;
return 0;
}
* #include <iostream>
Den här raden inkluderar ett bibiliotek som heter iostream och är ett av biblioteken som hanterar in- och utdata. Den låter dig använda funktionen cout som skriver ut något på skärmen. Jag kommer att visa ett alternativ senare.
* int main()
Den här raden påbörjar huvudfunktionen (main) som alltid måste vara närvarande i ett program. Vad en funktion är kommer jag att gå igenom senare, det enda du behöver veta för tillfället är att funktionen main är en nödvändighet.
* std::cout << "Hello World!\n" << std::endl;
Den här raden skriver ut "Hello World!" på skärmen, std:: används för att komma åt funktioner eller objekt inom ett s.k. namespace. Begreppet namespace är överkurs och man kan välja att använda using namespace std; istället för att skriva std:: bakom varje funktion som kräver det, vissa argumenterar dock för att det är en dålig vana att inte använda std::.
#include <iostream>
using namespace std;
int main()
{
return 0;
}
* return 0;
Den här raden säger till funktionen main() att returnera 0; sålänge funktionen är av en speciell datatyp så måste funktionen returnera något. Nu är funktionen av datatypen int (integer, ett tal) således måste den returnera ett tal, som i det här fallet är 0.
* { }
Dessa tecken används för att öppna och stänga ett s.k. scope (räckvidd eller omfång). Detta innefattar bl.a. funktioner och flödeskontroller.
Några alternativa sätt att skriva en enkel grund, och ändå uppnå samma resultat, finns nedan.
#include <stdio.h>
int main()
{
puts("Hello World!");
return 0;
}
#include <iostream>
using namespace std;
void main()
{
cout << "Hello World!\n";
}
1.3 - Variabler
En variabel kan ses som en låda i en byrå som kan öppnas och stängas, man kan givetvis också lägga saker i lådan.
#include <iostream>
#include <string>
int main()
{
int x; //En variabel av datatypen int.
std::string str; //En variabel av datatypen string.
x = 5;
str = "Hello!";
std::cout << x << " " << str;
return 0;
}
Programmet ovan kommer att skriva ut "5 Hello!".
* int x //En variabel av datatypen int.
Den här raden deklarerar variabeln x som är av datatypen int. Detta betyder att man bara kan lagra heltalsvärden i lådan, som t.ex. 5, eller 12, eller -105.
"//" används för att göra kommentarer; dessa kommentarer förändrar inte själva programmet utan är bara där för att göra det enklare att förstå koden, både för programmeraren och för andra som läser den.
* std::string str; //En variabel av datatypen string.
Den här raden deklarerar en variabel av datatypen string, det är med andra ord en sträng. Man kan också använda sig av char, jag föredrar dock att arbeta med dessa strängar så jag kommer att utgå från dessa i guiden.
#include <iostream>
int main()
{
int x;
std::cout << "Enter a number: ";
std::cin >> x;
std::cout << "\nYou entered: " << x;
return 0;
}
Det här programmet låter användaren initialisera variabeln x genom att använda cin (som används för att få input från användaren).
Exempel på output:
Enter a number: 5
You entered 5
1.4 - Konstanter
En konstant är, som namnet antyder, en variabel som inte går att ändra. Det finns två sätt att skapa en konstant; antingen med const datatyp eller #define.
#include <iostream>
int main()
{
const int x = 5; //x är nu en konstant och kan inte ändras.
x = 6; //Går inte!
const int y;
y = 5; //Går inte heller!
}
#include <iostream>
#define VAR 150
int main()
{
std::cout << VAR; //Skriver ut 150.
VAR = 5; //Går inte! VAR är en konstant.
return 0;
}
Mer information om konstanter.
[U]1.5 - I/O[/U]
I/O eller In/Ut (Input/Output) syftar på funktioner man använder för att skriva ut information på skärmen eller låta användaren mata in information till programmet. Det finns två vanliga bibliotek för detta; iostream och stdio.
iostream
#include <iostream>
int main()
{
std::cout << "Hello World!";
}
cout används för att skriva ut data på skärmen, i det här fallet skriver programmet ut texten "Hello World!".
#include <iostream>
int main()
{
int x;
std::cout << "Enter a number: ";
std::cin >> x;
std::cout << "You entered: " << x;
return 0;
}
För att låta användaren mata in information använder man cin.
Output:
Enter a number: 34
You entered: 34
stdio
Det finns många sätt att skriva ut och mata in data med stdio, här är ett par exempel:
#include <stdio.h>
#include <string>
int main()
{
puts("Hello World!");
printf("%s", "Hello!\n");
std::string str;
printf("Enter a string: ");
scanf("%s", str.c_str());
puts(str.c_str());
return 0;
}
Output:
Hello World!
Hello!
Enter a string: Test!
Test!
Mer information om input och output.
[U]1.6 - Operatörer[/U]
Operatörer används för att på något sätt modifiera variabler. En vanlig operatör är likamedtecknet, =, som används för att initialisera variabler.
int x;
x = 5;
Vi kan också använda oss av matematiska operatörer; division, subtraktion, addition, multiplikation och modulo.
int x,y;
x = 5;
y = 3;
std::cout << x+y << std::endl;
std::cout << x*y << std::endl;
std::cout << x/y << std::endl;
std::cout << x-y << std::endl;
std::cout << x%y << std::endl;
Det finns också en del genvägar man kan ta för att slippa skriva så mycket.
int x;
x = 5;
x = x + 2;
x += 2;
x = x * 2;
x *= 2;
a += b är samma sak som a = a +b.
int x = 1;
x++;
x++ är samma sak som x = x+1. x-- är samma sak som x = x-1.
== - likamed-operatör
> - mer än-operatör
< - mindre än-operatör
<= - mindre än eller likamed-operatör
>= - mer än eller likamed-operatör
!= - inte likamed-operatör
! - INTE (NOT) eller falskt (false)
&& - och
|| - eller
Exempel:
int a, b;
a = 13;
b = 23;
a == a; (sant)
a == b; (falskt)
a < b; (sant)
b >= a; (sant)
a <= b; (sant)
a != b; (sant)
a != a; (falskt)
if(a == 5 && b == 10)
Om a är 5 OCH b är 10.
if(a == 5 || b == 10)
Om a är 5 ELLER om b är 10.
Mer information om operatörer.
2.0 - Funktioner och flödeskontrollering
Det här kapitlet är väldigt viktigt då både funktioner och flödeskontrollering spelar en väldigt stor roll i programmering, speciellt i ett objektorienterat språk som C++ (klasser brukar innebära många funktioner).
2.1 - Flödeskontrollering
Om det här påståendet är sant, så gör jag så här. Annars så går jag här ifrån!
En småkomisk förklaring till flödeskontrollering; med hjälp av flödeskontroll kan man kontrollera flödet av ett program genom att införa ett eller flera logiska kontroller.
#include <iostream>
int main()
{
bool x = true;
if(x == true)
{
std::cout << "It's true!";
}
else
{
std::cout << "It's not true";
}
return 0;
}
Det här programmet skapar först en variabel av datatypen bool, som används för att antingen lagra true eller false. Programmet sätter sedan igång en kontroll som kan resultera i två händelser; antingen så är påståendet sant och programmet skriver ut "It's true!", eller så är påståendet falskt och programmet skriver ut "It's not true". I det här exemplet så är ju påståendet sant, och programmet skulle således skriva ut "It's true!".
#include <iostream>
int main()
{
for(int i = 0; i < 5; i++)
{
std::cout << i << std::endl;
}
}
Det här är en annan typ av flödeskontroll, en s.k. loop. Formatet för en for-loop är följande:
for (initilisation; villkor; ökning eller minskning) uttryck;
Enligt vårt exempel alltså:
for (int i = 0; medan i är mindre än 5; öka i med ett)
Eftersom att i börjar på 0, skulle programmet skriva ut:
0
1
2
3
4
Programmet stannade på fyra för att vi sade till den att hålla på så länge i var mindre än fem (och fyra är ju mindre än fem).
#include <iostream>
int main()
{
for(int i = 5; i >= 0; i--)
{
std::cout << i << std::endl;
}
}
for(int i = 5; medan i är större eller lika med 0; ta bort 1 från i)
Det här programmet skulle alltså skriva ut:
5
4
3
2
1
0
#include <iostream>
int main()
{
int x = 0;
while( x < 5)
{
x++;
std::cout << x;
}
return 0;
}
Det här är ännu en typ av loop, en s.k. while-loop. Formatet är följande:
while(villkor) uttryck;
Som i vårt exempel:
int x = 0;
sålänge x är mindre än 5, öka x med ett och skriv ut resultatet på skärmen.
Programmet skulle alltså skriva ut:
12345
Mer information om flödeskontrollering.
2.2 - Funktioner
Funktioner låter programmeraren skriva kod som sedan kan användas om och om igen utan att behöva skriva ut hela koden flera gånger.
#include <iostream>
int function()
{
std::cout << "Hello!";
return 0;
}
int main()
{
function();
return 0;
}
Precis som vår main-funktion är vår nya funktion, function, av datatypen int. Den returnerar således också en int, som i det här fallet är 0. Genom att kalla på funktionen inifrån main-funktionen, får man programmet att köra koden som function innehåller. Den skriver alltså ut "Hello!".
#include <iostream>
int add(int x, int y)
{
return x+y;
}
int main()
{
std::cout << add(5,2);
return 0;
}
I det här programmet använder vår funktion funktionsparametrar (x och y), detta låter oss förändra resultatet av funktionen varje gång vi kallar på den. Vi kan också använda return i olika sammanhang, t.ex. skriva ut (x+y) genom att ange funktionen i cout.
Programmet skriver alltså ut siffran sju på skärmen.
Mer information om funktioner.
3.0 - Datatyper
Variabler kan ha olika datatyper, så som int, char, string, o.s.v. Datatypen bestämmer vilken typ av värde som kan lagras i variabeln.
3.1 - Arrays
En array är en serie värden som lagras i en variabel, fast med olika minnesplatser.
int array[4] = {1, 2, 3, 4};
std::cout << array[0] << std::endl;
std::cout << array[3] << std::endl;
Här har vi en array med fyra värden; 1, 2, 3, 4, 5. Dessa initialiseras genom att först deklarera en array med fyra minnesplatser, och sedan specificera ett värde för varje minnesplats. Koden ovan kommer att skriva ut värdet 1 och 4.
int array[4];
for(int i = 0; i < 4; i++)
{
array[i] = i;
}
for(int i = 0; i < 4; i++)
{
std::cout << array[i];
}
Här är ett exempel där en array initialiseras med hjälp av en for-loop, arrayen kommer att innehålla värdena 0,1,2,3.
[U]3.2 - Vektorer[/U]
Vektorer är snarlika arrayer, men är lättare att kontrollera.
#include <iostream>
#include <vector> //Krävs för att använda vektorer!
int main()
{
std::vector<std::string> myvector; //Deklaration för en vector av datatypen string.
myvector.push_back("Test!"); //En initialisering för en vector.
std::cout << myvector[0]; //Skriver ut "Test!".
return 0;
}
[U]3.3 - Pekare[/U]
Alla värden som lagras i variabler har en egen adress i minnet; C++ tillåter oss att hantera dessa adresser.
#include <iostream>
int main()
{
int x = 5; //En vanlig variabel med ett värde,
std::cout << "x is at memory: " << &x << std::endl; //Skriver ut minnesadressen.
return 0;
}
x is at memory: 0x28ff1c
Och-tecknet (&) kallas för en referens-operatör, den översätter i princip en variabel till adressen i minnet den existerar på.
En asterisk (*) är motsatsen till referens-operatören, den översätter en adress till värdet som finns på adressen. Asterisk-operatören kallas på engelska för dereference operator.
#include <iostream>
int main()
{
int x = 5; //En vanlig variabel med ett värde,
std::cout << "x is at memory: " << &x << std::endl; //Skriver ut minnesadressen.
int * y;
y = &x; //y pekar på värdet som finns på adressen 0x28ff1c!
std::cout << "value: " << *y;
return 0;
}
x is at memory: 0x28ff1c
value: 5
[U]3.4 - Datastrukturer[/U]
Liksom arrayer och vektorer kan en datastruktur ha olika element; men inte bara värden, utan också olika datatyper. En datastruktur (structure eller struct på engelska) består av olika medlemmar (members) som sedan deklareras som ett objekt (object); datastrukturer används väldigt ofta i C++, speciellt i form av klasser.
Det här är syntaxen för en datastruktur:
struct namn
{
datatyp variabel;
datatyp variabel;
} objekt;
#include <iostream>
int main()
{
struct mystruct //En ny datastruktur
{
int x;
int y;
} myobject; //Ett objekt.
myobject.x = 5;
myobject.y = 3;
std::cout << myobject.x << std::endl;
std::cout << myobject.y << std::endl;
return 0;
}
Som du kan se så initialiseras x och y utanför strukturen med hjälp av namnet på objektet, detta är användbart därför att man kan initialisera fler objekt och få tillgång till samma lista av variabler.
#include <iostream>
int main()
{
struct mystruct
{
int x;
int y;
} myobject, another_object;
myobject.x = 5;
myobject.y = 3;
another_object.x = 13;
another_object.y = 24;
std::cout << myobject.x << std::endl;
std::cout << myobject.y << std::endl;
std::cout << another_object.x << std::endl;
std::cout << another_object.y << std::endl;
return 0;
}
Output:
5
3
13
24
Och här är ett exempel på en datastruktur med olika av datatyper.
#include <iostream>
int main()
{
struct mystruct
{
int x;
std::string str;
bool z;
} myobject;
myobject.x = 19;
myobject.str = "Hello!";
myobject.z = false;
std::cout << "x: " << myobject.x << std::endl;
std::cout << "str: " << myobject.str << std::endl;
std::cout << "z: " << myobject.z << std::endl; //False är 0, true är 1.
return 0;
}
Output:
x: 19
str: Hello!
z: 0
Mer information om datastrukturer.
4.0 - Objektorientering
Nu kommer vi till det sista kapitlet som går igenom det som gör C++ så speciellt jämfört med C, nämligen objektorientering. Med hjälp av objektorientering så kan man, likt datastrukturer, deklarera funktioner och värden i klasser och komma åt dessa genom objekt. Programmet får bl.a. mer struktur och det blir oerhört mycket lättare för funktioner att dela variabler och värden med varandra.
4.1 - Klasser
Här är den grundläggande syntaxen för en klass:
class namn
{
åtkomstspecificering:
datatyp variabel;
datatyp funktion;
} objekt;
Som du ser så är syntaxen för klasser nästan identisk med syntaxen för datastrukturer, men med en del skillnader. Åtkomstspecificeringen gör det möjligt att specificera vad som får komma åt vad inom klassen, om funktioner utanför klassen får komma åt värden eller om bara funktioner innanför klassen kan göra det. En tumregel är att ha innehållet så privat som möjligt.
Olika åtkomstspecificeringar:
public - låter vad som helst komma åt innehållet
private - låter bara medlemmar inom klassen komma åt innehållet. Medlemmarnas vänner kan också komma åt innehållet, men jag kommer inte att gå igenom vänskap inom objektorientering. Jag kommer dock att länka till mer information i slutet av kapitlet.
protected - låter medlemmar och dess vänner och vänners vänner, o.s.v., komma åt innehållet.
#include <iostream>
class myclass
{
private:
int x;
public:
void set_value(int);
void print();
} myobject;
void myclass::set_value(int a)
{
x = a;
}
void myclass::print()
{
std::cout << x;
}
int main()
{
myobject.set_value(5);
myobject.print();
return 0;
}
I exemplet ovan är variabeln x privat, och kan därför bara kommas åt av medlemmar i klassen.
myobject.set_value(5);
myobject.print();
myobject.x = 5;
Skulle man försöka ändra variabeln, eller försöka skriva ut, x som i exemplet ovan så får man ett felmeddelande:
main.cpp|6|error: 'int myclass::x' is private|
Man kan också göra flera olika objekt, även kallat instanser, för att kunna använda samma variabler och funktioner flera gånger.
#include <iostream>
class myclass
{
int x; //Om ingen åtkomstspecifiering finns så är alla medlemmar privata.
public:
void set_value(int);
void print() {std::cout << x << std::endl;}
};
void myclass::set_value(int a)
{
x = a;
}
int main()
{
myclass x,y; //Två olika objekt eller instanser!
x.set_value(5); //x är 5
y.set_value(12); //x är 12
x.print();
y.print();
return 0;
}
Output:
5
12
Som du ser så används x två gånger, men värdet är fortfarande detsamma i respektive objekt. Man kan alltså använda variabler och funktioner flera gånger utan att skriva över någon information.
Osocial, instängd och förbannad.
