What is a Variable?

A variable is the name for a place in the computer's memory where you store some data.

If you are new to programming, please take a look at these articles first.

• What is Programming?.
• What is Software?.
• What is a Programming Language?

Imagine a very large warehouse with lots of storage bays, tables, shelves, special rooms etc. These are all places where you can store something. Lets imagine we have a crate of beer in the warehouse. Where exactly is it located?

We wouldn't say that it is stored 31' 2" from the west wall and 27' 8" from the north wall. In programming terms we also wouldn't say that my total salary paid this year is stored in four bytes starting at location 123,476,542,732 in RAM.

The computer will place variables in different locations each time our program is run. However our program knows exactly where the data is located. We do this by creating a variable to refer to it and then let the compiler handle all the messy details about where it is actually located. It is far more important to us to know what type of data we will be storing in the location.

In our warehouse, our crate might be on section 5 of shelf 3 in the drinks area. In the PC, the program will know exactly where its variables are located.

They exist just as long as they are needed and are then disposed of. Another analogy is that variables are like numbers in a calculator. As soon as you hit the clear or power off buttons, the display numbers are lost.

How Big is a Variable?

In modern programming languages, variables are declared to be of a type.

Apart from numbers, the CPU does not make any kind of distinction about the data in its memory. It treats it as a collection of bytes. Modern CPUs (apart from those in mobile phones) can usually handle both integer and floating point arithmetic in hardware. The compiler has to generate different machine code instructions for each type, so knowing what the type of variable helps it generate optimal code.

• Integers (both signed and unsigned) 1,2,4 or 8 bytes in size. Usually referred to as ints.
• Floating Point Numbers up to 8 bytes in size.
• Bytes. These are organised in 4s or 8s (32 or 64 bits) and read in and out of the CPU's registers.
• Text strings, up to billions of bytes in size. CPUs have special instructions for searching through large blocks of bytes in memory. This is very handy for text operations.

• Variant - This can hold any type but is slower to use.

• Arrays of types- single dimension like drawers in a cabinet, two dimensional like post office sorting boxes or three dimensional like a pile of beer crates. There can be any number of dimensions, up to the limits of the compiler.
• Enums which are a restricted subset of integers.
  • See What is an Enum?
• Structs are a composite variable where several variables are lumped together in one big variable.
• Streams provide a way to manage files. They're a form of string.
• Objects. Like structs but with much more sophisticated data handling.
  • See the Intro to OOP.

In memory but in different ways, depending on how they are used.

• Globally. All parts of the program can access and change the value. This is how older languages like Basic and Fortran used to handle data and it is not considered a good thing. Modern languages tend to discourage global storage though it is still possible.
• On the Heap. This is the name for the main area used. In C and C++, access to this is via pointer variables.
• On the Stack. The stack is a block of memory that is used to store parameters passed into functions, and variables that exist local to functions.

Variables are essential to procedural programming, but it is important not to get too hung up on the underlying implementation unless you are doing systems programming or writing applications that have to run in a small amount of RAM.

My own rules regarding variables are

1. Unless you are tight on ram, or have large arrays, stick with ints rather than a byte (8 bits) or short int (16 bits). Especially on 32 Bit CPUs, there is a extra delay penalty in accessing less than 32 bits.
2. Use floats instead of doubles unless you need the precision.
3. Avoid variants unless really necessary. They are slower.