Is it possible to pass a reference to a fixed size array of non primitive type?

[colt]

Hello. I want to pass to a certain function, a reference to a fixed size array of a user defined struct "Sphere":

void trace (Image& image, Sphere (&sphere_array) [3]) {

However this results in:

main.cpp:39:29: error: invalid initialization of reference of type ‘Sphere (&)[3]’ from expression of type ‘Sphere [n_spheres]’
    trace (image,sphere_array);
                             ^
main.cpp:24:6: note: in passing argument 2 of ‘void trace(Image&, Sphere (&)[3])’
 void trace (Image&, Sphere (&) [3]);

However,if I change

void trace (Image& image, Sphere (&inArray) [3])

to:

void trace (Image& image, int (&in_array) [4])

it works. Can't the compiler deduce the array size when using use defined types? Is that the cause? Is there a workaround to make it work? Anyway, I assume I will have to put the array inside a struct and pass it by reference instead, which probably I am going to do in the future anyway.

[john.c]

Can't the compiler deduce the array size when using use defined types?

Of course it can. There must be some difference that you aren't disclosing. Are you perhaps using a variable-sized array for the Spheres?

[thmm]

More in the spirit of C++ is to use std::array.

[colt]

Of course it can. There must be some difference that you aren't disclosing. Are you perhaps using a variable-sized array for the Spheres?

No, just a fixed size one. Bellow the full code:

#include <iostream>

using namespace std;

struct Vec3f {
    float x,y,z;
};

struct Image {
   int height,width,bpp;
};

struct Camera {
    Vec3f origin;
    Vec3f dir;
};

struct Sphere {
    Vec3f origin;
    Vec3f normal;
    float radius;
};

void trace (Image&, Sphere (&) [3]);

main () {
   Image image;
   image.height=768, image.width=1024, image.bpp=4;
   int n_spheres=3;
   int test_array [n_spheres];
   Sphere sphere_array [n_spheres];
   sphere_array[0].origin.x=700,sphere_array[0].origin.y=700,sphere_array[0].origin.z=100;
   sphere_array [0].radius=100;
   sphere_array[1].origin.x=300,sphere_array[1].origin.y=300,sphere_array[1].origin.z=100;
   sphere_array[1].radius=100;
   sphere_array[2].origin.x=500,sphere_array[2].origin.y=500,sphere_array[2].origin.z=100;
   sphere_array[2].radius=100;
   trace (image,sphere_array);
}

void trace (Image& image, Sphere (&sphere_array) [3]) {
   unsigned char pixel_array [image.height*image.width*image.bpp];
   Camera camera;
    camera.origin.x=512, camera.origin.y=384, camera.origin.z=0;
    camera.dir.x=0, camera.dir.y=0, camera.dir.z=1;
    int recursion_level=0;
    for (int y=0; y<image.height; y++) {
        for (int x=0; y<image.width; y++) {
            camera.dir.x=x, camera.dir.y=y, camera.dir.z=1;
            for (int z=0; z<3; z++) {

            }

        }
    }
}

[john.c]

That isn't a fixed-sized array since n_spheres is a variable.
pixel_array is also obviously variable-sized.
You should be getting warnings about variable-sized arrays being forbidden in standard C++.

I don't understand why you want to pass it as a reference.

#include <iostream>
using namespace std;
 
struct Vec3f {
    float x,y,z;
};
 
struct Image {
   int height, width, bpp;
};
 
struct Camera {
    Vec3f origin;
    Vec3f dir;
};
 
struct Sphere {
    Vec3f origin;
    Vec3f normal;
    float radius;
};
 
void trace(const Image& image, const Sphere sphere_array[]) {
    auto pixel_array = new unsigned char[image.height * image.width * image.bpp];
    Camera camera { {512, 384, 0}, {0, 0, 1} };
    for (int y = 0; y < image.height; y++) {
        for (int x = 0; y < image.width; y++) {
            camera.dir = {float(x), float(y), 1};
            for (int z = 0; z < 3; z++) {
            }
        }
    }
    delete[] pixel_array;
}
 
int main() {
   Image image = {768, 1024, 4};
   const int n_spheres = 3;
   Sphere sphere_array[n_spheres] = {
       { {700, 700, 100}, {0, 0, 0}, 100 },
       { {300, 300, 100}, {0, 0, 0}, 100 },
       { {500, 500, 100}, {0, 0, 0}, 100 }
   };
   trace (image, sphere_array);
}

[colt]

Ah, I see know what you meant by "variable-sized array". A simple "const" solved it. Thanks.