1. Introduction
Ang wika ng C ay minamahal ng maraming programmer dahil sa kanyang makasaysayang background at low-level control. Gayunpaman, ang C ay hindi isang object-oriented na wika. Sa ibang salita, hindi katulad ng Java o C++, ang C mismo ay hindi natural na sumusuporta sa mga tampok ng object-oriented programming tulad ng classes, inheritance, o encapsulation. Gayunpaman, posible na tularan ang mga konsepto ng object-oriented programming (OOP) sa C at makamit ang isang tiyak na antas ng functionality ng OOP. Sa artikulong ito, ipapaliwanag namin kung paano mo maaaring i-implement ang object-oriented programming sa C, na nakatuon sa mga pangunahing konsepto ng encapsulation, inheritance, at polymorphism.
2. Basic Concepts of Object-Oriented Programming
Ang object-oriented programming (OOP) ay naglalayong pamahalaan ang data at ang mga method na gumagana sa data na iyon bilang isang yunit. Tumutulong ang diskarteng ito na linawin ang istraktura ng programa at mapabuti ang reusability at maintainability. Ang mga pangunahing konsepto sa OOP ay encapsulation, inheritance, at polymorphism. Bagaman hindi direktang sumusuporta ang C sa mga tampok na ito, sa ilang katalinuhan, maaari mong i-implement ang mga ito nang katulad.
2.1 Encapsulation
Ang encapsulation ay nangangahulugang paggrupo ng data at ang mga operasyon nito (methods) bilang isang yunit at pagkontrol sa access mula sa labas. Sa C, maaari mong paggrupo ang data gamit ang structs. Ang mga struct ay gumaganap ng katulad na papel sa classes sa paraang pinagsasama nito ang maraming piraso ng data sa isang istraktura.
typedef struct {
int age;
char name[50];
} Person;
Sa struct na ito, ang data type na Person ay nag-encapsulate ng parehong impormasyon ng age at name. Pinapayagan nito ang paglikha at pag-ooperate sa mga instance ng Person.
2.2 Inheritance
Wala munang native na tampok ng inheritance ang C, kaya hindi mo maaaring lumikha ng mga relasyon ng parent-child tulad ng ginagawa mo sa classes. Gayunpaman, sa pamamagitan ng paglalagay ng isang struct bilang miyembro ng isa pa, maaari kang makamit ang isang mekanismo na katulad ng inheritance.
typedef struct {
int age;
} Parent;
typedef struct {
Parent parent;
int studentID;
} Child;
Sa kodeng ito, ang struct na Child ay naglalaman ng isang struct na Parent, na kumakatawan sa isang anyo ng pseudo-inheritance.
2.3 Polymorphism
Ang polymorphism ay nangangahulugang kakayahang kumilos nang iba-iba ang parehong operasyon depende sa uri ng object. Sa C, maaari mong makamit ito gamit ang function pointers. Ang function pointer ay isang variable na nagdadala ng address ng isang function, na nagbibigay-daan sa iyo na tawagin nang dinamiko ang iba’t ibang functions.
typedef int (*OperationFunc)(int, int);
int add(int a, int b) {
return a + b;
}
int multiply(int a, int b) {
return a * b;
}
OperationFunc op = add; // Set to add function
printf("%d", op(3, 4)); // Output: 7
op = multiply; // Switch to multiply function
printf("%d", op(3, 4)); // Output: 12
Tulad ng ipinapakita, maaari kang gumawa ng iba’t ibang operasyon gamit ang parehong function pointer.
3. How to Implement Classes in C
Upang dalhin ang object-oriented programming sa C, kailangan mong simulahin ang konsepto ng classes. Ito ay ginagawa sa pamamagitan ng pagkakakabit ng structs at function pointers upang lumikha ng mga istraktura na katulad ng class.
3.1 Using Structs as Classes
Upang i-implement ang classes sa C, gumamit ng structs upang paggrupo ang data at methods nang magkasama. Ang mga method ay tinutukoy bilang functions at pinapamahalaan sa loob ng struct gamit ang function pointers.
typedef struct {
int age;
void (*setAge)(struct Person*, int);
int (*getAge)(struct Person*);
} Person;
void setAge(struct Person* p, int age) {
p->age = age;
}
int getAge(struct Person* p) {
return p->age;
}
Person person = {0, setAge, getAge};
person.setAge(&person, 25);
printf("Age: %d", person.getAge(&person)); // Output: 25
Sa halimbawang ito, ang struct na Person ay may mga method na setAge at getAge, na nagbibigay-daan sa pag-uugali na katulad ng class.
4. Implementing Methods
Upang muling likhain ang “methods,” isang pangunahing tampok ng OOP, sa C, gumamit ng function pointers. Pinapayagan nito ang pagtukoy ng methods bilang mga miyembro ng struct.
typedef struct {
int age;
void (*setAge)(struct Person*, int);
} Person;
void setAge(struct Person* p, int age) {
p->age = age;
}
5. Summary and Applications
Bagaman maaari mong ipatupad ang mga tampok na object‑oriented sa C, tandaan na ang wika mismo ay hindi likas na sumusuporta sa OOP. Kakailanganin mo ng kaunting pagkamalikhain, gamit nang lubos ang mga struct, function pointer, at pamamahala ng memorya upang isama ang mga konsepto ng klase at kahalintulad ng inheritance.
