As talked about by
(Gotealeaf, 2015), a Variable is essentially a name or symbol in computer programming that holds and represents a value (like the number 10, or if something's true or false). Value is what Variable is short for, and it can be further changed or altered in software like Unreal 4 to suit the user's needs. In order to follow professional working practices, good-use of naming conventions must be used when using them, ensuring all the names of variables are similar to each other in format (such as having Time_Start and Time_End, keeping the underscore) and allowing the user to quickly type in each variable when programming, without forgetting how it's set out and referring back and forth to each variable name, thus wasting time.
In Unreal 4 a user normally creates a Variable inside a Blueprint or C++ class, and can then set their data type (talked about below) and then program in their functions using either the Blueprint or C++ scripting languages. Variables in Blueprints are much easier to access and use due to the natural, visual structure it provides. However C++ is much more flexible and capapble when it comes to using Variables, but it has a very intimidating interface with Microsoft's Visual Studio, putting off a lot of beginners and potential users.
(Wiki.unrealengine, 2015)
There are a variety of data types for Variables, ranging from Boolean (true or false statements), to Integers (a number). Here's a table below as provided by
(cplusplus, 2015) showing all of the data types for C++ and their functions:
| Group | Type names* | Notes on size / precision |
|---|
| Character types | char | Exactly one byte in size. At least 8 bits. |
char16_t | Not smaller than char. At least 16 bits. |
char32_t | Not smaller than char16_t. At least 32 bits. |
wchar_t | Can represent the largest supported character set. |
| Integer types (signed) | signed char | Same size as char. At least 8 bits. |
signed short int | Not smaller than char. At least 16 bits. |
signed int | Not smaller than short. At least 16 bits. |
signed long int | Not smaller than int. At least 32 bits. |
signed long long int | Not smaller than long. At least 64 bits. |
| Integer types (unsigned) | unsigned char | (same size as their signed counterparts) |
unsigned short int |
unsigned int |
unsigned long int |
unsigned long long int |
| Floating-point types | float |
|
double | Precision not less than float |
long double | Precision not less than double |
| Boolean type | bool |
|
| Void type | void | no storage |
| Null pointer | decltype(nullptr) |
|
It means the user should always pick the right Variable type for the job since they all have their uses for different scenarios. For example; if a game wanted the player character to open a door when they move near it, the Boolean Variable in the door for whether or not it's closed should be set to true, but when they move within range of its hitbox the Variable will then change to false, and thus he door will open. This will be until the player has left the range of the hitbox and aren't constantly colliding with it anymore, changing the value to true again and closing the door.
Each type has a specific purpose and aren't really interchangeable, which is why you must use certain ones. If you're counting a score in a game and keeping track of a specific number that's constantly changing as the player progresses, an int datatype is compulsory to use as "
The int keyword denotes an integral type that stores values according to the size and range shown in the following table." (Msdn.microsoft a, 2015) So it would be unwise to use a float datatype instead, since they serve a different purpose and the code simply wouldn't work, because: "
The float keyword signifies a simple type that stores 32-bit floating-point values. The following table shows the precision and approximate range for the float type". (Msdn.microsoft b, 2015)
