I have an array of 64 bit unsigned integers. Is it possible to assign some pointers of an array in some positions of it. I mean:
array [0] = Integer
array [1] = Integer
array [2] = Pointer to array
array [3] = Pointer to array
array [4] = Integer
Can anybody help me how to do that ?
One way is to turn array into an array of
union {
uint64_t intval;
uintptr_t ptrval;
};
and work with that.
You will, of course, need some way to know whether a particular element stores an integer or a pointer.
You can use reinterpret_cast:
array[3] = reinterpret_cast<std::uintptr_t>(pointer);
(uintptr_t is from <cstdint>)
Try to avoid doing this if possible though. Can you rethink your design?
reinterpret_cast it back into the pointer... What are you trying to do with this?
Let me guess: you want to have an array, each element of which could be either a number or another array of number ? If so, make an array of std::vectors, and keep only one value if you want to store a number. Like this:
typedef std::vector< long long > I64Vector;
std::vector< I64Vector > array;
array.push_back( I64Vector( { 42 } ) ); // store one integer ( 42 ) in array[ 0 ]
array.push_back( I64Vector( { 1, 2, 3, 4, 5 } ) ); // store 5 integers in array[ 1 ]
//... etc.
// accessing them
long long num = array[ 0 ][ 0 ]; // 42
const I64Vector & subarray = array[ 1 ];
long subNumber1 = subarray[ 0 ]; // 1
long subNumber2 = subarray[ 1 ]; // 2
//... etc.
You have to change the type your array element to something that can store integers and pointers (or preferably std::vector<std::uint64_t>). A type-safe approach is to use
boost::variant:
std::vector<boost::variant<std::uint64_t, std::vector<std::uint64_t>>> array;
array.push_back(1);
array.push_back(2);
array.push_back(std::vector<std::uint64_t>{4,5,6});
if (int* x = boost::get<std::uint64_t>(array[0])) { ... }
if (std::vector<std::uint64_t>* x
= boost::get<std::vector<std::uint64_t>>(array[2])) { ... }
If you want to use builtin arrays instead of vectors you can use unions instead of boost::variant:
struct IntOrArray
{
bool isInt;
union {
std::uint64_t int_value;
std::uint64_t* array_value;
}
};
std::vector<IntOrArray> array;
IntOrArray a1;
IntOrArray a1.isInt = true;
IntOrArray a1.int_value = 1;
array.push_back(a1);
IntOrArray a2;
IntOrArray a2.isInt = false;
IntOrArray a2.array_value = arrayYouGotElsewhere;
array.push_back(a2);
if (array[0].isInt) { ... }
C++11 allows you to put std::vectors into unions but this is not supported by all compilers.
Yes we can do that,
a[3] = (unsigned long long)&a; (in windows)
and to get back the pointer value, (unsigned long long *)a[3]
