C++ Klass och objekt med exempel

Vad är en klass?

A C++ klass kombinerar data och metoder för att manipulera data till en. Klasser bestämmer också formerna för objekt. Data och metoder som finns i en klass kallas klassmedlemmar. En klass är en användardefinierad datatyp. För att komma åt klassmedlemmarna använder vi en instans av klassen. Du kan se en klass som en ritning för ett objekt.

En klass kan vara en prototyp för ett hus. Den visar placeringen och storleken på dörrar, fönster, golv etc. Utifrån dessa beskrivningar kan vi konstruera ett hus. Huset blir objektet. Det är möjligt att skapa många hus från prototypen. Det är också möjligt att skapa många objekt från en klass.

I figuren ovan har vi en prototyp för ett enda hus. Från denna prototyp har vi skapat två hus med olika funktioner.

Med idén om en klass som en ritning i åtanke är nästa steg att se hur en sådan deklareras i kod.

Klassdeklaration

In C++, definieras en klass med hjälp av nyckelordet class. Detta bör följas av klassnamnet. Klassens innehåll läggs sedan till mellan klammerparenteser { }.

syntax

class class-name
   {
   // data
   // functions
   };

• Ocuco-landskapet klassnamn är namnet som ska tilldelas klassen.
• Ocuco-landskapet datum är data för klassen, normalt deklarerade som variabler.
• Ocuco-landskapet funktioner är klassfunktionerna.

Att deklarera klassnamnet och brödtexten väcker naturligtvis frågan om vem som får använda varje medlem.

Privata och offentliga sökord

Du måste ha stött på dessa två nyckelord. De är åtkomstmodifierare.

Privat:

När det privata nyckelordet används för att definiera en funktion eller klass, blir det privat. Sådana är endast tillgängliga inifrån klassen.

Offentlig:

Det offentliga nyckelordet gör däremot data/funktioner offentliga. Dessa är tillgängliga utanför klassen.

Efter att en klass existerar kan objekt skapas från den, ungefär som variabler skapas från en datatyp.

Objektdefinition

Objekt skapas från klasser. Klassobjekt deklareras på ett liknande sätt som variabler deklareras. Klassnamnet måste komma först, följt av objektnamnet. Objektet är av klasstypen.

syntax

class-name object-name;

• Ocuco-landskapet klassnamn är namnet på den klass från vilken ett objekt ska skapas.
• Ocuco-landskapet objektnamn är namnet som ska tilldelas det nya objektet.

Denna process att skapa ett objekt från en klass kallas instansiering.

När ett objekt har skapats kan dess publika medlemmar nås direkt via en enkel operator.

Tillgång till datamedlemmar

För att komma åt offentliga medlemmar i en klass använder vi (.)dot-operatorn. Dessa är medlemmar märkta med public access modifier.

Exempelvis 1

#include <iostream>
using namespace std;
class Phone {
public:
	double cost;   
	int slots; 
};
int main() {
	Phone Y6;        
	Phone Y7;        

	Y6.cost = 100.0;
	Y6.slots = 2;

	Y7.cost = 200.0;
	Y7.slots = 2;
	cout << "Cost of Huawei Y6 : " << Y6.cost << endl;
	cout << "Cost of Huawei Y7 : " << Y7.cost << endl;

	cout << "Number of card slots for Huawei Y6 : " << Y6.slots << endl;
	cout << "Number of card slots for Huawei Y7 : " << Y7.slots << endl;

	return 0;
}

Produktion:

Här är en skärmdump av koden:

Code Förklaring:

