What does int* pint; pint = (int*)data; mean?

Question

I'm reading how pointers work here because I'm trying to understand qsort(). But the guide gives this code:

// increaser
#include <iostream>
using namespace std;

void increase (void* data, int psize)
{
  if ( psize == sizeof(char) )
  { char* pchar; pchar=(char*)data; ++(*pchar); }
  else if (psize == sizeof(int) )
  { int* pint; pint=(int*)data; ++(*pint); }
}

int main ()
{
  char a = 'x';
  int b = 1602;
  increase (&a,sizeof(a));
  increase (&b,sizeof(b));
  cout << a << ", " << b << endl;
  return 0;
}

without explaining what the line

pint=(int*)data;

and

pchar=(char*)data;

means. I understand what the rest means, but it doesbt quite make sense to me what (char*)data could mean. Is it pointing to the value of char? But how could that be if char is a variable type?

I would highly recommend learning language fundamentals from a [decent book](http://stackoverflow.com/questions/388242/the-definitive-c-book-guide-and-list), rather than from a random website... — Oliver Charlesworth, Apr 02 '13 at 20:50
That's a terrible assumption. Multiple types can be the same size. — chris, Apr 02 '13 at 20:51
@markovchain Many would recommend that you not learn how anything works at that particular site. :( — Drew Dormann, Apr 02 '13 at 20:55

JaredPar · Accepted Answer · 2013-04-02T21:01:00.263

The line pint = (int*)data is doing two things

The (int*)data is a conversion from void* to int*
The pint = ... is an assignment of the value to pint

Ultimately what this function is attempting to do is increment the value pointed to by data by one value. It's a bit flawed though as a) the signature accepts any pointer type but the implementation only works with a fixed set of types and b) it incorrectly associates sizes with types.

Given that this is C++, a much better way of writing this would be to use a template. It accepts all input types which support ++.

template <class T>
void increase(T* pValue) {
  ++(*pValue);
}

Ideally though you'd just use a reference

template <class T>
void increase(T& value) {
  ++value;
}

score 2 · Answer 2 · answered Apr 02 '13 at 20:50

2

(int*)data;

and

(char*)data;

are casts from one pointer type to another, in this case from void* to int* and char*. And after that the results are assigned to pint and pchar

answered Apr 02 '13 at 20:50

Johnny Mnemonic

3,822
5
21
33

score 2 · Answer 3 · answered Apr 02 '13 at 20:52

2

data is passed as a void*

(int*)data is casting it to a int*.

answered Apr 02 '13 at 20:52

quandrei

204
1
3
10

score 1 · Answer 4 · answered Apr 02 '13 at 20:50

1

pint=(int*)data;

and

pchar=(char*)data;

are casting these variables as pointers, just as you would cast a a double to an int, or vise versa.

answered Apr 02 '13 at 20:50

Syntactic Fructose

18,936
23
91
177

score 1 · Answer 5 · answered Apr 02 '13 at 20:55

pchar is a pointer to a char - this is what the declaration

char* pchar;

means. Thus, after the assignment

pchar=(char*)data;

the pointer pchar is pointing to the start of the block pointed to by data - and when you offset pchar by a number (say 5 - *(pchar+5)), it will point to a memory location that is "five chars" from the location pointed to by data. Since a char is one byte long, this means you are incrementing the location by 5. Since pint had been declared as int* pint, the same construction *(pint+5) will point to a location that is 5*sizeof(int) away... so the +5 means different things depending on how the pointer was declared!

In other words - the declaration tells the compiler how to treat the objects pointed to by the pointer, and what to do when you offset the pointer (increment, decrement, etc).

score 0 · Answer 6 · answered Apr 02 '13 at 21:00

Pointer is not variable as any other. It does not hold regular value. What it does is just remembering some place in memory by holding it's address.

On any place in memory could start any variable of any type. By casting pointer into some other type than it was created for (like (char*) for example) you let the program know, that he should work with that place in memory as if it was variable of given type.

score 0 · Answer 7 · answered Apr 02 '13 at 21:10

A pointer points to a place in memory (in 32bit systems the width of ALL pointers is 32bit and 64bit systems is 64bit). When you write void* pointer you are telling the compiler that the data in the memory has no type, and therefore the compiler takes default width for to read the contents(eg. 8bit). Remember that the pointer itself is always 32/64 bit, but the data it points differs.

For example when you say char* pointer, it knows that the data is a character and read 2byte for it (32bit). It is the same for int* and others. Or for long* pointer it reads 4byte.

when you write pchar = (char*)data you are telling to the CPU (MMU actually) that the data stored at pchar address is a char and therefore when I said read that, read 2byte for me. When you said (short*) your are telling the MMU to read 1byte for you for that pointer.

if you use void*, the system will use its default size which I think is 1byte.

What does int* pint; pint = (int*)data; mean?

7 Answers7