Why in this program the value stored in one pointer gets corrupted after casting?

Question

Why in this program the value stored in one pointer gets corrupted after casting?

Walkbitterwyrm Lightwarg 20

Why in this C program the type conversion of the character pointer "ptr_c" to a integer pointer "ptr_i" changed the data but when the integer pointer "ptr_i" is converted to character pointer "ptr
_c" there was no data loss.

#include <stdio.h>

int main()
{
    int a, *ptr_i;
    char c, *ptr_c;

    a = 65;
    c = 'A';

    ptr_i = &a;
    ptr_c = &c;

    ptr_i = (int*) ptr_c;
    ptr_c = (char*) ptr_i;
        
    printf("The value of \"ptr_i\" is %d\n", *ptr_i);
    printf("The value of \"ptr_c\" is %c\n", *ptr_c);

    return 0;
}

Minxin Yu 13,501 Reputation points Microsoft External Staff

2023-08-22T09:35:45.15+00:00

Did the answers solve your problem?

3 answers

Your answer

Minxin Yu 13,501 Reputation points Microsoft External Staff

2023-08-22T09:35:45.15+00:00

Did the answers solve your problem?

Answer 1

My answer may be not professional enough. FYI :-) (poor english)

when you dereference a pointer, the type of it is important.

We know that int takes up 4 bytes of memory while char does only 1.

One example are as followed:

(%x: print in hex)

#include <cstdio>
#include <cstdlib>

The output on my pc is:

a: -1412567278

in hex:

a: abcdef12

ptc_a: 61fdfc

pti_a: 61fdfc

*ptc_a: 12

*pti_a: abcdef12

*(ptc_a + 1): ffffffef

c: V

in hex:

c: 56

ptc_c: 61fdfb

pti_c: 61fdfb

*ptc_c: 56

*pti_c: cdef1256

*(ptc_c + 1): 12

In this program, varibles a and c are storaged like this:

address | values, type

0x61fdff | ab, int High address

0x61fdfe | cd, int

0x61fdfd | ef, int

0x61fdfc | 12, int <- ptc_a, pti_a

0x61fdfb | 56, char Low address <- ptc_c, pti_c

When you print *ptc_a, it shows 12, which is only 1 byte long in 0x61fdfc.

Similiarly, when you print *pti_c, it shows cdef1256, which takes up 4 bytes from 0x61fdfb to 0x61fdfe. a and c are all storaged in stack from high to low address. However, data of a are in an inverse order. 0x61fdfc is the highest of a and 0x61fdff the lowest.

So, in your example, ptr_i actually reads the data of c as well as a, because ‘A’ is only a 1-byte data. And dereference of it cause the data loss. On the contrary, ptr_c only reads the lowest byte of a(65), and a happens to only need one byte to store, so when you dereference ptr_c, you get exactly 65.

I'm a beginner in programming so if there's a mistake please let me notice.

Rer 80 Reputation points

2023-08-20T13:42:01.7+00:00

ouch my code isn't showed.

Answer 2

Bruce (SqlWork.com) 74,936

ptr_I is the address of an int, ptr_c is the address of a char. If you assign ptr_c to ptr_i, the compiler knows this is bad code. So you cast the char* it int* to force the assignment. As both variables are address there are was no conversion. But after the assignment ptr_i is no longer points to a valid int address, it’s a bad pointer. As it has the same value as ptr_c assigning the value to ptr_c has no effect.

Walkbitterwyrm Lightwarg 20 Reputation points

2023-08-25T16:51:44.5766667+00:00
This is not because of assigning ptr_i because both the pointers are printing 'A' when using the %c. But only %d is not showing 65 when used with ptr_i. Why is that?

#include <stdio.h> int main() { int a, *ptr_i; char c, *ptr_c; a = 65; c = 'A'; ptr_i = &a; ptr_c = &c; ptr_i = (int*) ptr_c; ptr_c = (char*) ptr_i; printf("The value of \"ptr_i\" is %c\n", *ptr_i); // Prints 'A' printf("The value of \"ptr_c\" is %c\n", *ptr_c); return 0; }

But the following program works

#include <stdio.h> int main() { int a, *ptr_i, *ptr_xi; char c, *ptr_c; a = 65; c = 'A'; ptr_i = &a; ptr_c = &c; ptr_xi = ptr_i; ptr_i = (int*) ptr_c; ptr_c = (char*) ptr_xi; printf("The value of \"ptr_i\" is %d\n", *ptr_i); printf("The value of \"ptr_c\" is %c\n", *ptr_c); return 0; }

But why the following program also doesn't work even after using temporary pointers.

#include <stdio.h> int main() { int a, *ptr_i, *ptr_xi; char c, *ptr_c, *ptr_xc; a = 65; c = 'A'; ptr_i = &a; ptr_c = &c; ptr_xi = ptr_i; ptr_xc = ptr_c; ptr_i = (int*) ptr_xc; ptr_c = (char*) ptr_xi; printf("The value of \"ptr_i\" is %d\n", *ptr_i); printf("The value of \"ptr_c\" is %c\n", *ptr_c); return 0; }

In the above program, only the value of ptr_i is not showing correctly as integer but it shows correctly as character when printed using the %c.

I think this is happening because the address allocated for an integer pointer is of 8 bytes and that consists of 8 memory blocks. Whereas, a character pointer only takes 1 byte and only one address block. So when the value of a character pointer is assigned to an integer pointer, only one block of memory is used and the rest 7 blocks are wasted with garbage values. That's why when using %d with ptr_i after casting with ptr_c, it shows a different integer value but when used with %c, it shows 'A'. This is corrupted pointer.

A format specifier like %c tells the compiler how to read the pointer and when it's %c, the compiler would only read the 1st 1byte of memory block and would ignore the rest 7 bytes. But when using %d, it would like to read all the 8 bytes and that's why ptr_i is giving garbage data when using %d.
Barry Schwarz 3,736 Reputation points

2023-08-25T20:09:44.58+00:00

The pointers are not corrupted. All the pointers contain the addresses you expect them to.

However, when you use a pointer to int to access the value of a char, the system (printf in this case) will attempt to access the full number of bytes that an int would occupy. Since the char occupies only one byte, the other bytes being accessed have never been given a value. They are indeterminate and accessing them causes undefined behavior. On many systems, accessing indeterminate values this way produces apparently random results.

Your second program did not work on my system for the exact same reason the first and third ones don't. Casting a pointer to a different type does not change the "value" of the pointer. The new value still points to the same memory address. The only change is the way the data pointed to is interpreted when accessed through the pointer.

Answer 3

Barry Schwarz 3,736

See the answers to the same question posted here https://learn.microsoft.com/en-us/answers/questions/1348818/why-type-casting-of-pointers-from-lower-to-higher

Share via

Why in this program the value stored in one pointer gets corrupted after casting?

3 answers

Your answer