नमस्ते, मैं वर्तमान में सी सीखने का प्रयास कर रहा हूं और मैं सोच रहा था कि क्या संरचनाओं में बहुरूपता प्राप्त करने का कोई तरीका है जिसमें अन्य विभिन्न प्रकार की संरचनाओं की सूची है?

इसका एक उदाहरण मामला इस प्रकार है:

  #include <stdlib.h>
#include <stdio.h>

typedef void (*update_t)(void *);

typedef struct entity entity_t;
typedef struct compA compA_t;
typedef struct compB compB_t;


struct compA{

    update_t update;
};

struct compB{

    update_t update;
};

struct entity{
    update_t update;
    int curSize;
    void **components;
};


void compA_update(void *c){
    printf("updating: componentA\n");
}

compA_t *compA_create(){
    compA_t *c = malloc(sizeof(compA_t));
    c->update = compA_update;
    return c; 
}

void compB_update(void *c){
    printf("updating: componentB\n");
}


compB_t *compB_create(){
    compB_t *c = malloc(sizeof(compB_t));
    c->update = compB_update;
    return c; 
}


void entity_update(void *en){
    entity_t *e = (entity_t *)en;
    for(int i = 0; i < e->curSize; i++){
        //would like to somehow update all the components with one line just iterating through the array but does not seem possible
    }
    return;
}



entity_t *entity_create(){
    entity_t *e = malloc(sizeof(entity_t));
    e->curSize = 0;
    e->update = entity_update;
    calloc(32, sizeof(void *));
    return e;
}

void add_component(entity_t *e, void *c){
    printf("%d\n", e->curSize);
    e->components[e->curSize] = c;
    e->curSize++;
    return;
}




int main(void){

    entity_t *e = entity_create();
    compA_t *a = compA_create();
    compB_t *b = compB_create();
    add_component(e, a);
    add_component(e, b);

    e->update(e);

    return 0;
}

अब तक इस समस्या के लिए मेरे दृष्टिकोण को एक टपल संरचना के शून्य सूचक सरणियों के साथ हल किया गया है जिसमें एक एनम प्रकार होता है जो संरचना के साथ-साथ संरचना की पहचान करता है और फिर संभावित अद्यतन फ़ंक्शन में एक काफी बदसूरत स्विच स्टेटमेंट को लागू करना होता है प्रत्येक विशिष्ट प्रकार के लिए एक मामला।

क्या ऐसा करने के लिए इससे अच्छा तरीका है? यदि सरणी के भीतर बहुत से विभिन्न प्रकार हैं तो स्विच दृष्टिकोण काफी तेजी से पागल हो जाएगा। जिसका अर्थ है कि प्रत्येक प्रकार के लिए स्पष्ट रूप से मामलों को जोड़ना चाहिए और प्रत्येक मामला बिल्कुल वही काम करता है, जिसे इस मामले में "अपडेट" नामक फ़ंक्शन पॉइंटर कहा जाता है।

1
user10632986 10 नवम्बर 2018, 16:11

1 उत्तर

सबसे बढ़िया उत्तर

आप फ़ंक्शन पॉइंटर के बजाय डेटा बहुरूपता का प्रयास कर सकते हैं। यही है, अलग-अलग डेटा एक ही कोड का उपयोग करके अलग-अलग व्यवहार उत्पन्न करते हैं।

उदाहरण के लिए, एक साधारण बहुरूपी व्यवहार:

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <assert.h>

typedef const char* ccstr;

typedef struct animal_attr_t
{
    bool is_body_segmented;
    float gill_completeness;
    float lung_completeness;
} animal_attr_t;

typedef struct species
{
    ccstr name, kingdom, domain;

    animal_attr_t animal_attr[0];
} species;

void initialize_species_base(species *this, ccstr name, ccstr kingdom, ccstr domain)
{
    this->name = name;
    this->kingdom = kingdom;
    this->domain = domain;
}

void initialize_animal_attr(animal_attr_t *this, bool is_body_segmented, float gill_completenss, float lung_completeness)
{
    this->is_body_segmented = is_body_segmented;
    this->gill_completeness = gill_completenss;
    this->lung_completeness = lung_completeness;
}

void print_species(species*);

int main(int argc, char *argv[])
{
    species *yeast = calloc(sizeof(species), 1);
    assert(yeast);

    initialize_species_base(yeast, "yeast", "fungus", "eukaryote");

    print_species(yeast);

    species *dog = calloc(sizeof(species) + sizeof(animal_attr_t), 1);
    assert(dog);

    initialize_species_base(dog, "dog", "animal", "eukaryote");
    initialize_animal_attr(dog->animal_attr, true, 0.0f, 1.0f);

    print_species(dog);

    free(yeast);
    free(dog);
}

void print_species(species *this)
{
    printf("name = %s, kingdom = %s, domain = %s",
           this->name, this->kingdom, this->domain);

    if (strcmp(this->kingdom, "animal") == 0) {
        animal_attr_t *ani_attr = this->animal_attr;
        printf(", has %s, %f completeness of gill, %f completeness of lung",
               ani_attr->is_body_segmented ? "segmented body" : "unsegmented body",
               ani_attr->gill_completeness, ani_attr->lung_completeness);
    }

    printf(".\n");
}

yeast और dog 2 पूरी तरह से अलग प्रकार हैं, फिर भी species के साथ इसे एकीकृत तरीके से व्यक्त किया जाता है और print_species में बहुरूपी व्यवहार होता है।

0
JiaHao Xu 10 नवम्बर 2018, 14:07