OOP_C[0] = “Composition Nedir ?”

Kafanızı kaldırmanızı ve çevrenize bakmanızı istiyorum. Bilinçli olmayan bir şekilde çevrenizde bulunan nesneleri ve o nesnelerin diğer nesneler arasında bulunan ilişkiyi kurabiliyorsunuz. Baktığınız nesnenin bir masa olduğunu düşünelim o masanın üzerinde bir bardak olsun. Tahmin edebileceğiniz üzere ne o bardak ne de o masanın yaşam süreleri birbirine bağlı. Masanın üzerinde o bardak olmasaydı, o masanın yaşam döngüsü bitmiyor ya da masa olmasaydı o bardağın.

Not : Masayı yere çarptım al gördün mü bardağı mı ?

Peki, bu yazıyı okumak için kullandığınız cihazı düşünelim ve bu bir bilgisayar olsun. Bu bilgisayarı oluşturan RAM ile Bilgisayarınız arasında bulunan ilişki sizce masa ve bardak arasında beliren ilişki ile aynı mı? Kısa cevap : Hayır. Bilgisayar bir ram değildir ama bilgisayar bir ram’e sahiptir. Yani burada bir sahiplik(has-a) ilişkisi vardır.

Bilgisayarın oluşmasını sağlayan bir dizi parça var ve bunların arasında bulunan sahiplik ilişkisi bize nesne yönelimli programlama yaklaşımında bir terim doğuruyor. Hoşgelmişsen “Composition”.

Şimdi bir senaryo düşünelim ve C dilinde nesne yönelimli programlama yapmaya çalışalım. Çok uzağa gitmeden evlerimizin mutfağında bulunan bir cihaz, o ki annelerimizin gözdesi. Bulaşık Makinesi. Bulaşık makinesini oluşturan parça olarak ventil’i seçelim. Yani makinenin temiz su ihtiyacı olduğunda devreye giren bir valf. Umarım bir gün bu parça bozulmaz.

Biraz “hiding information” yaparak kodumuzu yazalım. Öncelikle bulaşık makinesi ve sonra valf için bir header dosyası oluşturuyorum.

#ifndef WASHING_MACH_H
#define WASHING_MACH_H

struct washing_machine_t;

//Memory Allocator
struct washing_machine_t* washing_machine_new(void);

//Constructor
void washing_machine_ctor (struct washing_machine_t*);

//Destructor
void washing_machine_dtor (struct washing_machine_t*);

//Behaviour Functions
void washing_machine_start (struct washing_machine_t*);
void washing_machine_stop (struct washing_machine_t*);
void washing_machine_get_water (struct washing_machine_t*);
int washing_machine_get_used_water (struct washing_machine_t*);


#endif 
#ifndef VALVE_H
#define VALVE_H

struct valve_t;

//Memory Allocator
struct valve_t* valve_new(void);

//Constructor
void valve_ctor(struct valve_t*);

//Destructor 
void valve_dtor(struct valve_t*);

//Behaviour Functions
void valve_start(struct valve_t*);
void valve_stop(struct valve_t*);
void valve_add_used_water(struct valve_t*);
int valve_get_water(struct valve_t*);

#endif

.h dosyalarında ne yapmak istediğimizi anlattık, .c dosyalarında ise nasıl yapacağımızı açıklayalım.

#include "stdlib.h"
#include "valve.h"

typedef struct 
{
    struct valve_t* valve;

}washing_machine_t;

washing_machine_t* washing_machine_new(void)
{
    return (washing_machine_t*)malloc(sizeof(washing_machine_t));
}

void washing_machine_ctor(washing_machine_t* self)
{
    self -> valve = valve_new();

    valve_ctor(self -> valve);
}

void washing_machine_dtor(washing_machine_t* self)
{
    valve_dtor(self -> valve);

    free(self -> valve);
}

void washing_machine_start(washing_machine_t* self)
{
    valve_start(self -> valve);
}

void washing_machine_stop(washing_machine_t* self)
{
    valve_stop(self -> valve);
}

void washing_machine_get_water(washing_machine_t* self)
{
    valve_add_used_water(self -> valve);
}

int washing_machine_get_used_water(washing_machine_t* self)
{
    return valve_get_water(self -> valve);
}
#include "stdlib.h"
#include "stdint.h"

typedef enum
{
    ON,
    OFF,

}valve_state;

typedef struct 
{
    valve_state state;
    uint8_t used_water_as_lt;

}valve_t;

valve_t* valve_new(void)
{
    return (valve_t*)malloc(sizeof(valve_t));
}

void valve_ctor(valve_t* self)
{
    self -> state = OFF;
    self -> used_water_as_lt = 0;
}

void valve_dtor(valve_t* self)
{
    //Nothing to do
}

void valve_start(valve_t* self)
{
    if(self -> state == ON) return;

    self -> state = ON;
    self -> used_water_as_lt = 2;
}

void valve_stop(valve_t* self)
{
    if(self -> state == OFF) return;

    self -> state = OFF;
}

void valve_add_used_water(valve_t* self)
{
    self -> used_water_as_lt += 4;
}

int valve_get_water(valve_t* self)
{
    return self -> used_water_as_lt;
}
#include "stdio.h"
#include "string.h"
#include "stdlib.h"

#include "washingmach.h"

int main()
{
    struct washing_machine_t* wm = washing_machine_new();

    washing_machine_ctor(wm);

    printf("Used of water before starting = %d \r\n", washing_machine_get_used_water(wm));

    washing_machine_start(wm);

    printf("Used of water after starting = %d \r\n", washing_machine_get_used_water(wm));

    // Now, we needed extra  water
    washing_machine_get_water(wm);

    washing_machine_stop(wm);

    printf("Total water, we used = %d  \r\n", washing_machine_get_used_water(wm));

    washing_machine_dtor(wm);

}
PS C:\Users\volkan.unal\Desktop\Blog> gcc .\valve.c .\washingmach.c .\main.c
PS C:\Users\volkan.unal\Desktop\Blog> .\a.exe
Used of water before starting = 0
Used of water after starting = 2
Total water, we used = 6

Bu ilişkide dikkat etmeniz gereken noktalara gelelim :

  • oluşturulan nesnenin hayatı sonlandırılmadan önce onu oluşturan nesnelerin hayatları sonlandırılır.
  • has-a ilişkisi vardır.
  • İlişkinin belirlenmesinde çalışılan problemin etkinlik alanı önemlidir.

Yanlışım var ise ya da eklemek istedikleriniz var ise bunları bana mutlaka bildirin. Yeni şeyler öğrenmek en büyük tutkum.

Bir Cevap Yazın

Please log in using one of these methods to post your comment:

WordPress.com Logosu

WordPress.com hesabınızı kullanarak yorum yapıyorsunuz. Çıkış  Yap /  Değiştir )

Google fotoğrafı

Google hesabınızı kullanarak yorum yapıyorsunuz. Çıkış  Yap /  Değiştir )

Twitter resmi

Twitter hesabınızı kullanarak yorum yapıyorsunuz. Çıkış  Yap /  Değiştir )

Facebook fotoğrafı

Facebook hesabınızı kullanarak yorum yapıyorsunuz. Çıkış  Yap /  Değiştir )

Connecting to %s