Alguma ferramenta conversor de código c++17 para c89? [RESOLVIDO]

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

#define MAX_MAP_SIZE 100

// Base class 'B' (simulated using a struct in C)
typedef struct B {
    int a;
    int (*f)(const struct B *self);  // Virtual function
} B;

// D1 class (derived from B)
typedef struct D1 {
    B base;  // Inheritance: the base class
    int n;
} D1;

// D2 class (derived from B)
typedef struct D2 {
    B base;  // Inheritance: the base class
    int m, n;
} D2;

// Function prototypes
int D1_f(const B *self);
int D2_f(const B *self);
void D1_out(const D1 *self);
void D2_out(const D2 *self);

// Map entry structure
typedef struct MapEntry {
    char name[50];
    B *obj;
} MapEntry;

// Map (array of entries)
MapEntry map[MAX_MAP_SIZE];
int map_size = 0;

// Create D1 object
D1 *create_D1(int a, int n) {
    D1 *d = (D1 *)malloc(sizeof(D1));
    d->base.a = a;
    d->base.f = D1_f;
    d->n = n;
    return d;
}

// Create D2 object
D2 *create_D2(int a, int m, int n) {
    D2 *d = (D2 *)malloc(sizeof(D2));
    d->base.a = a;
    d->base.f = D2_f;
    d->m = m;
    d->n = n;
    return d;
}

// Function implementations
int D1_f(const B *self) {
    const D1 *d = (const D1 *)self;
    return d->base.a + d->n;
}

int D2_f(const B *self) {
    const D2 *d = (const D2 *)self;
    return d->base.a + (d->m + d->n) / 2;
}

void D1_out(const D1 *self) {
    printf("D1(%d, %d)", self->base.a, self->n);
}

void D2_out(const D2 *self) {
    printf("D2(%d, %d, %d)", self->base.a, self->m, self->n);
}

// Add object to map
void add_to_map(const char *name, B *obj) {
    if (map_size < MAX_MAP_SIZE) {
        strcpy(map[map_size].name, name);
        map[map_size].obj = obj;
        map_size++;
    }
}

// Generate a random number in the range [0, r]
int range_rand(double r) {
    return (int)(r * (rand() / (RAND_MAX + 1.0)));
}

int main() {
    srand(time(NULL));

    // Populate the map
    add_to_map("Entrada 1", (B *)create_D1(0, 1));
    add_to_map("Entrada 2", (B *)create_D2(0, 0, 2));

    for (int i = 3; i < 13; ++i) {
        int r = range_rand(5);
        switch (r) {
            case 0: add_to_map("Entrada", (B *)create_D1(i, 1)); break;
            case 1: add_to_map("Entrada", (B *)create_D1(i, r)); break;
            case 2: add_to_map("Entrada", (B *)create_D2(i, 0, 2)); break;
            case 3: add_to_map("Entrada", (B *)create_D2(i, r, 2)); break;
            case 4: add_to_map("Entrada", (B *)create_D2(i, r, range_rand(i + r))); break;
            default: fprintf(stderr, "Unexpected value of r (%d).\n", r); break;
        }
    }

    // Output the contents of the map
    int sum = 0;
    for (int i = 0; i < map_size; i++) {
        printf("%s: ", map[i].name);
        if (map[i].obj->f == D1_f) {
            D1_out((D1 *)map[i].obj);
        } else if (map[i].obj->f == D2_f) {
            D2_out((D2 *)map[i].obj);
        }
        int f_val = map[i].obj->f(map[i].obj);
        printf("; f()=%d\n", f_val);
        sum += f_val;
    }

    printf("\nSum of f() values = %d.\n", sum);

    // Free allocated memory
    for (int i = 0; i < map_size; i++) {
        free(map[i].obj);
    }

    return 0;
} 

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

#define MAX_MAP_SIZE 100

// Define a base class "B" with a virtual function "f"
typedef struct B {
    int a;
    int (*f)(const struct B *self);  // Virtual function pointer
} B;

// Define a "D1" class that derives from "B"
typedef struct D1 {
    B base;  // Inherit B
    int n;
} D1;

// Define a "D2" class that derives from "B"
typedef struct D2 {
    B base;  // Inherit B
    int m, n;
} D2;

// Define a structure to hold map entries
typedef struct MapEntry {
    char name[50];
    B *obj;
} MapEntry;

// Declare a map with fixed size
MapEntry map[MAX_MAP_SIZE];
int map_size = 0;

// Function prototypes for constructors, methods, and map operations
D1 *create_D1(int a, int n);
D2 *create_D2(int a, int m, int n);
int D1_f(const B *self);
int D2_f(const B *self);
void D1_out(const D1 *self);
void D2_out(const D2 *self);
void add_to_map(const char *name, B *obj);
int range_rand(double r);
int find_map_index(const char *name);

