Why type conversion is required for memory allocation to a pointer?

Question

Why type conversion is required for memory allocation to a pointer?

Debojit Acharjee 455

I want to know why type conversion is required when assigning memory to a pointer?

int *ptr_a = (int*)malloc((sizeof(int)));

In the above line of code why the (int*) is used?

Moreover, the following code means to store the value of character.

char *a = 'A';

But this can't be applicable for an integer type.

int *a = 1; // This will not store the value

So how come int *ptr_a is able to store the memory allocation value?

Vahid Ghafarpour 22,800 Reputation points

2023-08-12T07:19:37.6633333+00:00

In your code, there's a small mistake in the character assignment. It should be char *a = "A"; instead of char *a = 'A';.
Debojit Acharjee 455 Reputation points

2023-08-13T06:37:38.3566667+00:00

Vahid Ghafarpour - that's a typing mistake but it's not going to give the answer to my question. Is it?

4 answers

Your answer

Vahid Ghafarpour 22,800 Reputation points

2023-08-12T07:19:37.6633333+00:00

In your code, there's a small mistake in the character assignment. It should be char *a = "A"; instead of char *a = 'A';.
Debojit Acharjee 455 Reputation points

2023-08-13T06:37:38.3566667+00:00

Vahid Ghafarpour - that's a typing mistake but it's not going to give the answer to my question. Is it?

Answer 1

Vahid Ghafarpour 22,800

Assigning an integer value directly to a pointer as in int *a = 1; is not correct. This doesn't work because an integer value doesn't inherently represent a valid memory address. If you want to store an integer value using a pointer, you need to allocate memory for that integer malloc:

int *ptr_a = (int*)malloc(sizeof(int));
*ptr_a = 1; // Storing the integer value 1 in the memory pointed to by ptr_a

Answer 2

RLWA32 48,056

int *ptr_a = (int*)malloc((sizeof(int))); In the above line of code why the (int*) is used?

Actually it depends on whether the line of code is being compiled as C or as C++. The malloc function returns a void* pointer. In C it is acceptable to assign a void* pointer to a pointer variable of a different type without a cast. However, in C++ such an assignment is an error and so a cast is required.

char *a = 'A';

The Visual Studio C compiler issues a warning for the above statement and the C++ compiler emits an error for it.

When compiled as C this statement does not store the 'A' character to memory. It actually places the value of 'A' (0x41) into the pointer variable. Of course, this creates a pointer that will cause errors and probably termination due to an access violation if it is used. Same problems for an int.

badptr

badptr2

Debojit Acharjee 455 Reputation points

2023-08-13T06:44:53.82+00:00

I think you haven't got my question.

If int *a = 1; can tell the compiler to store the value 1 using the pointer a then the expression int *ptr_a = (int*)malloc((sizeof(int))); should also tell the compiler to store the value of the malloc. But how it's telling the compiler to allocate the memory instead?
Barry Schwarz 3,736 Reputation points

2023-08-13T08:25:16.1133333+00:00
@Debojit Acharjee You are proceeding from a false assumption. The definition

int *a = 1;

does not tell the compiler to store the value 1 where a points to. It tells the compiler to store the value 1 directly into pointer a.

You seem to think the asterisk in the definition is a dereference operator. It is not. It is strictly a syntax convention that says a is a pointer to int rather than simply an int.

int is an object type. pointer-to-int is a derived type. In the context of this derived type, int is called the referenced type. The presence of the asterisk tells the compiler to construct the pointer type by a process called "pointer type derivation".

The definition

int *ptr_a = (int*)malloc (...);

does both call malloc and store the value. You may be confusing this definition with an assignment statement, which it is not. As with all definitions that contain initialization, it causes the compiler to:

Define and allocate storage for an object of type pointer-to-int.

Generate code to initialize this object by a. Calling malloc. b. Converting the value returned by malloc (which has type pointer-to-void) to type pointer-to-int. c. Store this converted value directly into ptr_a.

Not all asterisks are dereference operators. Not all equal signs indicate assignment.

Furthermore, in C it is not necessary to cast the return value of malloc. In C, there is an implicit conversion between pointer-to-void and any other object pointer type in both directions. This is not true for C++ but you should stick with C for the time being.
RLWA32 48,056 Reputation points

2023-08-13T08:25:52.4166667+00:00

