Thread: pointers to arrays

Code:

#include <iostream>
using namespace std;

void test(float* fff, int length) {
   cout << fff[0];  //access first element of array f
}

int main() 
{
   float f[5] = {1,2,3,4,5};
   test(f, 5);
}

The trick is allow your function to accept a pointer to the type of array and then also send the number of arrays as the 2nd param. Remember that the name of an array is also an address to the first element. So in this example f = &f[0], that's why we don't use the address of operator when sending the array as an argument...
Hope that helped at all...

One last thing...you can't call length() on your array...

Not a dynamic array. But if it's an array of constant size, sizeof will work. Though it's not suggested....best to avoid having to do that. It also doesn't work just on pointers.

Oh, and please note,

Code:

#include <iostream>
using namespace std;

void myFunc(float* arrayPtr)
{
    cout << sizeof(arrayPtr) << endl;
}

int main()
{
    float array[10];
    cout << "main: " << sizeof(array) << endl;

    myFunc(array);
    return 0;
}

Test that out to see what I mean.

>>why avoid sizeof?
Avoid sizeof (when using arrays, it's fine to use on single variables), simply because it's EXTREMELY easy to use it in the wrong place, especially since the compiler won't catch you if you do. It's usually just as easy to do this:

Code:

const int sizeOfArray = 10;
float myArray[sizeOfArray];
...
for(int i = 0; i < sizeOfArray; ++i)
   myArray[i] = i;

//Instead of:
float myArray[10];
...
for(int i = 0; i < sizeof(myArray) / sizeof(*myArray); ++i)
   myArray[i] = i;

This way, if you want to change the size of the array you can change the constant and it will be changed everywhere else - just as if you used sizeof/sizeof and changed the actual size of the array in the declaration instead, but safer and simpler too in its own way. You can pass the length of the array etc. to any function that needs it, and this method will work for both dynamic and static arrays too.

**EDIT**
>>because it's actually adding up the amount of bytes...not the number of elements...
Although that's one reason (convenience), the real reason is simply that if you try using sizeof on a dynamic array, you'll end up with the size of the pointer (usually 4 bytes) no matter what the size of the array itself is. If you don't realize this, then you have a nasty and hidden bug just waiting to happen.

IMO it's a bad habit to get in to with arrays.

Yeah I can understand why...good call on the code, opened my eyes...

Why is using sizeof a bad habit? I realize you can't get the size of an array using sizeof on a pointer to a dynamically created array, but using:

sizeof my_array / sizeof my_array[0]

gives you the size of a statically created array of any type perfectly well and good--as far as I can tell. It also seems like it can be easier to use in certain situations. For instance, if you are testing out some code on an array, and you are adding and deleting elements from the array as you test your code, you don't have to do anything else. If instead, you use a constant for the array size, then every time you add or delete an element from the array, you also have to change the constant--which is too much of a pain.

Its a better Idea just to use vectors actually.

>>testing out some code on an array, and you are adding and deleting elements from the array as you test your code, you don't have to do anything else.
I don't follow you here. How are you 'adding' and 'deleting' elements from the array? If you're speaking of dynamic arrays, then you have just proven the exact point that I was trying to make; and if you're speaking of static arrays, then you will not be able to add/remove elements at all anyway, and therefore sizeof will simply give you the size of the array in bytes - and you'll have to perform a costly division operation too, if you want to get the length of the array.

If instead, you use a constant for the array size, then every time you add or delete an element from the array, you also have to change the constant--which is too much of a pain.

Changing the constant takes exactly the same amount of time, typing and work as changing the hardcoded array size.

>>Its a better Idea just to use vectors actually.
While this is generally true, there are a few rare cases (dealing with API calls that cannot accept vectors) in which arrays are necessary.

Originally Posted by Hunter2

>>Its a better Idea just to use vectors actually.
While this is generally true, there are a few rare cases (dealing with API calls that cannot accept vectors) in which arrays are necessary.

Yea, thats true. You have to work with whats given.

@7stud:
I see what you mean now. That's a good point Of course, if you do that then to get the best of both worlds you can do:

Code:

int a[] = {1, 2, 3, 4};
const int sizeOfA = sizeof(a) / sizeof(*a);

To add a qualifier to my previous statement, then, I feel that it is unsafe practice to use sizeof with arrays except in tightly controlled situations where it is immediately clear that the 'array' is truly an array and not a pointer.