Contents
This website uses cookies and other technology to provide you a more personalized
experience. By
continuing the view of our web-pages you accept the terms of using these files. If you
don't
want your personal data to be processed, please, leave this site.
Learn More →
V207. A 32-bit variable is utilized as a reference to a pointer. A write outside the bounds of this variable may occur.
This warning informs you about an explicit conversion of a 32-bit integer variable to the reference to pointer type.
Let's start with a simple synthetic example:
int A;
(int *&)A = pointer;Suppose we need for some reason to write a pointer into an integer variable. To do this, we can cast the integer 'A' variable to the 'int *&' type (reference to pointer).
This code can work well in a 32-bit system as the 'int' type and the pointer have the same sizes. But in a 64-bit system, writing outside the 'A' variable's memory bounds will occur, which will in its turn lead to undefined behavior.
To fix the bug, we need to use one of the memsize-types - for example intptr_t:
intptr_t A;
(intptr_t *&)A = pointer;Now let's discuss a more complicated example, based on code taken from a real-life application:
enum MyEnum { VAL1, VAL2 };
void Get(void*& data) {
static int value;
data = &value;
}
void M() {
MyEnum e;
Get((void*&)e);
....
}There is a function which returns values of the pointer type. One of the returned values is written into a variable of the 'enum' type. We won't discuss now the reason for doing so; we are rather interested in the fact that this code used to work right in the 32-bit mode while its 64-bit version doesn't - the Get() function changes not only the 'e' variable but the nearby memory as well.