Är det värt att komplettera lite grundläggande OOP i C, istället för att lära sig C++?
Hej!
Jag har skapat en klass i rent C och satt några värden till en variabel i klassen.
Jag har aldrig gjort detta förut, men nu börjar jag förstå kraften av pekare.
Dessutom fann jag detta väldigt roligt och väldigt enkelt också. Jag har skapat en klass som heter minKlass och den har en variabel som heter minVariabel. För att sätta värden och hämta värden till minVariabel så har jag skapat två funktioner som heter getter och setter. Detta är en väldigt lik analogi med Javaprogrammering att man sätter getter och setter.
Det har varit en rätt aktivt diskussion att OOP är faktiskt inte den bästa metodiken att lösa problem. Majoriteten av fallen så duger faktiskt funktionsprogrammering, dvs vanliga funktioner. Där håller jag faktiskt med. Jag tycker funktionsprogrammering är enklare att läsa och det blir dessutom mindre kod.
Men trots att funktionsprogrammering må vara den vanligaste metodiken för att lösa dagliga problem, så finns det ändå behov utav OOP vid tillfällen där man jobbar med objekt. Då tänkte jag ställa er frågan:
Frågeställning:
Är det värt att komplettera lite grundläggande OOP i C, istället för att lära sig C++?
Jag blir riktigt nöjd om jag kan bara göra en liten klass och ha den möjligheten att kunna ärva en annan klass. Mer än så här behöver jag inte för att kunna lösa OOP problem. Nu finns det säkert ännu mera man kan göra inom OOP t.ex. interface. Men sådant har jag faktiskt klarat mig utan.
Här nedan visar jag två exempel utan minnesallokering. Dvs du behöver inte använda funktionen free som i C ochC++ efter avslutat objekt.
#include <stdio.h>
typedef struct minKlass minKlass;
struct minKlass{
/* Skapa en variabel och getter-setter */
int minVariabel;
void (*setMinVariable)(minKlass*, int);
int (*getMinVariable)(minKlass*);
};
minKlass* minKonstruktor(minKlass* this){
/* Skapa getter-funktion */
int getMinVariableFunktion(minKlass* this){
return this->minVariabel;
}
/* Skapa setter-funktion */
void setMinVariableFunktion(minKlass* this, int variabel){
this->minVariabel = variabel;
}
/* Applicera dessa till pekarfunktionen i klassen */
this->setMinVariable = setMinVariableFunktion;
this->getMinVariable = getMinVariableFunktion;
/* Retunera adressen av våran nya klass */
return this;
}
int main(){
/* Skapa två klasser */
minKlass klass1;
minKlass klass2;
/* Passera klassen igenom konstruktören */
minKlass* pKlass1 = minKonstruktor(&klass1);
minKlass* pKlass2 = minKonstruktor(&klass2);
/* Sätt ett värde till klassen */
pKlass1->setMinVariable(pKlass1, 104);
pKlass2->setMinVariable(pKlass2, 23);
/* Ta ett värde från klassen */
int minVariabel1 = pKlass1->minVariabel;
int minVariabel2 = pKlass2->minVariabel;
/* Skriv ut värdet */
printf("minVariabel1 = %i, minVariabel2 = %i\n", minVariabel1, minVariabel2);
return 0;
}
Om jag vill ha lite arv där jag skapar en huvudKlass som är inkluderat i minKlass.
typedef struct minKlass minKlass;
struct minKlass{
/* Skapa en variabel och getter-setter */
int minVariabel;
void (*setMinVariabel)(minKlass*, int);
int (*getMinVariabel)(minKlass*);
/* Ärv huvudklassen */
huvudKlass* huvud;
};
Analogin mellan klasserna är det samma. Skillnaden är att jag MÅSTE skapa strukturen innan jag anropar min konstruktör.
Om jag inte vill göra detta, så måste jag allokera minnet igenom att använda mig utav malloc. Men notera, använder man malloc, så måste man även frigöra minnet sedan via free. Tänk på det!
/* Skapa två klasser */
minKlass minKlass1;
minKlass minKlass2;
huvudKlass huvudKlass1;
huvudKlass huvudKlass2;
/* Viktigt att sätta addresserna från huvudklassen till min klass */
minKlass1.huvud = &huvudKlass1;
minKlass2.huvud = &huvudKlass2;
#include <stdio.h>
typedef struct huvudKlass huvudKlass;
struct huvudKlass{
int huvudVariabel;
void (*setHuvudVariabel)(huvudKlass*, int);
int (*getHuvudVariabel)(huvudKlass*);
};
huvudKlass* huvudKonstruktor(huvudKlass* this){
/* Skapa getter-funktion */
int getHuvudVariabelFunktion(huvudKlass* this){
return this->huvudVariabel;
}
/* Skapa setter-funktion */
void setHuvudVariabelFunktion(huvudKlass* this, int variabel){
this->huvudVariabel = variabel;
}
/* Applicera dessa till pekarfunktionen i klassen */
this->setHuvudVariabel = setHuvudVariabelFunktion;
this->getHuvudVariabel = getHuvudVariabelFunktion;
/* Retunera adressen av våran nya klass */
return this;
}
typedef struct minKlass minKlass;
struct minKlass{
/* Skapa en variabel och getter-setter */
int minVariabel;
void (*setMinVariabel)(minKlass*, int);
int (*getMinVariabel)(minKlass*);
/* Ärv huvudklassen */
huvudKlass* huvud;
};
minKlass* minKonstruktor(minKlass* this){
/* Skapa getter-funktion */
int getMinVariabelFunktion(minKlass* this){
return this->minVariabel;
}
/* Skapa setter-funktion */
void setMinVariabelFunktion(minKlass* this, int variabel){
this->minVariabel = variabel;
}
/* Applicera dessa till pekarfunktionen i klassen */
this->setMinVariabel = setMinVariabelFunktion;
this->getMinVariabel = getMinVariabelFunktion;
/* Anropa konstruktören för huvudklassen */
this->huvud = huvudKonstruktor(this->huvud);
/* Retunera adressen av våran nya klass */
return this;
}
int main(){
/* Skapa två klasser */
minKlass minKlass1;
minKlass minKlass2;
huvudKlass huvudKlass1;
huvudKlass huvudKlass2;
/* Viktigt att sätta addresserna från huvudklassen till min klass */
minKlass1.huvud = &huvudKlass1;
minKlass2.huvud = &huvudKlass2;
/* Passera klassen igenom konstruktören */
minKlass* pMinKlass1 = minKonstruktor(&minKlass1);
minKlass* pMinKlass2 = minKonstruktor(&minKlass2);
/* Sätt ett värde till minKlassen */
pMinKlass1->setMinVariabel(pMinKlass1, 104);
pMinKlass2->setMinVariabel(pMinKlass2, 23);
/* Sätt ett värde till huvudKlassen */
pMinKlass1->huvud->setHuvudVariabel(pMinKlass1->huvud, 200);
pMinKlass2->huvud->setHuvudVariabel(pMinKlass2->huvud, 500);
/* Ta ett värde från klassen */
int minVariabel1 = pMinKlass1->minVariabel;
int minVariabel2 = pMinKlass2->minVariabel;
int huvudVariabel1 = pMinKlass1->huvud->getHuvudVariabel(pMinKlass1->huvud);
int huvudVariabel2 = pMinKlass2->huvud->getHuvudVariabel(pMinKlass2->huvud);
/* Skriv ut värdet */
printf("minVariabel1 = %i, minVariabel2 = %i, huvudVariabel1 = %i, huvudVariabel2 = %i\n", minVariabel1, minVariabel2, huvudVariabel1, huvudVariabel2);
return 0;
}