I'll say it again. Go back and reread my answer slowly and think about it. I'm telling you how the language interprets statements. You're busy inventing how you think a statement should be interpreted by the compiler. And your interpretations are incorrect. If you don't understand the malloc function then read the documentation about the function and how heaps provide dynamically allocated memory.
Debojit Acharjee 455 Reputation points

2023-08-14T09:36:07.23+00:00

Barry Schwarz - If int *a = 1 means that 1 should be stored in *a then what does this statement would mean int b = 2? If b is a variable to store the value of 2 and pointer a also stores that value of 1 then what's the difference between a and b?

If type casting is not necessary for a void value then why (int*) was used in the statement int *ptr_a = (int*)malloc (...);?

RLWA32 - my question is not related to malloc function but I want to know why (int*) is used with malloc and what it does?
RLWA32 48,056 Reputation points

2023-08-14T09:47:55.9433333+00:00

How many times must the same question be answered? Go back and read my answer. The answer to your question about the cast was the very first thing I wrote!
Barry Schwarz 3,736 Reputation points

2023-08-14T16:55:51.7766667+00:00

@Debojit Acharjee How many times do we have to tell you?

If int *a = 1 means that 1 should be stored in *a then

is a COMPLETELY FALSE ASSERTION. It does not store anything in *a. It tries to store the value 1 directly in a.

The asterisk in a definition is not the dereference operator. The pointer a is not dereferenced. The pointer a is being initialized with a value. The fact that a has pointer type does not change the semantics. The object itself is being accessed, not what it might point to.
Debojit Acharjee 455 Reputation points

2023-08-15T14:30:53.69+00:00

RLWA32 - did you really get my question? You have only explained that a void pointer is returned in C and it's acceptable. But if it's acceptable then why (int*) is required?

Barry Schwarz - how many times did you tell? Who are "we"? Exaggeration is not teaching. First you said values are stored in a pointer and now you are saying it doesn't.

As per my knowledge, I know that only a variable can store a value of certain data type but a pointer can only store the address of any variable. I want to know why * operator is used with a pointer and what it means when used with a data type like int*.

I think you don't know any technical aspects of C and that's why giving all garbage answers.
RLWA32 48,056 Reputation points

2023-08-15T15:03:09.32+00:00

But if it's acceptable then why (int*) is required?

Obviously you don't read the answers that have been given. In my anwwer I wrote the following explanation --

"Actually it depends on whether the line of code is being compiled as C or as C++. The malloc function returns a void pointer. In C it is acceptable to assign a void pointer to a pointer variable of a different type without a cast. However, in C++ such an assignment is an error and so a cast is required."**

Why don't you try reading the answers that have been provided instead of ignoring them!!!!!
Barry Schwarz 3,736 Reputation points

2023-08-15T17:29:21.9266667+00:00
@Debojit Acharjee Try reading the answers for content. No one said the definition did not initialize the value to the pointer. It is your assertion that the value was stored in the object pointed to is being rejected.

Your knowledge is only half correct. All objects store values. The nature of the values and how they are used depends on the type of the object. int and double hold normal arithmetic values. char holds a character but can also handle small integers. An object of pointer type holds the address of another object. A pointer to void can hold the address of any type of object. Any other pointer to any other type can only hold the address of an object of that type.

The dereference operator when applied to a pointer in an expression tells the compiler to access the the object the pointer points to. The asterisk used in a definition or in the cast operator is NOT a dereference operator. It is the syntax that indicates a pointer type is being derived. In these two lines

int *ptr; ptr = (int*)malloc(100);

neither asterisk is a dereference operator. It is simply syntax identifying that ptr is a pointer to int, not an int, and kthe value returned by malloc should be converted to a pointer value, not an int value.

In the following line

*ptr = 10;

the asterisk is a dereference operator. It says don not assign the value to ptr but to the object ptr points to.

And the cast operator in the call to malloc above is NOT required in C. It is optional and basically superfluous. In C, there is an implicit conversion defined for pointer-to-void to any other object pointer type and also in the reverse direction. This is not true in C++ which also discussed in this group. Do not confuse the two languages.
Debojit Acharjee 455 Reputation points

2023-08-16T06:46:36.5533333+00:00
RLWA32 - you are only talking about C++ but I am asking about C. You said casting is not needed in C but then why (int*) is used in C?

Barry Schwarz - According to the information on W3 School, a pointer stores the address only and can also point to any value.