// Create D1 object
D1 *create_D1(int a, int n) {
    D1 *d = (D1 *)malloc(sizeof(D1));
    d->base.a = a;
    d->base.f = D1_f;
    d->n = n;
    return d;
}

// Create D2 object
D2 *create_D2(int a, int m, int n) {
    D2 *d = (D2 *)malloc(sizeof(D2));
    d->base.a = a;
    d->base.f = D2_f;
    d->m = m;
    d->n = n;
    return d;
}

// D1's virtual function: f()
int D1_f(const B *self) {
    const D1 *d = (const D1 *)self;
    return d->base.a + d->n;
}

// D2's virtual function: f()
int D2_f(const B *self) {
    const D2 *d = (const D2 *)self;
    return d->base.a + (d->m + d->n) / 2;
}

// Output method for D1
void D1_out(const D1 *self) {
    printf("D1(%d, %d)", self->base.a, self->n);
}

// Output method for D2
void D2_out(const D2 *self) {
    printf("D2(%d, %d, %d)", self->base.a, self->m, self->n);
}

// Add object to the map
void add_to_map(const char *name, B *obj) {
    if (map_size < MAX_MAP_SIZE) {
        strcpy(map[map_size].name, name);
        map[map_size].obj = obj;
        map_size++;
    }
}

// Generate a random number in the range [0, r]
int range_rand(double r) {
    return (int)(r * (rand() / (RAND_MAX + 1.0)));
}

// Find an entry in the map by name
int find_map_index(const char *name) {
    for (int i = 0; i < map_size; i++) {
        if (strcmp(map[i].name, name) == 0) {
            return i;
        }
    }
    return -1;
}

int main() {
    srand(time(NULL));

    // Create map m1
    add_to_map("Entrada 1", (B *)create_D1(0, 1));
    add_to_map("Entrada 2", (B *)create_D2(0, 0, 2));

    for (int i = 3; i < 13; ++i) {
        int r = range_rand(5);
        switch (r) {
            case 0: add_to_map("Entrada", (B *)create_D1(i, 1)); break;
            case 1: add_to_map("Entrada", (B *)create_D1(i, r)); break;
            case 2: add_to_map("Entrada", (B *)create_D2(i, 0, 2)); break;
            case 3: add_to_map("Entrada", (B *)create_D2(i, r, 2)); break;
            case 4: add_to_map("Entrada", (B *)create_D2(i, r, range_rand(i + r))); break;
            default: break;
        }
    }

    // Print the contents of m1
    int sum = 0;
    for (int i = 0; i < map_size; i++) {
        printf("%s: ", map[i].name);
        if (map[i].obj->f == D1_f) {
            D1_out((D1 *)map[i].obj);
        } else if (map[i].obj->f == D2_f) {
            D2_out((D2 *)map[i].obj);
        }
        int f_val = map[i].obj->f(map[i].obj);
        printf("; f()=%d\n", f_val);
        sum += f_val;
    }
    printf("Soma dos f()s do mapa 1: %d.\n\n", sum);

    // Create map m2
    MapEntry map2[MAX_MAP_SIZE];
    int map2_size = 0;

    for (int i = 0; i < 50; i += 3) {
        char s[50];
        sprintf(s, "Entrada %d", i);
        int index = find_map_index(s);
        if (index != -1) {
            add_to_map(s, map[index].obj);
        }
    }

    // Print the contents of m2
    sum = 0;
    for (int i = 0; i < map2_size; i++) {
        printf("%s: ", map2[i].name);
        if (map2[i].obj->f == D1_f) {
            D1_out((D1 *)map2[i].obj);
        } else if (map2[i].obj->f == D2_f) {
            D2_out((D2 *)map2[i].obj);
        }
        int f_val = map2[i].obj->f(map2[i].obj);
        printf("; f()=%d\n", f_val);
        sum += f_val;
    }
    printf("Soma dos f()s do mapa 2: %d.\n\n", sum);

    // Free allocated memory
    for (int i = 0; i < map_size; i++) {
        free(map[i].obj);
    }

    return 0;
} 

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

#define MAX_MAP_SIZE 100

// Define a base class "B" with a virtual function "f"
typedef struct B {
    int a;
    int (*f)(const struct B *self);  // Virtual function pointer
} B;

// Define a "D1" class that derives from "B"
typedef struct D1 {
    B base;  // Inherit B
    int n;
} D1;

// Define a "D2" class that derives from "B"
typedef struct D2 {
    B base;  // Inherit B
    int m, n;
} D2;

// Define a structure to hold map entries
typedef struct MapEntry {
    char name[50];
    B *obj;
} MapEntry;

// Declare a map with fixed size
MapEntry map[MAX_MAP_SIZE];
int map_size = 0;

