Fra CodeWiki

Den største forskjellen på C og C++ er C++ sin muligheter til å definere egne variabler ved å bruke keyword struct (som også finnes i en enklere versjon i C) og class.

For å forstå denne artikkelen vil det være nødvendig med en grei forståelse av C.

Forskjellen på struct og class

Class og struct er veldig like i funksjon og begge har de samme mulighetene, men funksjoner og variabler i struct er public hvis man ikke forandre de mens de i class er private.

Tilgangsnivåer

Objekter (struct og class) i c++ har muligheten til å definere variabler og funksjoner med forskjellige tilgangsnivåer som avgjøre hvor man har tilgang elementene i objectet. C++ har 3 ulike tilgangsnivåer som er private, protected og public. private gjør at man bare bruke funksjoner og variabler hvis man befinner seg inne i objektet. protected fungerer som private, men gir også objekter som arver fra objektet tilgang til elementet. public gir alle tilgang til elementene.

Grunnleggende bruk

class Katt
{
public: //gir tilgang til variablene overalt
  int         alder;
  std::string navn;
};

Koden over viser hvordan man kan lage en enkel klasse hvor alle variablene lese og skrivebare overalt i koden.

#include <iostream>
#include <string>
 
class Katt
{
public: //gir tilgang til variablene overalt
  int         alder;
  std::string navn;
};
 
int main()
{
  Katt Bamse;
  Katt Lindis;
 
  Bamse.alder = 42;
  Bamse.navn = "Bamse";
 
  Lindis.alder = 22;
  Lindis.navn = "Lindis";
 
  std::cout << "Katten min heter: " << Bamse.navn << " og er " << Bamse.alder << " år gammel" <<  std::endl;
  std::cout << "Katten min heter: " << Lindis.navn << " og er " << Lindis.alder << " år gammel" << std::endl;
 
  return 0;
}

Koden over vil når programmet er ferdig ha skrevet ut.

Katten min heter: Bamse og er 42 år gammel
Katten min heter: Lindis og er 22 år gammel

Medlems funksjoner

Funksjoner som hører til objekter kalles for medlemsfunksjoner siden funksjonene er medlemmer av objektet. Funksjonene som hører til et object har også tilgang til protected og elementer som hører til sin egen eller sine foreldres objekter. Funksjonene har også tilgang til private elementer som hører til sitt eget objekt.

class Katt
{
  std::string katteNavn;//denne blir private siden det er brukes noe, men blir public hvis vi hadde brukt struct
public:
  int         alder;
  std::string navn;
  std::string GetKatteNavn {return katteNavn;}
};

Det er 2 typer medlems funksjoner som skiller seg spesielt ut og det er konstruksjon og destruksjons funksjonene. Konstruksjons funksjonen blir automatisk kjørt når klassen blir erklært og destruksjons funksjonen blir automatisk kjørt rett før variabelen uallokeres.

#include <iostream>
#include <string>
 
class Katt
{
  std::string katteNavn; //Denne blir privat siden det er standard hvis ikke noe annet blir spesifisert i klasser, hadde vi brukt struct ville den blitt public
 std::string kalleNavn; //Samme som ovenfor
 
public:
  Katt(std::string KatteNavn, string KalleNavn) 
  {
    katteNavn = KatteNavn;
    kalleNavn = KalleNavn
  }
  ~Katt()//deconstruktor
  {
    std::cout << "Katten " << katteNavn << " har gått bort fra programmet" << std::endl;
  }
 
  std::string GetKatteNavn() {return katteNavn;} //Denne funksjonen vil returnere vil returnere katteNavn som ellers er blitt spesifisert som privat
  std::string GetKalleNavn() {return kalleNavn;} //Returnerer kalleNavn
};
 
int main()
{
  Katt Lindis("Lindis","mjaaaau");
 
  std::cout << "Katten min heter: " << Lindis.GetKatteNavn() << ", men kattene kaller hun bare " << Lindis.GetKalleNavn() << std::endl;
  return 0;
}

Når programmet er ferdig vil det ha skrevet ut:

Katten min heter: Lindis, men kattene kaller henne bare mjaaaau
Katten Lindis har gått bort fra programmet

Arv

