int pointer to memory address

Hi,

Just want to know if int *Group_ID is acceptable to refer to memory address, I test and it works.
Just a quick scrap of code without any mem management, ...

Code:

typedef struct Object{

      int *Group_ID;
      int somenumber;

}Object;

typedef struct Group{

     //some Data
     int *Object_ID; //this would actually be a list referencing objects
     int somenumber;

}Group;


function test_group(void *pt){

       Group *grp;
       grp = (Group *)pt;
       printf("%d\n",grp->somenumber);

}


//edited here:
function test_object(void *pt){

       Object *obj;
       obj = (Object *)pt;
       printf("%d\n",obj->somenumber);

}


function testgroup(void){

       Object someobj;
       Group *g, GRP;        
       //....

       g = &GRP;
       g->somenumber = 77;
       g->Object_ID = &someobj;

       someobj->Group_ID = &GRP;
       someobj->somenumber = 88;


       test_group(someobj->Group_ID);
       test_object(g->Object_ID);
       

}

why do you store pointer to struct in the pointer to int?

or declare teh pointer with correct type using forward declaration, or use void*

I do realize I can use forward declaration and actual type - which is probably the best idea, but I wanted to know if it would be acceptable.

I think I should have casted the address,

Code:

       someobj->Group_ID = (int *)&GRP;
       g->Object_ID =  (int *)&someobj;

Anyway perhaps my question is not useful.

Originally Posted by vurentjie

I do realize I can use forward declaration and actual type - which is probably the best idea, but I wanted to know if it would be acceptable.

I think I should have casted the address,

Code:

       someobj->Group_ID = (int *)&GRP;
       g->Object_ID =  (int *)&someobj;

Anyway perhaps my question is not useful.

A pointer is always as many bytes as your architecture - int, char, void and whatever pointers are always 4 bytes on a 32-bit architecture. Same applies on 64-bit, but they're 8 bytes.

It's basically the same thing, but it makes your code that much harder to read. Why do you want to do this?

why not to use void* ?
standard garantees that you can cast any pointer to void* and back and get the same pointer. Nothing is said about casting to int* and back

Why do you want to do this?

I don't !!...anymore. I will use specific type or void depending on how many different types I need to assign to an id.


I am experimenting with data structures, and more specifically want to create objects that are independent of groups but can be referenced by groups. So that objects can belong to more than one group but can also be dealt with as 'all objects' irrespective of which group they belong to.

This is probably not that interesting out of context or for learned programmers. As I say, I am experimenting with c programming data structures, and was wondering about the int pointer to a memory address.

So what type is a memory address?? For interest's sake...

Originally Posted by vurentjie

So what type is a memory address?? For interest's sake...

A memory address is an integer. C and C++ distinguish between integers and pointers, but essentially they are just numbers.

thanks,

i spent a good deal of today reading and reading on c and memory,

today i realized that my understanding of c-syntax and coding is reasonably ok, but i have been lacking in the general understanding of memory management,

i spent a good deal more reading up on memory alignment and padding today, so i thought i would add this here....for whatever reason, probably because before today i would easily have done something silly like this.

from the book Memory as a Programming Concept in C and C++
by Frantisek Franek

Code:

char i;
   int* p = (int*) &i;
   ...
   *p = 1234567892;
   ...

No compiler will complain; everything seems fine. Yet clearly we are storing a binary code for the integer value 1234567892 that takes 32 bits (01001001100101100000001011010100) at the address of the variable i that has the size of 8 bits

There are several possible outcomes.

If the whole part X of the memory in Figure 3.1 belongs to the running program (process), then:

if X does not contain any data important for the rest of the execution of the program, then the program runs fine and there is no apparent problem;

if X does contain important data that are overridden by the 100101100000001011010100 tail of the binary code but by pure chance this does not change anything (as the data stored therein just happened to be the same), then the program runs fine and there is no apparent problem;

if X does contain important data that are overridden and thus changed, then

incorrect results may be produced or

the program may crash with all kinds of possible error messages.

If all or part of X belongs to some other process, then the program is terminated by the operating system for a memory access violation (the infamous UNIX segmentation fault error).

i think my first post till now i have a much better idea of how a c program needs to be structured for effeciency, although now i need to implement what i have been learning

anyway thanks for the helpful forum ...later

Originally Posted by IceDane

A pointer is always as many bytes as your architecture - int, char, void and whatever pointers are always 4 bytes on a 32-bit architecture. Same applies on 64-bit, but they're 8 bytes.

Pedanticism:
The standard says no such thing - it has some guarantees about pointers being compatible (particularly that any pointer can be cast to void * and back to it's original form). There are however architectures where a char * is different from an int * - the reason being that the machine uses "word addressing", so a pointer points at a machine-word (e.g. a 32-bit aligned address). To get to individual bytes within that word, you have to use a separate register to say "extract byte X from address A" - so a char * would need to store the X and the A component. void * would also do that, to guarantee that the void * can store and restore a char *.

--
Mats

Originally Posted by vurentjie

thanks,

i spent a good deal of today reading and reading on c and memory,

today i realized that my understanding of c-syntax and coding is reasonably ok, but i have been lacking in the general understanding of memory management,

i spent a good deal more reading up on memory alignment and padding today, so i thought i would add this here....for whatever reason, probably because before today i would easily have done something silly like this.

from the book Memory as a Programming Concept in C and C++
by Frantisek Franek


i think my first post till now i have a much better idea of how a c program needs to be structured for effeciency, although now i need to implement what i have been learning

anyway thanks for the helpful forum ...later

Some compilers may warn about truncation in that example.

I thought I'd put this here, as another follow on,

I am trying to understand something else about how memory will be organized in examples such as the following...

Code:

struct OfSize8{OfSize8 *next };

struct OfSize16{  OfSize16 *next};

If each of these lists are initialized I assume that each list node in the respective list will be set contiguously in memory - also meaning that each list will be allocated a block of memory starting at a different offset.

If during program runtime OfSize16 is dynamically allocated space for X amount of nodes, but later none of these nodes are in use. This memory block has not been freed (but might have been set to zero or some such) and is still available for re-use. Re-using this memory for the same type of Object seems relatively easy.

What would need to happen if a different type of object of the same size wanted to use this memory block? Would it be correct to assume that it would merely involve running through the memory from the original head and allocating it to the new list of objects, and removing pointers from the old list.

Would it be possible to take this memory block which is a multiple of 16 (and therefore of 8) and re-use it on the list OfSize8? What does this entail?

Any brief explanations would be appreciated. And any corrections to my understanding...

You can do that. The reason is that to the computer - it's just bits, or bytes. It doesn't care what's stored in there.
This is the same way malloc works - it just allocates a raw number of bytes needed for your data and you treat it like a certain type.