Cast int* to const short int* - c++

Question

I am using functions from a library where a most-important function takes arguments of type const short int*. What I have instead is int * and was wondering if there was a way of casting an int * into a const short int*. The following code snippet highlights the problem I am facing:
/* simple program to convert int* to const short* */
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
void disp(const short* arr, int len) {
int i = 0;
for(i = 0; i < len; i++) {
printf("ith index = %hd\n", arr[i]);
}
}
int main(int argc, char* argv[]) {
int len = 10, i = 0;
int *arr = (int *) malloc(sizeof(int) * len);
for(i = 0; i < len; i++) {
arr[i] = i;
}
disp(arr, len);
return 0;
}
The above code snippet compiles.
This is what I have tried so far:
1. Tried the c-style cast. Function call looked something like so:
disp((const short*) arr, len). The resulting output was quite weird:
ith index = 0
ith index = 0
ith index = 1
ith index = 0
ith index = 2
ith index = 0
ith index = 3
ith index = 0
ith index = 4
ith index = 0
Tried the const-ness cast. Function call looked like:
disp(const_cast<const short*> arr, len);
This resulted in an error while compiling.
My question(s):
1. Why is the output in approach 1 so weird? What is going on over there?
2. I saw some examples that remove const-ness using the const cast in approach 2. I do not know how to add the same.
3. Is there a way to cast an int* into a const short int*?
P.S: If there are questions of this sort that have been asked before, please do let me know. I googled it and did not find anything specific.

Answer 1

In general, casting from int * to short * will not give useful behaviour (in fact, it will probably lead to undefined behaviour if you try to dereference the resulting pointer). They are pointers to fundamentally different types.
If your function expects a pointer to a bunch of shorts, then that's what you'll need to give it. You'll need to create an array of short, and populate it from your original array.

Answer 2

Casts are almost always a sign of a design problem. If you have a function that takes a short* (const or otherwise), you need to call it with a short*. So instead of allocating an array of int, allocate an array of short.
When you cast an int* to a short* you're telling the compiler to pretend that the int* is really a pointer to short. It will do that, but having lied to the compiler, you're responsible for the consequences.

Answer 3

Right, so the SIZE of a short is different to an int in many environments (it doesn't have to be, and there are certainly compilers that for example have 16-bit int and 16-bit short).
So what you get out of casting a pointer in this way is, a) undefined behaviour, and b) unless you know exactly what you are doing, probably not what you wanted anyway.
The output from your code looks perfectly fine from what I'd expect, so clearly you are not telling us something about what you are trying to do!
Edit: Note that since pointers are "size-dependant", if you cast a pointer of one size to a pointer to a type of a different size, the alignment of the data will be wrong, which is why every other value is zero in your output - because an int is 4 bytes [typically] and a short is 2 bytes, the pointer will "step" 2 bytes for each index, (so arr[i] will be original arr + i * 2 bytes. where the int * arr has a 'step' of 4 bytes, so arr + i * 4 bytes. Depending on your integer values, you will get some "half an integer" values out of this - since your numbers are small, this is zero.
So, whilst the compiler is doing exactly what you ask it to do: make a pointer to short point to a lump of memory containing int, it won't do what you EXPECT it to do, namely translate each int into a short. To do that, you will either have to do:
short **sarr = malloc(sizof(short *) * 10);
for(i = 0; i < 10; i++)
{
sarr[i] = (short *)(&arr[i]); // This may well not work, since you get the "wrong half" of the int.
}
If this gives the wrong half, you can do this:
sarr[i] = (short *)(&arr[i])+1; // Get second half of int.
But it depends on the "byte-order" (big endian or little endian) so it's not portable. And it's very bad coding style to do this in general code.
Or:
short *sarr = malloc(sizof(short *) * 10);
for(i = 0; i < 10; i++)
{
sarr[i] = (short)(arr[i]);
}
The second method works in the sense that it makes a copy of your integer array into a short array. This also doesn't depend on the order the content is stored, or anything like that. Of course, if the value in arr[i] is greater than what can fit in a short, you don't get the same value as arr[i] in your short!
And in both cases don't forget to free your array when it is no longer needed.

Answer 4

Answer to q.1
The output is not weird at all. Apparently, your compiler assign each int 4 bytes and each short 2 bytes. Therefore, your arr is of size 10x4 = 40 bytes. When you assign numbers 0..9 to it you have in memory (one char per byte, grouped by int ):
0 0 0 0
0 0 0 1
0 0 0 2
0 0 0 3
0 0 0 4
...
When you cast arr to short the memory is now "grouped" into 2 bytes :
0 0
0 0
0 0
0 1
0 0
0 2
0 0
...
I hope you can see the effect, and why you suddenly have 0-s in between the numbers you assigned.
Answer to q.2
The declaration of const in the function display only means that the content of arr will not be changed during the execution of display. You do not need to explicitly cast the argument to const array in order to invoke display.
Answer to q.3
please see answers by #Pete and #Mats