My pointers have been pointing crazily for the past few days, and I am getting crazy as well. Usually, I would not be so troubled by pointers, but all of a sudden, after trying to make a pretty complex set of functions with many pointers, my brain is now... not at its best and I feel I must ask these questions...


Firstly, have a look at this code. Does it make any sense?

float* arr1;
arr1=(float*)realloc(arr1,5*sizeof(float));
arr1[0]=5;
arr1[1]=15;
arr1[2]=25;

Am I doing this correctly? AM I allowed to treat float* which i malloc - ed like an array? arr1[0] sets the value of the first block to 5 right, or am I pointing the block of memory to memory address "5" ?

And....


void testfunc(float* varA,var varB, var varC)
{

printf("%i",(int)varA); //anything wrong with this?
if (varB>*varA[0]) //or this?
{
//run non-pointer related stuff
}
varA[1] = varC; //or this?
}

Of course, the first question is more important, since my problem is probably due to some confusion with the way pointers work.

I have worked with pointers before, but my absense from playing around with programming (hence forgetting pointers) is definately causing my problems. Any sites which offer a quick, painless, accessible, non-frightening crash course on lite-c pointers (which I dunno... seems to work differently from C++, or are they the same? I don't know anymore) to refresh my memory?

Section 1 ::
It is basically, but very unsafely done, and very unlikely to actually work.
Here is two ways for it to be done safely.
Im unsure which is best for your overall situation though.
You are using 're-alloc' in a strange way....


Section 2 ::
Not too sure heres, its a fuzzy area for me too. But I THINK this is the way to go.

Nothing more to add to the first question, I think.


Yes, you are doing this right.

arr1 alone (without any index) just points to the base address of the array or rather the allocated memory block.

However, if you use the indirection operator on the base address, you will get the first value: *arr1. *arr1 is equal to arr1[0]. Consequently arr[i] is the same as *(arr + i), so its nothing more than the indirected base address shifted by the index i.


With this said, your second question can be answered as well: if 'float* varA' is an array, you don't have to use the indirection operator in the function, as varA is a pointer to the base address and varA[i] is equal to *(varA + i), thus it's already indirected.

So in regard to your function:

- 'printf("%i",(int)varA)' would print the base address,
- 'if (varB>*varA[0])' is an illegal indirection and
- 'varA[1] = varC' is all right. : )

This does not apply if 'float *arrA' is NOT a pointer to an array but a single float, though. Then indirection is needed.

Hope this helps (even though my post seems to be pretty messy).

BTW: Pointers in lite-C should behave like in C as long as PRAGMA_POINTER is defined.

Thanks both! I'm starting to see the light. Cleared up some stuff but there are still some things I don't get. I'm trying to use realloc to change the size of my array at runtime.

Anyway, another piece of code I need to clarify about


Please excuse any foolishness by me, since I get the feeling that I'm supposed to know what is already wrong from the posts above. But I don't.

My problem is that my initialisation function(arrinitialise) somehow crashes(but without using a function, the same piece of code, the two lines I commented out, works). So probably, the problem lies in what my pointer points to?

Thanks!

arr1 is a pointer and you are using the address operator on it. So a pointer to a pointer is returned.

Thus your initialization function should look like this:

I see, that made sense! But I'm still a little lost. Should it not be



instead? Since *arr1 would still be a undefined value rather than the address?

All these pointer to pointer thing is really confusing and hard to work with.. Is there a better way to maintain an array at runtime or for me to write these code?

arr1 is a pointer to a pointer. A pointer to a float pointer to be exact. So if you change arr1 like 'arr1 = ...' the first of these two pointers is changed. However, this is not what you want here: you want to change the second pointer instead (that is the local pointer of your main function). To get this pointer, the indirection operator has to be used: *arr1 = malloc... : )


Depends on what you would like to achieve.
An easy way would be to encapsulate your array and corresponding data in a struct.

Like this for example:


Then you could use it like this:

FLOAT_ARRAY *arr = float_array_new(10);
(arr->data)[0] = 123.456; // set first element
(arr->data)[arr->size - 1] = 987.654; // set last element

Now you don't have to pass pointers to pointers anymore. You can just pass 'arr' and change its members within other functions. In addition you can keep track of the arrays actual size easily.