Casting a generic or void pointer to point to a struct...

[redefined.horizons]

First, I would thank all of those that took the time to answer my
question about creating an array based on a numeric value stored in a
variable.

I realize after reading the responses and doing some more research,
that what I really need is known in C as a "dynamic array". Basically,
you surpass the array notation and use pointers with memory obtained
with malloc() or calloc(). I think this will do just what I needed.

That has brought up another question though. I'm not sure what syntax I
would use to cast a gneeric or void pointer to a struct that I have
defined. For example, if I have defined the "new_data_t ype" struct
previously in the source code file, would the following code be valid?

/* Create a generic pointer to the first element in the block of
memory obtained with the calloc() function. */
void generic_pointer = calloc(number_o f_elements, size_of_element );

/* If the memory has been sucessfully allocated, cast the generic
pointer to the correct data type. */
if(generic_poin ter != NULL)
(struct new_data_type *)generic_point er
else
/* We've got problems. */

Thanks again for the help everyone.

Scott Huey

[MQ]

re************* ***@gmail.com wrote:

First, I would thank all of those that took the time to answer my
question about creating an array based on a numeric value stored in a
variable.

I realize after reading the responses and doing some more research,
that what I really need is known in C as a "dynamic array". Basically,
you surpass the array notation and use pointers with memory obtained
with malloc() or calloc(). I think this will do just what I needed.

That has brought up another question though. I'm not sure what syntax I
would use to cast a gneeric or void pointer to a struct that I have
defined. For example, if I have defined the "new_data_t ype" struct
previously in the source code file, would the following code be valid?

/* Create a generic pointer to the first element in the block of
memory obtained with the calloc() function. */
void generic_pointer = calloc(number_o f_elements, size_of_element );

/* If the memory has been sucessfully allocated, cast the generic
pointer to the correct data type. */
if(generic_poin ter != NULL)
(struct new_data_type *)generic_point er
else
/* We've got problems. */

Thanks again for the help everyone.

Scott Huey

struct new_data_type * ptr = calloc(number_o f_elements,
size_of_element );
if(ptr == NULL)
{
/*error */
}
else
{
/*do something */
}

MQ

[MQ]

MQ wrote:

re************* ***@gmail.com wrote:

First, I would thank all of those that took the time to answer my
question about creating an array based on a numeric value stored in a
variable.

I realize after reading the responses and doing some more research,
that what I really need is known in C as a "dynamic array". Basically,
you surpass the array notation and use pointers with memory obtained
with malloc() or calloc(). I think this will do just what I needed.

That has brought up another question though. I'm not sure what syntax I
would use to cast a gneeric or void pointer to a struct that I have
defined. For example, if I have defined the "new_data_t ype" struct
previously in the source code file, would the following code be valid?

/* Create a generic pointer to the first element in the block of
memory obtained with the calloc() function. */
void generic_pointer = calloc(number_o f_elements, size_of_element );

/* If the memory has been sucessfully allocated, cast the generic
pointer to the correct data type. */
if(generic_poin ter != NULL)
(struct new_data_type *)generic_point er
else
/* We've got problems. */

Thanks again for the help everyone.

Scott Huey

struct new_data_type * ptr = calloc(number_o f_elements,
size_of_element );
if(ptr == NULL)
{
/*error */
}
else
{
/*do something */
}

MQ

correction: size_of_element should be replaced by sizeof(struct
new_data_type)

MQ

[Keith Thompson]

re************* ***@gmail.com writes:

First, I would thank all of those that took the time to answer my
question about creating an array based on a numeric value stored in a
variable.

I realize after reading the responses and doing some more research,
that what I really need is known in C as a "dynamic array". Basically,
you surpass the array notation and use pointers with memory obtained
with malloc() or calloc(). I think this will do just what I needed.

That has brought up another question though. I'm not sure what syntax I
would use to cast a gneeric or void pointer to a struct that I have
defined. For example, if I have defined the "new_data_t ype" struct
previously in the source code file, would the following code be valid?

/* Create a generic pointer to the first element in the block of
memory obtained with the calloc() function. */
void generic_pointer = calloc(number_o f_elements, size_of_element );

/* If the memory has been sucessfully allocated, cast the generic
pointer to the correct data type. */
if(generic_poin ter != NULL)
(struct new_data_type *)generic_point er
else
/* We've got problems. */

Don't cast the result of malloc() or calloc(). It's unnecessary, and
it can mask certain errors.

BTW, it's "void *generic_pointe r", not "void generic_pointer ".

Also, keep in mind that calloc() isn't necessarily as useful as you
might think it is. It initializes the allocated memory to
all-bits-zero. For pointers or floating-point data, this is not
necessarily meaningful; there's no guarantee that either a null
pointer or a floating-point 0.0 is represented as all-bits-zero.

Usually it's easier to use malloc() (which doesn't initialize the
allocated object), and just make sure that you don't use any portion
of the object that you haven't assigned a value to.

Why do you want a generic pointer rather than a pointer to your
"new_data_t ype" struct? For example:

struct new_data_type {
/* member declarations here */
};

struct new_data_type *ptr;

ptr = malloc(number_o f_elements * sizeof *ptr);