1. Inkludera iostream-huvudfilen i vår kod för att kunna använda dess funktioner.
2. Inkludera std-namnområdet i vår kod för att använda dess klasser utan att anropa det.
3. Deklarera en klass som heter Telefon.
4. Använda public access-modifieraren för att markera de variabler vi håller på att skapa som offentligt tillgängliga.
5. Deklarera den rörliga kostnaden för en dubbel datatyp.
6. Deklarera en heltalsvariabel med namnet slots.
7. Slutet av klassens kropp.
8. Anropar main()-funktionen. Programlogiken bör läggas till i dess kropp.
9. Skapa ett objekt med namnet Y6 av typen Telefon. Detta kallas instansiering.
10. Skapa ett objekt med namnet Y7 av typen Telefon. Detta kallas instansiering.
11. Få tillgång till variabel-/medlemskostnaden för klass Telefon med hjälp av objektet Y6. Värdet är satt till 100.0. Kostnaden för Y6 är nu satt till 100.0.
12. Få tillgång till variabel-/medlemsplatserna i klass Telefon med hjälp av objektet Y6. Värdet är satt till 2. Facket för Y6 är nu satt till 2.
13. Få tillgång till variabel-/medlemskostnaden för klass Telefon med hjälp av objektet Y7. Värdet är satt till 200.0. Kostnaden för Y7 är nu satt till 200.0.
14. Få tillgång till variabel-/medlemsplatserna i klass Telefon med hjälp av objektet Y7. Värdet är satt till 2. Facket för Y7 är nu satt till 2.
15. Skriv ut kostnaden för Y6 på konsolen tillsammans med annan text.
16. Skriv ut kostnaden för Y7 på konsolen tillsammans med annan text.
17. Skriv ut antalet platser för Y6 tillsammans med annan text.
18. Skriv ut antalet platser för Y7 tillsammans med annan text.
19. Programmet måste returnera ett värde efter framgångsrikt slutförande.
20. Slutet på huvuddelen av funktionen main().

Offentliga medlemmar är öppna för extern kod, men privata medlemmar följer mycket strängare åtkomstregler.

Vad är en privatklass?

Klassmedlemmar markerade som privata kan endast nås av funktioner definierade inom klassen. Alla objekt eller funktioner som definieras utanför klassen kan inte komma åt sådana medlemmar direkt. En privat klassmedlem nås endast av medlems- och vänfunktioner.

Exempelvis 2

#include <iostream>
using namespace std;
class ClassA {
public:
	void set_a(int val);
	int get_a(void);

private:
	int a;
};
int ClassA::get_a(void) {
	return a;
}
void ClassA::set_a(int val) {
	a = val;
}
int main() {
	ClassA a;
	a.set_a(20); 
	cout << "Value of a is: " << a.get_a(); 
	return 0;
}

Produktion:

Här är en skärmdump av koden:

Code Förklaring:

1. Inkludera iostream-huvudfilen i vår kod för att använda dess funktioner.
2. Inkludera std-namnområdet i vår kod för att använda dess klasser utan att anropa det.
3. Skapa en klass som heter ClassA.
4. Använd public access modifier för att markera klassmedlemmen som ska skapas som allmänt tillgänglig.
5. Skapa funktionen som heter set_a() som tar ett heltalsvärde val.
6. Skapa en funktion som heter get_a().
7. Använd modifieraren för privat åtkomst för att markera klassmedlemmen som ska skapas som privat tillgänglig.
8. Deklarera en heltalsvariabel med namnet a.
9. Slutet av klassens kropp.
10. Använd klassnamnet och scope resolution operatorn för att komma åt funktionen get_a(). Vi vill definiera vad funktionen gör när den anropas.
11. Funktionen get_a() ska returnera värdet för variabel a när den anropas.
12. Slutet på definitionen av funktionen get_a().
13. Använd klassnamnet och scope resolution operatorn för att komma åt funktionen set_a(). Vi vill definiera vad funktionen gör när den anropas.
14. Tilldela variabeln värdet till variabel a.
15. Slutet på definitionen av funktionen set_a().
16. Anropa main()-funktionen. Programlogiken bör läggas till i kroppen av denna funktion.
17. Skapa en instans av ClassA och ge den namnet a.
18. Använd ovanstående klassinstans och funktionen set_a() för att tilldela variabeln a ett värde på 20.
19. Skriver ut lite text tillsammans med värdet för variabel a på konsolen. Värdet på variabel a erhålls genom att anropa funktionen get_a().
20. Programmet måste returnera värde efter framgångsrikt slutförande.
21. Slutet på huvuddelen av funktion main().

Skyddade medlemmar sitter mellan privat och offentlig, vilket lägger till en viktig funktion för arv.