https://www.w3schools.com/c/c_pointers.php#:~:text=A%20pointer%20is%20a%20variable,is%20created%20with%20the%20*%20operator.

I wrote the following program for you.

#include <stdio.h> int main() { int a, *b, c; a = 10; printf("address of 'a': %p\n", &a); b = &a; // Stores the address of 'a'; printf("address of 'a': %p\n", b); printf("value of 'a': %d\n", *b); // Dereference of 'b' c = *b; // Dereference of 'b' printf("value of 'a': %d\n", c); c = 20; *b = c; // What is this? This is not derefencing but assigning. printf("value of 'a': %d", *b); return 0; }

In the above program, the c = *b is dereferencing and *b = c is assigning or pointing but it actually means to replace the previous value in the address of C with the value 20.
RLWA32 48,056 Reputation points

2023-08-16T07:51:22.1766667+00:00

you are only talking about C++ but I am asking about C. You said casting is not needed in C but then why (int*) is used in C?

@Debojit Acharjee Its difficult to believe that you still do not understand what has been written and explained to you by me and also by @Barry Schwarz several times.

int *ptr_a = (int*)malloc((sizeof(int)));

This line of code is subject to different rules if it is compiled using a C compiler versus a C++ compiler. You cannot determine whether a C or C++ compiler is being used by looking at this single line of code.

I'll say it another way. In C++ the cast is required, but in C it is optional. When compiling as C the (int*) cast is not required and its presence is not an error and does not mean that C++ is being used! Perhaps the cast was included so that the code would compile successfully in either C or C++.
Minxin Yu 13,501 Reputation points Microsoft External Staff

2023-08-16T08:20:44.2066667+00:00

@Debojit Acharjee It is recommended that one thread focus on one question. You mentioned two different problems in this thread. For the first question, you don't need to use (int*) in C.
Debojit Acharjee 455 Reputation points

2023-08-16T10:05:13.34+00:00

RLWA32 - it's not me but you didn't get my question. I am not asking why (int*) is used in C but I have asked what is the meaning of using it? What exactly the syntax data_type* means when used for casting?

Usually, char a = (char) b; would mean to explicitly convert the value of b to character but what if the expression goes like this char a = (char*) b; then what that suppose to mean? What is the meaning of (char*)?

Minxin Yu - Thanks for the clarification.
RLWA32 48,056 Reputation points

2023-08-16T10:21:56.6766667+00:00

In the question you posted you wrote "In the above line of code why the (int*) is used?" I have exhausted my patience answering that question more than once. I'm through with going around in circles answering the same questions over and over.
Barry Schwarz 3,736 Reputation points

2023-08-16T15:19:44.9366667+00:00
@Debojit Acharjee

The line of code

*b = c; // What is this? This is not derefencing but assigning.

has two operators. The first operator is the asterisk applied to the variable b. THIS IS A DEREFERENCE OPERATOR. Why do you think it's not? It means that assignment should be performed NOT to b but to the object b points to. Since b still points to object a, the result of this assignment is that the current value of c is copied to object a, which should be obvious when you look at the output of the next printf statement.

The web site you mention does not say "a pointer stores the address only and can also point to any value." or anything like that. In fact, it clearly states "A pointer variable points to a data type (like int) of the same type"

You don't have to like my answers but you could at least read the sites you do like completely.

Answer 3

Deleted

This answer has been deleted due to a violation of our Code of Conduct. The answer was manually reported or identified through automated detection before action was taken. Please refer to our Code of Conduct for more information.

Comments have been turned off. Learn more

Answer 4

the line

char *a = 'A';

should cause a warning/error in modern compiler, because 'A' (char literal) is upcast to an int (65) and assigned to a pointer. using a cast to bypass error:

char* a = (char*) 'A';
printf("%p\n", a); //0x41 (65 in hex)
printf("%s\n", a); //undefined behavior as 65 is a random memory address

while:

char *a = "A";            // set to a to string literal address
printf("%p: %s\n", a, a); //<some address>: A

is valid, because a is being set to the address of the string literal.

note: due to string literal pooling, the following should print the same address:

char *a = "A";         // set to a to string literal address
char *b = "A";         // set to b to string literal address
printf("%p %p\n", a, b); //values should match
printf("%d", a == b);  //1 (addresses match)

Share via

Why type conversion is required for memory allocation to a pointer?

4 answers

Your answer