Avoid stack corruption while writing to a pointer location - c++

Question

Let's assume that, we have a C API exposed by a C++ library where the C client queries a value by passing a void pointer and a key.
bool GetValue(const char* key, void* val) {
if(val != NULL) {
// find the value using the key with some logic of library
// lets assume found value is a int
int foundValue = 34;
*(int*)val = foundValue;
return true; // or false if key not found
}
return false;
}
The C client and the C++ library developers have an agreement about the size of values associated with keys.
Let's assume the C++ library only has int and long long int, and the C client also knows it.
So the C client is expected to behave as follows when the value associated with "some_key" is an int:
int valueHolder;
if(GetValue("some_key",&valueHolder)) {
// do something with valueHolder
}
But the C client can cause stack memory corruption by providing pointer which points to less space. For example, if the C client provides a pointer which points to an unsigned char and the value written by the C++ library is int, stack memory corruption can happen.
So the C client should take proper action to avoid such a situation. My question is, how the C++ library can handle such memory corruption/crash situation and be robust to crash or memory corruption? (a small note: a template or function overload is not an option for me because C++ library can not expose such feature to a C client).

Answer 1

Simply you have to design API in such way that type of the value is clear.
So for example:
bool GetIntValue(const char* key, int* val) {
if(val != NULL && IsIntValue(key)) {
// find the value using the key with some logic of library
// lets assume found value is a int
int foundValue = 34;
val = foundValue;
return true;
}
return false;
}
bool GetSizeValue(const char* key, size_t* val) {
if(val != NULL && IsSizeValue(key)) {
// find the value using the key with some logic of library
// lets assume found value is a int
size_t foundValue = 12;
val = foundValue;
return true;
}
return false;
}
...
Or other way:
enum Types {
Int,
Size,
....
};
struct Variant {
enum Types type;
union {
int integer;
size_t size;
....
};
};
bool GetVariantValue(const char* key, struct Variant* val) {
if(val != NULL) {
...
*val = MakeIntVariant(33);
return true;
}
return false;
}

Answer 2

Unfortunately it cannot be made robust, see this link:
Checking if a pointer is allocated memory or not
You can catch the crash however using something like
try {} catch (...) {}
but there is no guarantee it will crash, and in fact it is very likely to instead overwrite/corrupt adjacent memory.