Vad är en skyddad klass?

Klassmedlemmar som är markerade som skyddade har en fördel framför de som är markerade som privata. De kan nås av funktioner inom klassen för deras definition. Dessutom kan de nås från härledda klasser.

Exempelvis 3

#include <iostream>
using namespace std;
class ParentClass {
protected:
	int value;
};
class ChildClass : public ParentClass {
public:
	void setId(int x) {
		value = x;
	}
	void displayValue() {
	cout << "Value is: " << value << endl;
	}
};
int main() {
	ChildClass c;
	c.setId(21);
	c.displayValue();
	return 0;
}

Produktion:

Här är en skärmdump av koden:

Code Förklaring:

1. Inkludera iostream-huvudfilen i vår kod för att använda dess funktioner.
2. Inkludera std-namnområdet i vår kod för att använda dess klasser utan att anropa det.
3. Skapa en klass som heter ParentClass.
4. Använd modifieraren för skyddad åtkomst för att markera klassmedlemmen som ska skapas som skyddad.
5. Skapa en heltalsvariabel med namnet värde.
6. Slutet av klassens kropp.
7. Skapa en ny klass med namnet ChildClass som ärver ParentClass.
8. Använd modifieraren för skyddad åtkomst för att markera klassmedlemmen som ska skapas som tillgänglig för barnklasser.
9. Skapa funktionen med namnet setId() som tar ett heltalsvärde x.
10. Tilldela värdet för variabeln x till variabelvärdet.
11. Slutet på definitionen av funktionen setId().
12. Skapa en funktion som heter displayValue().
13. Skriv ut värdet på variabelns namngivna värde på konsolen tillsammans med annan text.
14. Slutet på kroppen av funktionen displayValue().
15. Slutet på brödtexten för klassen som heter ChildClass.
16. Anropa main()-funktionen. Programlogiken bör läggas till i kroppen av denna funktion.
17. Skapa en instans av ChildClass och ge den namnet c.
18. Använd ovanstående klassinstans och funktionen setId() för att tilldela variabeln x värdet 21.
19. Använd klassinstansen ovan för att anropa funktionen med namnet displayValue().
20. Programmet måste returnera värde efter framgångsrikt slutförande.
21. Slutet på huvuddelen av funktion main().

Förutom att lagra data grupperar en klass även de funktioner som arbetar med den datan.

Klassmedlemsfunktioner

Funktioner hjälper oss att manipulera data. Klassmedlemsfunktioner kan definieras på två sätt:

• Inuti klassdefinitionen
• Utanför klassdefinitionen

Om en funktion ska definieras utanför en klassdefinition måste vi använda scope resolution operator (::). Detta bör åtföljas av klass- och funktionsnamn.

Exempelvis 4

#include <iostream>
#include <string>
using namespace std;
class Guru99
{
public:
	string tutorial_name;
	int id;
	void printname();
	void printid()
	{
		cout << "Tutorial id is: "<< id;
	}
};
void Guru99::printname()
{
	cout << "Tutorial name is: " << tutorial_name;
}
int main() {
	Guru99 guru99;
	guru99.tutorial_name = "C++";
	guru99.id = 1001;
	guru99.printname();
	cout << endl;
	guru99.printid();
	return 0;
}

Produktion:

Här är en skärmdump av koden:

Code Förklaring:

1. Inkludera iostream-huvudfilen i vårt program för att använda dess funktioner.
2. Inkludera stränghuvudfilen i vårt program för att använda dess funktioner.
3. Inkludera std-namnområdet i vår kod för att använda dess klasser utan att anropa det.
4. Skapa en klass med namnet Guru99.
5. Använd modifieraren för offentlig åtkomst för att markera de klassmedlemmar vi ska skapa som offentligt tillgängliga.
6. Skapa en strängvariabel med namnet tutorial_name.
7. Skapa en heltalsvariabel med namnet id.
8. Skapa en funktion som heter printname(). Denna funktion är inte definierad i klassdefinitionen.
9. Skapa en funktion med namnet printid(). Denna funktion är definierad i klassdefinitionen. Dess brödtext har lagts till i klassdefinitionen.
10. Skriv ut värdet för variabel-id tillsammans med annan text på konsolen. Observera att detta har lagts till i huvuddelen av printid()-funktionen. Den kommer bara att köras när funktionen printid() anropas.
11. Slutet på funktionskroppen printid().
12. Slutet av klassens kropp Guru99.
13. Början av definitionen av funktionen printname().
14. Skriv ut värdet för variabeln tutorial_name på konsolen tillsammans med annan text. Observera att detta har lagts till i funktionen printname()s brödtext. Den kommer bara att köras när funktionen printname() anropas.
15. Slutet på definitionen av printname()-funktionen.
16. Anropa main()-funktionen. Programlogiken bör läggas till i kroppen av denna funktion.
17. Skapa en instans av klassen Guru99 och ger den namnet guru99.
18. Använd ovanstående instans för att tilldela ett värde på C++ till variabeln tutorial_name.
19. Använd guru99-instansen för att tilldela ett värde på 1001 till variabel-id.
20. Använd instansen guru99 för att anropa funktionen printname() .
21. Anropa kommandot slut (slutrad) för att skriva ut en ny tom rad på konsolen.
22. Använd instansen guru99 för att anropa funktionen printid().
23. Programmet måste returnera värde efter framgångsrikt slutförande.
24. Slutet på huvuddelen av funktionen main().

Två speciella medlemsfunktioner körs automatiskt när ett objekt skapas och när det förstörs.

Konstruktörer och destruktörer

Vad är en konstruktör?

Konstruktorer är specialfunktioner som initierar objekt. C++ kompilatorer anropa en konstruktor när man skapar ett objekt. Konstruktorerna hjälper till att tilldela värden till klassmedlemmar. Naturligtvis sker detta efter att de har allokerats minnesutrymme.

Vad är en destruktor?

Destruktörer å andra sidan hjälper till att förstöra klassobjekt.

Konstruktornamnet måste likna klassnamnet. Konstruktörer har ingen returtyp.

Konstruktorn kan definieras inom eller utanför klasskroppen. Om den definieras utanför klasskroppen bör den definieras med klassnamnet och scope resolution operator (::).

Exempelvis 5

#include <iostream>  
using namespace std;
class ClassA {
public:
	ClassA() {
		cout << "Class constructor called"<<endl;
	}
	~ClassA() {
		cout << "Class destructor called"<<endl;
	}
};

int main() {
	ClassA a;
	int p = 1;
		if (p) {
			ClassA b; 
		}   
}

Produktion:

Här är en skärmdump av koden:

Code Förklaring:

1. Inkludera iostream-huvudfilen i koden för att använda dess funktioner.
2. Inkludera std-namnområdet i vår kod för att använda dess klasser utan att anropa det.
3. Skapa en klass som heter ClassA.
4. Använd modifieraren för offentlig åtkomst för att markera den medlem vi håller på att skapa som allmänt tillgänglig.
5. Skapa en konstruktor för klassen.
6. Text att skriva ut på konsolen när konstruktorn anropas. Änden är en C++ nyckelord, vilket betyder slutrad. Den flyttar muspekaren till nästa rad.
7. Slutet på kroppen av klasskonstruktören.
8. Skapa en destruktör för klassen.
9. Text att skriva ut på konsolen när förstöraren anropas. Änden är en C++ nyckelord, vilket betyder slutrad. Den flyttar muspekaren till nästa rad.
10. Slutet på destruktörens kropp.
11. Slutet av klassens kropp.
12. Anropa main()-funktionen. Programlogiken bör läggas till i kroppen av denna funktion.
13. Skapa ett klassobjekt och ge det namnet a. Konstruktören kommer att kallas.
14. Skapa en heltalsvariabel med namnet p och tilldela den värdet 1.
15. Skapa ett if-satsblock med variabeln p.
16. Skapa ett klassobjekt och ge det namnet b. Förstöraren kommer att kallas.
17. Slutet på brödtexten i if-satsen.
18. Slutet på huvuddelen av funktionen main().

Vanliga frågor