Den virkelige styrken i objekt orientert programmering ligger i at objeter kan arve funksjonalitet av hverandre. Hvis man skulle lage et ballongkatt objekt så kunne man lage to klasser en ballong og et dyr (f. eks. katt) for så lage en ny klasse som arver egenskapene til begge klassene.

#include <iostream>
#include <string>
 
class Ballong
{
  bool FyltMedLuft;
public:
  void FyllMedLuft() 
  {
    FyltMedLuft = true;
  }
 
  void TaUtLufta() 
  {
    FyltMedLuft = false;
  }
 
  bool ErFullAvLuft() 
  {
    return FyltMedLuft;
  }
};
 
class Katt
{
public:
  std::string navn;
};
 
class BallongKatt : public Ballong,public Katt
{
 //variabler og funksjoner
};
 
int main()
{
  BallongKatt Bjarne;
  Bjarne.FyllMedLuft();
  Bjarne.navn = "Bjarne";
 
  std::cout << "BallongKatten er " << (Bjarne.ErFullAvLuft() ? "uten luft" : "full av luft") << std::endl;
  std::cout << "Tar ut luften av " << Bjarne.navn << std::endl;
  Bjarne.TaUtLufta();
 
  std::cout << "BallongKatten er " << (Bjarne.ErFullAvLuft() ? "uten luft" : "full av luft") << std::endl;
 
  return 0;
}

Når programmet er ferdig vil det ha skrevet ut:

BallongKatten er full av luft
Tar ut luften av Bjarne
BallongKatten er uten luft

Overlasting av operatorer

int og float har som flere av de andre variablene som følger med C/C++ flere operatorer som hjelper når man jobber med variabler. For å legge samme to integere skriver man rett og slett et plus tegn mellom de, dette er også mulig med egne objekter.

class CVector2
{
public:
  float x;
  float y;
 
  const CVector2& CVector2::operator+= (CVector2 &vVector)
  {
    x += vVector.x;
    y += vVector.y;
    return *this;
  }
};

Koden over definerer en klasse som har to mulige operatorer += og -=, operatorene gjør at man kan bruke operatorene på samme måte som om objektet skulle være en float variabel. Det er ingen begrensninger på hva du kan gjøre inne i operator funksjonen så man kan godt kode det slik at + operatoren fungerer som - eller sette alle verdier til 0. Nøkkelordet this som brukt i koden over fungere som en const peker til objektet du befinner deg inne i.

#include <iostream>
 
class CVector2
{
public:
  float x;
  float y;
 
  const CVector2& CVector2::operator+= (CVector2 &vVector)
  {
    x += vVector.x;
    y += vVector.y;
    return *this;
  }
};
 
int main()
{
  CVector2 a,b;
 
  a.x = 1.0f;
  a.y = 1.0f; 
 
  b.x = 2.0f; 
  b.y = 2.0f; 
 
  a += b;
 
  std::cout << "a + b = " << a.x << "," << a.y << std::endl;
  return 0;
}

Når programmet er ferdig vil det ha skrevet ut:

a + b = 3,3

Template klasser

Template er er en av de nyere funksjonen c++ har fått i løpet av sin levetid. Når man bruker templates sammen med objecter kan man velge å bytte ut enkelte variabler med andre variabler. Koden under viser hvordan man kan lage en template version av CVector2 klassen som vi laget i eksemplet over, men ved å gjøre CVector2 om til et template object kan vi enkelt bytte ut float til andre variabler som int eller f. eks. CVector2.

#include <iostream>
 
template <typename T> class CVector2
{
public:
  T x;
  T y;
 
  const CVector2& CVector2::operator+= (CVector2 &vVector)
  {
    x += vVector.x;
    y += vVector.y;
    return *this;
  }
};
 
int main()
{
  CVector2 <int> a;
  CVector2 <int> b;
 
  a.x = 1;
  a.y = 1; 
 
  b.x = 2; 
  b.y = 2; 
 
  a += b;
 
  std::cout << "a + b = " << a.x << "," << a.y << std::endl;
  return 0;
}

Koden over viser hvordan man kan spesifisere at CVector2::x og CVector2::y skal være int.

Når programmet er ferdig vil det ha skrevet ut:

a + b = 3,3

Eksterne lenker

cppreference.com > C/C++ Keywords > class
Wikipedia om c++ strukturer og classer