can not count array elements after passing as argument

Question

I am having issues counting the array elements after passing it into an arguement

void GXDX::LoadMesh(GXVector vertices[], UINT indices[] = NULL)
{
    D3D10_BUFFER_DESC bufferDesc;

    UINT numVerts = sizeof(vertices)/sizeof(GXVector);

    bufferDesc.Usage = D3D10_USAGE_DEFAULT;
    bufferDesc.ByteWidth = sizeof(GXVector) * numVerts;
    bufferDesc.BindFlags = D3D10_BIND_VERTEX_BUFFER;
    bufferDesc.MiscFlags = 0;
    bufferDesc.CPUAccessFlags = 0;

       code..............

}

In the following line above

UINT numVerts = sizeof(vertices)/sizeof(GXVector);

I am trying to count the number of elements in the array varible vertices. But I am not getting an accurate count, if not one at all.

When I did a step through, I notice that I am not able to see all the values in the array, only the first value of the array.

So I am not sure if I am passing the array correctly as an arguement. In another application, I did the same thing and i was able to see all the values in the step through. I pass the array like this.

GXVector vertices[] = {     {D3DXVECTOR3(0.5f, 0.5f, 0.5f)},
                                {D3DXVECTOR3(0.5f, -0.5f, 0.5f)},
                                {D3DXVECTOR3(-0.5f, -0.5f, 0.5f)},

                                {D3DXVECTOR3(-0.5f, -0.5f, 0.5f)},
                                {D3DXVECTOR3(-0.5f, 0.5f, 0.5f)},
                                {D3DXVECTOR3(0.5f, 0.5f, 0.5f)},
    };

    UINT indices[] = {0,1,2,3,4};

    GXRenderManager::Device()->LoadMesh(vertices, indices);

So in a nutshell, Am I passing the array right as an arguement, what am I doing wrong where I can not get the correct element count of the array.

Answer 1

You are passing the array correctly. Array parameters simply do not remember their lengths. Instead, they're passed as though they were mere pointers, so your sizeof expression is getting the size of a pointer, not the size of the entire array that the pointer points at.

If the function needs to know the lengths of the arrays, then you need to pass the lengths as additional parameters.

Answer 2

Yes, you are passing the array correctly; however, in C (and C++), arrays don't contain their size. So you need to pass the size of the array as a separate parameter. Arrays effectively decay into pointers when passed as a parameter into a function, so sizeof(vertices) will give you the size of the pointer type, not the size of the array. You can walk through the array though, either with pointer arithmetic or indexing - but you need to know its exact size, otherwise you can get out of bounds.

This is one main reason why in C++ std::vector is recommended to use instead of raw arrays.

Answer 3

C arrays (which is what you're passing) don't pass the size (length) along unless you explicitly specify the array length in the function declaration. The typical way to solve this in C is to pass the array length into the function as well as the array.

In C++ much better is to use a std::vector and pass it around. It already knows its own size and the problem vanishes compeltely.

Answer 4

The sizeof(vertices) operation that you are doing is not a runtime operation, it is actually resolved by the compiler. So, as long as the declaration of the array is in scope, you will get a correct result.

That is not so in a function, because you could be passing arrays from several other points in the code, hence the incorrect result. (And hence the confusion for the debugger as well).

Answer 5

Arrays decay into pointers when you pass them like that. What kind of sense did you think that UINT indices[] = NULL made?

You can pass the length around with the array, like you would have in C, or you could use some more intelligent construct like a vector or boost::array.

Answer 6

The C sizeof operator is evaluated at compile-time, not run-time. As written, the compiler does not have enough information to determine the size of the array.

Instead, change your function prototype. Pass in a pointer to the array as well as the length of the array.