Sometimes you do need to use void* pointers, but quite often it's
better to use a specific pointer type.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Flash Gordon]

MQ wrote:

MQ wrote:

>re************* ***@gmail.com wrote:

>>First, I would thank all of those that took the time to answer my
question about creating an array based on a numeric value stored in a
variable.

I realize after reading the responses and doing some more research,
that what I really need is known in C as a "dynamic array". Basically,
you surpass the array notation and use pointers with memory obtained
with malloc() or calloc(). I think this will do just what I needed.

That has brought up another question though. I'm not sure what syntax I
would use to cast a gneeric or void pointer to a struct that I have
defined. For example, if I have defined the "new_data_t ype" struct
previously in the source code file, would the following code be valid?

/* Create a generic pointer to the first element in the block of
memory obtained with the calloc() function. */
void generic_pointer = calloc(number_o f_elements, size_of_element );

/* If the memory has been sucessfully allocated, cast the generic
pointer to the correct data type. */
if(generic_poin ter != NULL)
(struct new_data_type *)generic_point er
else
/* We've got problems. */

Thanks again for the help everyone.

Scott Huey

struct new_data_type * ptr = calloc(number_o f_elements,
size_of_elemen t);
if(ptr == NULL)
{
/*error */
}
else
{
/*do something */
}

correction: size_of_element should be replaced by sizeof(struct
new_data_type)

In all probability neither is optimal. Firstly, the OP did not say that
it needed clearing to all bits 0 (remember that floating point 0 and
null pointers might not be all bits 0) so why pay the cost of zeroing
the memory? Secondly, there are better ways to use sizeof.

If you really do want calloc:

T *ptr = calloc(number_o f_elements, sizeof *ptr);
Then you only have to specify the type in one place, so maintenance is
easier.

Or, for malloc
T *ptr = malloc(number_o f_elements * sizeof *ptr);

Or, if mallocing some time after declaration:
ptr = malloc(number_o f_elements * sizeof *ptr);

Although the OP should also look up the references to the struct hack
others have posted and, if using a C99 compiler, the C99 sanctioned
alternative.
--
Flash Gordon
Still sigless on this computer.

[William Ahern]

On Wed, 02 Aug 2006 02:00:42 +0200, Flash Gordon wrote:
<snip>

If you really do want calloc:

T *ptr = calloc(number_o f_elements, sizeof *ptr); Then you only have to
specify the type in one place, so maintenance is easier.

Or, for malloc
T *ptr = malloc(number_o f_elements * sizeof *ptr);

calloc() might have the benefit of overflow detection.

[MQ]

Flash Gordon wrote:

>
In all probability neither is optimal. Firstly, the OP did not say that
it needed clearing to all bits 0 (remember that floating point 0 and
null pointers might not be all bits 0) so why pay the cost of zeroing
the memory?

I don't understand what you are talking about

MQ

[MQ]

Flash Gordon wrote:

>
In all probability neither is optimal. Firstly, the OP did not say that
it needed clearing to all bits 0 (remember that floating point 0 and
null pointers might not be all bits 0) so why pay the cost of zeroing
the memory?

Ah, OK just realized, calloc zeroes memory, malloc does not. I used
calloc because thats what the OP is using, so you have to assume they
are using it for a reason. Why would you use it otherwise?

Secondly, there are better ways to use sizeof.
sizeof *ptr

I dont understand how this is better though. Please explain.

MQ

[Keith Thompson]

"MQ" <mi************ **@gmail.comwri tes:

Flash Gordon wrote:

>In all probability neither is optimal. Firstly, the OP did not say that
it needed clearing to all bits 0 (remember that floating point 0 and
null pointers might not be all bits 0) so why pay the cost of zeroing
the memory?

I don't understand what you are talking about

I don't understand what the problem is.

The main difference between malloc() and calloc() is that calloc()
initializes the allocated object to all-bits-zero. There's no
guarantee that this is useful; all-bits-zero may not be a
representation of a meaningful value for all types. In particular,
there's no guarantee that either a null pointer value or a
floating-point 0.0 is represented as all-bits-zero.

Because of this, zeroing allocated memory is often a waste of time. A
better solution is often to allocate using malloc(), and then be
careful not to read any portion of the allocated object that you
haven't explicitly assigned a value to.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Flash Gordon]

MQ wrote:

Flash Gordon wrote:

>In all probability neither is optimal. Firstly, the OP did not say that
it needed clearing to all bits 0 (remember that floating point 0 and
null pointers might not be all bits 0) so why pay the cost of zeroing
the memory?

Ah, OK just realized, calloc zeroes memory, malloc does not. I used
calloc because thats what the OP is using, so you have to assume they
are using it for a reason. Why would you use it otherwise?

Because the OP does not know how to program in C yet.

>Secondly, there are better ways to use sizeof.
sizeof *ptr

I dont understand how this is better though. Please explain.

What changes to you have to make to
ptr = malloc(N * sizeof *ptr);
if the type of ptr is changed? I'll give you a clue, the answer is none.

Do you have to find the declaration of ptr to see if the correct amount
of memory is being allocated?

Seach the groups archives for a bit for further discussion.
--
Flash Gordon
Still sigless on this computer