Best way to store different structs in same array in c - arrays

Question

If I have multiple structs which have a common method like this:
typedef struct s sphere;
typedef struct s{
point3 center;
double radius;
bool (*hit)(sphere, const ray*, double, double, hit_record*);
} sphere;
typedef struct b box;
typedef struct b{
point3 center;
double radius;
bool (*hit)(box, const ray*, double, double, hit_record*);
} box;
Is it possible for me to create some type of array such that it can store both of these structs and loop through it calling the method like this:
objects shapes[50]; // Where objects is something that can let shapes hold both structs
//Pretend shapes has a mixture of Boxes and Spheres
int number_of_shapes = 20;
for (int i = 0; i < number_of_shapes;i++){
if shapes[i].hit(shapes[i], r, t, t, red) { //random variables
;// do something
}
}
I just started learning c yesterday so I am not really sure what to do. I tried using void pointers but that also failed miserably.

Answer 1

Void pointers are the right way to do that, but it requires that your objects are persistent in memory, because an array of pointers won't retain them. I give you an example :
EDIT : I update the example to do the job using function pointers and simulate the behavior of methods.
#include <stdio.h>
#include <stdlib.h>
// Type your code here, or load an example.
enum { TypeSphere, TypeBox };
typedef struct s sphere;
typedef struct b box;
typedef char (*hit)(void *object, void *ray, double x, double y, void*hit_record);
// Starts both structure with a common function pointer type
typedef struct s{
hit method;
double center;
double radius;
} sphere;
typedef struct b{
hit method;
double center;
double radius;
} box;
// Implementation of a method for each type
char sphereMethod(void *s, void *ray, double x, double y, void *hit_record) {
printf("A sphere\n");
}
char boxMethod(void *b, void *ray, double x, double y, void *hit_record) {
printf("A box\n");
}
int main() {
void* objects[50];
// Allocates 25 objects of each type for the example
for(int i=0; i<50; i+=2) {
objects[i] = malloc(sizeof(sphere));
// Sets the implementation here
((sphere *)objects[i])->method = sphereMethod;
objects[i+1] = malloc(sizeof(box));
((box *)objects[i+1])->method = boxMethod;
}
// Loops through objects and calls the methods
for(int i=0; i<50; i++) {
hit method = *((hit *)objects[i]);
method(objects[i], NULL, 0, 0, NULL);
}
// Frees them
for(int i=0; i<50; i++) { free(objects[i]); }
}

Answer 2

Here is a rough cut of how you might achieve your objective...
enum { BOX, SPHERE } types;
typedef struct sphere {
point3 center;
double radius;
} sphere_t;
typedef struct box {
point3 center;
double len, wid, dpth;
double rotX, rotY, rotZ;
} box_t;
typedef object {
int type;
union {
sphere_t sphere;
box_t box;
};
} object_t;
int main() {
object_t objs[ 50 ];
/* ... */
for( int i = 0; i < numObjs; i++ )
switch( objs[ i ].type ) {
case BOX:
hndlr_Box( objs[i].box );
break;
case SPHERE:
hndlr_Sphere( objs[i].sphere );
break;
/* ... */
}
}
Looking back at that, it might be even better to use a linked list of objects instead of an array.
AND, each object instance in the array will consume as much memory as is required for the largest of the union. It may be better to use pointers to separately allocated blocks, each storing only its particular attributes.

Answer 3

If you create a sufficiently complicated enough object, you should be able to accomplish something pretty close to your goal. Below, I sketch out a solution that you should be able to build upon.
First, we define a Shape as having a ShapeInterface, which for now is just something that can be hit.
typedef struct HitRecord HitRecord;
typedef struct Ray Ray;
typedef struct Shape {
const struct ShapeInterface * const vtable;
} Shape;
struct ShapeInterface {
bool (*hit)(Shape *, const Ray *, double, double, HitRecord *);
void (*dump)(Shape *);
};
bool shape_hit (Shape *s, const Ray *r, double x, double y, HitRecord *hr) {
return s->vtable->hit(s, r, x, y, hr);
}
void shape_dump (Shape *s) {
s->vtable->dump(s);
}
Then, we define Sphere and Box to be kinds of Shape.
typedef struct Point3 {
double p[3];
} Point3;
typedef struct Sphere {
Shape base;
Point3 center;
double radius;
bool popped;
} Sphere;
typedef struct Box {
Shape base;
Point3 center;
double radius;
bool crushed;
} Box;
Now, define Objects to be a union of these different kinds of Shape. We note that all items in Objects have a common initial sequence, which is Shape.
typedef union Objects {
Shape shape;
Sphere sphere;
Box box;
} Objects;
When you have an array of Objects, you can loop through and call shape_hit on the shape member.
void process_hit_objects (
Objects shapes[],
int number_of_shapes,
const Ray *r, double x, double y, HitRecord *hr) {
for (int i = 0; i < number_of_shapes; ++i) {
if (shape_hit(&shapes[i].shape, r, x, y, hr)) {
/* ... do something ... */
shape_dump(&shapes[i].shape);
}
}
}
When creating a Sphere, it needs to initialize its base member with an appropriate implementations for the functions in its vtable.
static bool sphere_hit (
Shape *shape, const Ray *r, double x, double y, HitRecord *hr) {
Sphere *sphere = (void *)shape;
return sphere->popped;
}
static void sphere_dump (Shape *shape) {
Sphere *sphere = (void *)shape;
double *p = sphere->center.p;
printf("sphere: %p # <%f,%f,%f> |%f|\n",
(void *)sphere, p[0], p[1], p[2], sphere->radius);
}
void makeSphere (Sphere *s, Point3 center, double radius) {
static const struct ShapeInterface vtable = {
sphere_hit, sphere_dump
};
Shape base = { &vtable };
Sphere sphere = { base, center, radius, true };
memcpy(s, &sphere, sizeof(sphere));
}
Similarly for a Box.
static bool box_hit (
Shape *shape, const Ray *r, double x, double y, HitRecord *hr) {
Box *box = (void *)shape;
return box->crushed;
}
static void box_dump (Shape *shape) {
Box *box = (void *)shape;
double *p = box->center.p;
printf("box: %p # <%f,%f,%f> |%f|\n",
(void *)box, p[0], p[1], p[2], box->radius);
}
void makeBox (Box *b, Point3 center, double radius) {
static const struct ShapeInterface vtable = {
box_hit, box_dump
};
Shape base = { &vtable };
Box box = { base, center, radius, true };
memcpy(b, &box, sizeof(box));
}