classes objects c
En kort introduktion till klasser och objekt i C ++.
Klasser och objekt är byggstenarna för objektorienterad programmering i C ++. Varje enhet, levande eller icke-levande kan representeras som ett objekt och programmeras i enlighet med C ++. Således kan enheter som bil, skrivbord, person, fågel, djur etc. representeras som objekt.
Klass är en nivå högre än objektet och representerar kategorin av objekt. Således fungerar klassen som en ritning som beskriver objektets design och detaljer. Detta inkluderar data som används för att beskriva objektet och olika metoder eller funktioner som kan verka på objektdata.
=> Se upp den enkla C ++ träningsserien här.
I denna handledning diskuterar vi alla detaljer om klass och objekt i C ++ tillsammans med deras programmatiska representation.
Vad du kommer att lära dig:
- Klasser
- Föremål
- Åtkomstspecifikatorer
- Konstruktörer
- Typer av konstruktörer
- Uppdragsoperatör
- Förstörare
- 'Denna' pekare
- Slutsats
- Rekommenderad läsning
Klasser
En klass i C ++ kan ses som en ritning eller ett skelett för en viss enhet. Klass är en användardefinierad datatyp. Den innehåller allmän information eller data för den specifika enheten och de funktioner som fungerar på den enheten.
I C ++ syntax definierar vi en klass med nyckelordet 'klass' följt av namnet på klassen.
Klassnamnet följs av detaljerna i klassen som är inneslutna i lockiga hängslen och avslutas med ett semikolon.
Följande block visar den allmänna syntaxen för klassdefinitionen.
Som visas i ovanstående representation kan klassen ha åtkomstspecifikatorer som offentliga / skyddade / privata. Det kan ha datamedlemmar och medlemsfunktioner. Data och funktioner kallas som medlemmar i klassen. Som standard är medlemmarna privata för klassen, så att ingen extern enhet har tillgång till dessa medlemmar.
Till exempel, ett fordon kan vara en generaliserad klass som har egenskaper som en modell, färg, chassinummer, medelhastighet etc. Det kan ha funktioner som changeModel, accelerera, avmattning etc. som utför åtgärder på datamedlemmarna. Vi kan definiera en klass med namnet 'fordon' som har alla dessa datamedlemmar och funktioner.
Som redan nämnts är en klass bara en ritning för enheterna. Det tar inget utrymme i minnet när det är definierat. För att en klass ska fungera måste vi definiera objekt som kan använda klassmedlemmarna.
Föremål
För att kunna använda klassfunktionaliteten måste vi starta klassen för att skapa ett objekt. Ett objekt är en förekomst av en klass. Jag enkla ord, vi kan säga att ett objekt är en variabel av typklass.
Den allmänna syntaxen för att skapa ett objekt är:
classname object_name;
När objektet har skapats kan det användas för att komma åt datakomponenterna och funktionerna i den klassen.
Åtkomst till medlemmarna i klassen (data och funktioner) görs med dot (.) -Operatören, som också kallas för medlemsaccessoperatören.
Om obj är namnet på objektet och det finns en funktion 'display ()' i klassen, kan funktionen nås som 'obj.display ()'.
Det finns dock en fångst i ovanstående uttalande. Vi kan komma åt funktionsdisplayen () med ett objekt och punktoperatören om funktionen är 'offentlig'.
Åtkomstspecifikatorer
I C ++ beror åtkomst till datamedlemmar och funktioner i klassen på åtkomsten till den specifika datamedlemmen eller funktionen med hjälp av en åtkomstspecifikator.
C ++ stöder följande åtkomstspecifikatorer:
# 1) Privat
Detta är standardåtkomstspecifikatorn för en klass i C ++. Detta innebär att om ingen åtkomstspecifikator anges för medlemmarna i en klass, anses den vara privat.
När en medlem är privat kan den inte nås utanför klassen. Inte ens använda objektet och punktoperatören. De privata datamedlemmarna kan endast nås med klassens medlemsfunktioner.
hur man lägger till ett element i en array i java
Det finns dock ett undantag från denna regel, som vi kommer att diskutera i våra senare ämnen.
# 2) Allmänhet
En datamedlem eller funktion som definieras som allmän i klassen är tillgänglig för alla utanför klassen. Dessa medlemmar kan nås med objektet och punktoperatören.
# 3) Skyddad
En skyddad medlem i en klass är tillgänglig för själva klassen och barnklasserna i den klassen.
Denna åtkomstspecifikator används särskilt i fall av arv och vi kommer att diskutera detta i detalj medan vi diskuterar arvsämnet.
Låt oss ta följande exempel för att bättre förstå dessa åtkomstspecifikationer.
#include #include using namespace std; class ABC{ int var1 = 10; public: string name; void display() { cout<<'var1 ='< Produktion:
var1 = 10
namn = sth
I det här programmet har vi två datamedlemmar varav var1 av typen int är privat (åtkomstspecifikator inte specificerad. Standard är privat). En annan medlem är strängnamnet, som deklareras som offentligt. Vi har ännu en funktionsdisplay som visar värdet på båda dessa medlemmar.
I huvudfunktionen deklarerar vi ett objekt abc av klass ABC. Sedan ställer vi in värden på datamedlemmar och även samtalsfunktionens display med objektet 'abc'.
Men när kompilatorn möter raden abc.var1 = 20; det genererar ett fel som “var1 är privat variabel”.
Detta beror på att vi inte kan komma åt privata datamedlemmar i en klass utanför klassen. Således finns det ett fel. Men vi kan komma åt den inuti funktionen och därför när vi matar ut värdet på var1 i displayfunktionen; det kastar inte något fel.
Därför visar programmets utgång det ursprungliga värdet med vilket var1 deklareras.
Hittills har vi sett detaljerna om klasser, objekt och åtkomstspecifikatorer, låt oss nu ta upp ett komplett exempel på ett exempel på klassstudenter. Den här klassen har datamedlemmar: student_id, studentnamn och student_alder. Det har också medlemsfunktioner för att läsa studentinformation och visa studentinformation.
För att göra det enkelt för läsarna har vi förklarat alla medlemmar i klassen som offentliga.
Följande program visar hela genomförandet.
#include #include using namespace std; class student{ public: int student_id; string student_name; int student_age; void read_studentInfo(); void print_studentInfo() { cout<<'
Student ID : '<student_id; cout<>student_name; cout<>student_age; } int main() { student s1; s1.read_studentInfo(); s1.print_studentInfo(); }
Produktion:
Ange student-id: 1
Ange studentnamn: abc
Ange student_alld: 12
Student-ID: 1
Studentnamn: abc
Studentålder: 12
Således har vi en komplett klass definierad ovan. Den enda anmärkningsvärda skillnaden är att vi har definierat en funktion “print_studentInfo” inuti klassen medan en annan funktion “read_studentinfo” definieras utanför klassen. Det här är de två sätten på vilka medlemsfunktioner kan definieras för en klass.
Observera att funktionen som definieras utanför fortfarande har en deklaration / prototyp inuti klassen. Det definieras också utanför klassen med hjälp av scope resolution operator (: :) . Sedan skapar vi ett studentklassobjekt i huvudfunktionen och sedan kallar vi funktioner för att läsa och visa data.
Konstruktörer
Hittills i den här handledningen har vi skapat ett enkelt objekt och sedan tilldelar vi värden till varje datamedlem i klassen i huvudfunktionen efter att ha läst dessa värden från standardingången.
I det här ämnet tittar vi på en speciell funktion som används för att initialisera objektet under dess skapande. Denna speciella funktion kallas en konstruktör.
En konstruktör är en medlemsfunktion i klassen men den skiljer sig från den normala medlemsfunktionen på följande sätt:
- Konstruktören har inget returvärde, dvs konstruktören returnerar aldrig ett värde.
- Det är en offentlig medlemsfunktion i klassen.
- Den används för att initialisera datamedlemmarna och konstruera klassens objekt.
- Det anropas automatiskt av kompilatorn när objektet skapas.
Typer av konstruktörer
C ++ stöder följande typer av konstruktörer.
# 1) Standardkonstruktör
En standardkonstruktör är grundkonstruktören och har inga parametrar. Vi kan skapa ett enkelt objekt utan några parametrar med hjälp av standardkonstruktören.
Standardkonstruktören har följande syntax:
classname() { //constructor code }
Om en klass inte har en standardkonstruktör skapar kompilatorn den.
# 2) Parameteriserad konstruktör
En parametrerad konstruktör är en som har en parameterlista med vilken vi kan initialisera klassmedlemmarna. När vi deklarerar ett objekt i en parametrerad konstruktör måste vi skicka initialvärden till konstruktorfunktionen som parametrar.
En parametrerad konstruktorfunktion ser ut som visas nedan.
classname(argument list){ //constructor code }
En parametriserad konstruktör används för att överbelasta konstruktörer. Vi kommer att se mer om överbelastning i våra senare ämnen.
En parametrerad konstruktör används i syfte att initiera datamedlemmar för olika objekt. Samtidigt kan vi skicka olika värden för datamedlemmar till olika objekt.
programvara för artificiell intelligens för pc gratis nedladdning
# 3) Kopiera konstruktörer
C ++ stöder en tredje typ av konstruktör som kallas Copy constructor. Dess allmänna form är
klassnamn (const klassnamn & objekt);
Som visas i ovanstående deklaration skapas ett nytt objekt i kopikonstruktör med hjälp av värdena för ett annat objekt av samma klass. Parametern som skickas till konstruktören är den konstanta referensen för ett objekt vars värden kommer att användas för konstruktionen av det nya objektet.
En kopiekonstruktör kallas vanligtvis i följande situationer:
- När ett klassobjekt returneras med värde.
- När ett objekt skickas till en funktion som ett argument och skickas med värde.
- När ett objekt är konstruerat från ett annat objekt av samma klass.
- När ett tillfälligt objekt genereras av kompilatorn.
Vi kan dock inte garantera att kopikonstruktör säkert kommer att anropas i alla ovanstående fall eftersom C ++ - kompilatorn har ett sätt att optimera kopieringsåtgärder.
En kopiekonstruktör utför en kopia mellan objekt mellan objekt. Precis som standardkonstruktör skapar C ++ - kompilator en standardkopiekonstruktör om vi inte tillhandahåller en i vårt program. Men när en klass har vissa datamedlemmar som pekare, referenser eller någon runtime-fördelning av resurser, måste vi ha vår egen användardefinierade kopieringskonstruktör.
Anledningen är att standardkopiekonstruktören endast utför en grund kopia av datamedlemmar, dvs båda objekten kommer att dela samma minnesplats. Detta är bra för enkla icke-pekare-datamedlemmar.
Men när det gäller pekare eller andra dynamiska datamedlemmar vill vi att informationen ska pekas på en ny minnesplats. Detta är djupkopian och kan endast uppnås med en användardefinierad kopikonstruktör.
Nedan ges ett komplett C ++ - program som implementerar alla tre typer av konstruktörer och deras användning vid konstruktion av ett objekt.
#include #include using namespace std; class student{ public: int student_id; string student_name; int student_age; //default constructor student(){ student_id = 1; student_name = 'abc'; student_age = 10; } //parameterized constructor student(int id,string name,int age){ student_id = id; student_name = name; student_age = age; } //copy constructor student(const student& st){ student_id = st.student_id; student_name = st.student_name; student_age = st.student_age; } void print_studentInfo() { cout<<'
Student ID : '< Produktion:
********** s **********
Student-ID: 1
Studentnamn: abc
Studentålder: 10
********** s2 **********
Student-ID: 2
Studentens namn: xyz
Studentålder: 12
Skärmdumpen för detsamma ges nedan.
I det här programmet har vi definierat en klassstudent som liknar den som definierades i föregående program. Skillnaden är att i stället för att läsa värden för datamedlemmar från standardinmatning via en funktion definierar vi tre konstruktörer.
Det är absolut möjligt för en klass att ha mer än en konstruktör. Vi har en standardkonstruktör som initialiserar datamedlemmarna till initialvärden. Därefter definierar vi en parametrerad konstruktör som skickar initialvärden som parametrar till konstruktören.
Därefter definierar vi en kopiekonstruktör som vi skickar en konstant referens till ett objekt i studentklassen.
I huvudfunktionen skapar vi tre objekt separat med tre konstruktörer. Första objektet s skapas med hjälp av standardkonstruktören. Det andra objektet s1 skapas med hjälp av den parametrerade konstruktorn medan det tredje objektet s2 skapas med hjälp av en kopiekonstruktör.
Notera skapandet av det tredje objektet s2. Här tilldelar vi det redan skapade objektet s1 till det nya objektet s2. Således när vi konstruerar ett nytt objekt med det redan existerande objektet, kallas en kopiekonstruktör av kompilatorn.
Uppdragsoperatör
Vi kan också tilldela värdena för ett objekt till ett annat med en tilldelningsoperator (=). I det här fallet har vi ett uttalande som s1 = s.
Skillnaden mellan kopiekonstruktör och tilldelningsoperatör är att medan kopiekonstruktören helt konstruerar ett nytt objekt tilldelar tilldelningsoperatören bara värdena för en medlem av objektet på RHS till det för objektet på LHS. Detta innebär att objekten på båda sidor av en uppdragsoperatör måste finnas existerande innan tilldelningen.
Förstörare
En förstörare är också en speciell funktion som en konstruktör men den implementerar den funktionalitet som är exakt motsatt konstruktören. Medan konstruktören används för att skapa ett objekt används en destruktör för att förstöra eller ta bort ett objekt.
Några av egenskaperna hos destruktören inkluderar:
- Ett destruktörsnamn är detsamma som klassnamnet men börjar med ett tilde (~) -tecken.
- Destructor har ingen returtyp.
- En förstörare har inga argument.
- Det kan bara finnas en förstörare i en klass.
- Kompilatorn skapar alltid en standardförstörare om vi inte tillhandahåller en för en klass.
Den allmänna syntaxen för en destruktör är:
~classname(){ //cleanup code }
Förstöraren av en klass kallas vanligtvis i följande situationer:
- När objektet går utanför räckvidden anropas automatiskt klassförstöraren.
- På samma sätt anropas destruktorn när programmet avslutar körningen. Detta innebär att alla objekt också upphör att existera. Därför kommer destruktorn för varje objekt att kallas.
- Klassens förstörare anropas också när operatören 'ta bort' för att radera ett objekt körs.
- Vi kan också ringa förstöraren uttryckligen för att utföra eventuella saneringsaktiviteter efter att vi är klara med objektfunktionen.
Exemplet nedan visar hur en destruktör fungerar.
#include using namespace std; class sample{ public: sample(){ cout<<'Constructor::sample called'< Produktion:
Constructor :: sample called
Detta är provklass
bästa hårddiskrengöraren för Windows 10
Destructor :: ~ sample called
Skärmdumpen för ovanstående utdata ges nedan.
Vi har definierat ett klassprov där vi har definierat en konstruktör, en destruktor och en funktionsdisplay. I huvudfunktionen skapar vi ett objekt obj av klassprov och anropar sedan visningsfunktionen på det här objektet.
Därefter körs en retur 0. I utgången kan vi se att det ögonblick när displayfunktionen återvänder och programstyrningen kommer till uttalande return 0, körs destruktorn. Detta innebär att det utförs i det ögonblick då objektet går utanför räckvidden.
'Denna' pekare
C ++ använder ett speciellt koncept relaterat till objekten, som kallas 'denna' pekare. 'Den här' pekaren pekar alltid på det aktuella objektet. Således, beroende på situationen, när vi måste hänvisa till det aktuella objektet använder vi 'denna' pekare.
Vi vet att varje gång en instans av klassen, dvs ett objekt skapas, görs en separat kopia av datamedlemmarna i klassen för objektet. Men när det gäller klassens medlemsfunktioner delar alla objekt samma kopia.
Så när ett eller flera objekt får åtkomst till medlemsfunktionerna samtidigt, hur säkerställer vi att rätt datamedlemmar nås och ändras av medlemsfunktionerna?
Det här är platsen där 'denna' pekare kommer till handling. Kompilatorn skickar en implicit pekare med funktionsnamnet som 'detta'. Detta kallas 'den här' pekaren.
'Denna' pekare skickas som ett dolt argument till alla medlemsfunktionssamtal. Det är vanligtvis en lokal variabel. Därför är 'denna' pekare en konstant pekare och dess innehåll är minnesadressen för det aktuella objektet.
Observera att den här pekaren endast är tillgänglig för icke-statiska medlemsfunktioner och inte för statiska funktioner. Detta beror på att de statiska funktionerna inte behöver nås med ett objekt. De kan nås direkt med klassnamnet.
Vi använder vanligtvis 'den här' pekaren i situationer där medlemsvariablerna och parametrarna skickas för att initialisera medlemsvariablerna som har samma namn. Vi använder det också när vi behöver returnera det aktuella objektet från funktionen.
Låt oss se demonstrationen av 'denna' pekare nedan.
#include using namespace std; class Sample { private: int num; char ch; public: Sample &setParam(int num, char ch){ this->num =num; this->ch = ch; return *this; } void printValues(){ cout<<'num = '< Produktion:
num = 100
ch = A
I ovanstående program har vi en klass som heter Sample, med två data-medlemmars num och ch. Vi har en medlemsfunktion setParam som skickar parametrarna med samma namn, num och ch för att ställa in värdena för medlemsvariablerna.
Inuti funktionen tilldelar vi dessa värden till de aktuella objektmedlemvariablerna som indikeras av den här pekaren. När värdena har ställts in returneras det aktuella objektet 'detta' från funktionen.
I huvudfunktionen skapar vi först ett objekt av provklass, obj och kallar en setParam-funktion för att ställa in värdena och sedan kallar funktionen printValues för att skriva ut värdena.
Slutsats
Vi har lärt oss de grundläggande byggstenarna för OOP i C ++ i denna handledning. Att förstå klasserna och objekten är de främsta kraven, till att börja med, OOP i C ++. Vi har också lärt oss om konstruktörerna och förstörarna i detalj med exempel.
I vår kommande handledning lär vi oss om initialiseringslistorna i C ++.
=> Se upp den enkla C ++ träningsserien här.
Rekommenderad läsning
- Python OOP-begrepp (Python-klasser, objekt och arv)
- Java-gränssnitt och abstrakt klasshandledning med exempel
- Arbeta med VBScript Excel-objekt
- QTP-handledning nr 7 - QTPs objektidentifieringsparadigm - Hur QTP identifierar objekt unikt?
- Objektförvar i QTP - Handledning # 22
- Arbeta med VBScript ADODB-anslutningsobjekt
- Runtime Polymorphism In C ++
- Arv i C ++