// Function prototypes for constructors, methods, and map operations
D1 *create_D1(int a, int n);
D2 *create_D2(int a, int m, int n);
int D1_f(const B *self);
int D2_f(const B *self);
void D1_out(const D1 *self);
void D2_out(const D2 *self);
void add_to_map(MapEntry *map, int *map_size, const char *name, B *obj);
int range_rand(double r);
int find_map_index(MapEntry *map, int map_size, const char *name);

// Create D1 object
D1 *create_D1(int a, int n) {
    D1 *d = (D1 *)malloc(sizeof(D1));
    d->base.a = a;
    d->base.f = D1_f;
    d->n = n;
    return d;
}

// Create D2 object
D2 *create_D2(int a, int m, int n) {
    D2 *d = (D2 *)malloc(sizeof(D2));
    d->base.a = a;
    d->base.f = D2_f;
    d->m = m;
    d->n = n;
    return d;
}

// D1's virtual function: f()
int D1_f(const B *self) {
    const D1 *d = (const D1 *)self;
    return d->base.a + d->n;
}

// D2's virtual function: f()
int D2_f(const B *self) {
    const D2 *d = (const D2 *)self;
    return d->base.a + (d->m + d->n) / 2;
}

// Output method for D1
void D1_out(const D1 *self) {
    printf("D1(%d, %d)", self->base.a, self->n);
}

// Output method for D2
void D2_out(const D2 *self) {
    printf("D2(%d, %d, %d)", self->base.a, self->m, self->n);
}

// Add object to the given map
void add_to_map(MapEntry *map, int *map_size, const char *name, B *obj) {
    if (*map_size < MAX_MAP_SIZE) {
        strcpy(map[*map_size].name, name);
        map[*map_size].obj = obj;
        (*map_size)++;
    }
}

// Generate a random number in the range [0, r]
int range_rand(double r) {
    return (int)(r * (rand() / (RAND_MAX + 1.0)));
}

// Find an entry in the map by name
int find_map_index(MapEntry *map, int map_size, const char *name) {
    for (int i = 0; i < map_size; i++) {
        if (strcmp(map[i].name, name) == 0) {
            return i;
        }
    }
    return -1;
}

int main() {
    srand(time(NULL));

    // Create map m1
    add_to_map(map, &map_size, "Entrada 1", (B *)create_D1(0, 1));
    add_to_map(map, &map_size, "Entrada 2", (B *)create_D2(0, 0, 2));

    for (int i = 3; i < 13; ++i) {
        int r = range_rand(5);
        switch (r) {
            case 0: add_to_map(map, &map_size, "Entrada", (B *)create_D1(i, 1)); break;
            case 1: add_to_map(map, &map_size, "Entrada", (B *)create_D1(i, r)); break;
            case 2: add_to_map(map, &map_size, "Entrada", (B *)create_D2(i, 0, 2)); break;
            case 3: add_to_map(map, &map_size, "Entrada", (B *)create_D2(i, r, 2)); break;
            case 4: add_to_map(map, &map_size, "Entrada", (B *)create_D2(i, r, range_rand(i + r))); break;
            default: break;
        }
    }

    // Print the contents of m1
    int sum = 0;
    for (int i = 0; i < map_size; i++) {
        printf("%s: ", map[i].name);
        if (map[i].obj->f == D1_f) {
            D1_out((D1 *)map[i].obj);
        } else if (map[i].obj->f == D2_f) {
            D2_out((D2 *)map[i].obj);
        }
        int f_val = map[i].obj->f(map[i].obj);
        printf("; f()=%d\n", f_val);
        sum += f_val;
    }
    printf("Soma dos f()s do mapa 1: %d.\n\n", sum);

    // Create map m2
    MapEntry map2[MAX_MAP_SIZE];
    int map2_size = 0;

    for (int i = 0; i < 50; i += 3) {
        char s[50];
        sprintf(s, "Entrada %d", i);
        int index = find_map_index(map, map_size, s);
        if (index != -1) {
            add_to_map(map2, &map2_size, s, map[index].obj);
        }
    }

    // Print the contents of m2
    sum = 0;
    for (int i = 0; i < map2_size; i++) {
        printf("%s: ", map2[i].name);
        if (map2[i].obj->f == D1_f) {
            D1_out((D1 *)map2[i].obj);
        } else if (map2[i].obj->f == D2_f) {
            D2_out((D2 *)map2[i].obj);
        }
        int f_val = map2[i].obj->f(map2[i].obj);
        printf("; f()=%d\n", f_val);
        sum += f_val;
    }
    printf("Soma dos f()s do mapa 2: %d.\n\n", sum);

    // Free allocated memory
    for (int i = 0; i < map_size; i++) {
        free(map[i].obj);
    }

    return 0;
}