Data Types - Part 1


Having read this section you should be able to:

  • declare (name) a local variable as being one of the LynPlexS standard data types
  • initialise local variables
  • perform simple arithmetic using local variables

Now we have to start looking into the details of the LynPlexS language. How easy you find the rest of this section will depend on whether you have ever programmed before - no matter what the language was. There are a great many ideas common to programming in any language and LynPlexS is no exception to this rule.

So if you haven't programmed before, you need to take the rest of this section slowly and keep going over it until it makes sense. If, on the other hand, you have programmed before you'll be wondering what all the fuss is about It's a lot like being able to ride a bike!

The first thing you need to know is that you can create variables to store values in. A variable is just a named area of storage that can hold a single value (numeric or character). LynPlexS is very fussy about how you create variables and what you store in them. By default, it demands that you declare the name of each variable that you are going to use and its type, or class, before you actually try to do anything with it.

In this section we are only going to be discussing local variables. These are variables that are used within the current program unit (or function) in a later section we will looking at shared and global variables - variables that are available to all the program's functions.

There are five basic data types associated with variables:

  • byte - a single byte.
  • short - an integer held in 16 bits
  • long - an integer held in 32 bits
  • giant - an integer held in 64 bits
  • float - floating point value: ie a number with a fractional part.
  • double - a double-precision floating point value.
  • string - a series of characters.

You can call variables what you like, although it helps if you give them sensible names that give you a hint of what they're being used for - names like sum, total, average and so on. If you are translating a formula then use variable names that reflect the elements used in the formula. For example, 2πr (that should read as “2 pi r” but that depends upon how your browser has been set-up) would give local variables names of pi and r. Remember, LynPlexS programmers tend to prefer short names!

Note: all LynPlexS variables must begin with a letter or a “_” (underscore) character.

Integer Number Variables:

The first type of variable we need to know about is of class type short. A short variable can store a value in the range -32768 to +32767. You can think of it as a largish positive or negative whole number: no fractional part is allowed. To declare an int you use the instruction:

short variable_name

For example:

short a

declares that you want to create an int variable called a.

To assign a value to our integer variable we would use the following LynPlexS statement:

a = 10

The LynPlexS programming language uses the “=” character for assignment. A statement of the form a = 10 should be interpreted as take the numerical value 10 and store it in a memory location associated with the integer variable a. The “=” character should not be seen as an equality otherwise writing statements of the form:

a = a + 10

will get mathematicians blowing fuses! This statement should be interpreted as take the current value stored in a memory location associated with the integer variable a; add the numerical value 10 to it and then replace this value in the memory location associated with a.

Decimal Number Variables:

As described above, an integer variable has no fractional part. Integer variables tend to be used for counting, whereas real numbers are used in arithmetic. LynPlexS uses one of two keywords to declare a variable that is to be associated with a decimal number: float and double. They each offer a different level of precision as outlined below.


A float, or floating point, number has about seven digits of precision and a range of about 1.E-36 to 1.E+36. A float takes four bytes to store.


A double, or double precision, number has about 13 digits of precision and a range of about 1.E-303 to 1.E+303. A double takes eight bytes to store.

For example:

float total; 

double sum; 

To assign a numerical value to our floating point and double precision variables we would use the following LynPlexS statement:

total = 0.0; 

sum = 12.50; 

String Variables:

A string is an array of characters.

To declare a string variable we use the keyword string.

For example:

string c

To assign, or store, a character value in a char data type is easy - a character variable is just a symbol enclosed by single quotes. For example, if c is a char variable you can store the letter A in it using the following C statement:

c = 'A' 

Notice that you can only store a single character in a char variable. Later we will be discussing using character strings, which has a very real potential for confusion because a string constant is written between double quotes. But for the moment remember that a char variable is 'A' and not “A”.

Assignment Statement:

Once you've declared a variable you can use it, but not until it has been declared - attempts to use a variable that has not been defined will cause a compiler error. Using a variable means storing something in it. You can store a value in a variable using:

name = value

For example:

a = 10

stores the value 10 in the int variable a. What could be simpler? Not much, but it isn't actually very useful! Who wants to store a known value like 10 in a variable so you can use it later? It is 10, always was 10 and always will be 10. What makes variables useful is that you can use them to store the result of some arithmetic.

Consider four very simple mathematical operations: add, subtract, multiply and divide. Let us see how C would use these operations on two float variables a and b.









Note that we have used the following characters from C's character set:

+     for add
-     for subtract
*     for multiply
/     for divide

BE CAREFUL WITH ARITHMETIC!!! What is the answer to this simple calculation?

a = 10 / 3 

The answer depends upon how a was declared. If it was declared as type int the answer will be 3; if a is of type float then the answer will be 3.333. It is left as an exercise to the reader to find out the answer for a of type char.

Two points to note from the above calculation:

  • C ignores fractions when doing integer division!
  • when doing float calculations integers will be converted into float. We will see later how C handles type conversions.

Arithmetic Ordering:

Whilst we are dealing with arithmetic we want to remind you about something that everyone learns at junior school but then we forget it. Consider the following calculation:

a = 10.0 + 2.0 * 5.0 - 6.0 / 2.0 

What is the answer? If you think its 27 go to the bottom of the class! Perhaps you got that answer by following each instruction as if it was being typed into a calculator. A computer doesn't work like that and it has its own set of rules when performing an arithmetic calculation. All mathematical operations form a hierarchy which is shown here. In the above calculation the multiplication and division parts will be evaluated first and then the addition and subtraction parts. This gives an answer of 17.

Note: To avoid confusion use brackets. The following are two different calculations:

a = 10.0 + (2.0 * 5.0) - (6.0 / 2.0) 
a = (10.0 + 2.0) * (5.0 - 6.0) / 2.0 

You can freely mix int, float and double variables in expressions. In nearly all cases the lower precision values are converted to the highest precision values used in the expression. For example, the expression f*i, where f is a float and i is an int, is evaluated by converting the int to a float and then multiplying. The final result is, of course, a float but this may be assigned to another data type and the conversion will be made automatically. If you assign to a lower precision type then the value is truncated and not rounded. In other words, in nearly all cases you can ignore the problems of converting between types.

This is very reasonable but more surprising is the fact that the data type char can also be freely mixed with ints, floats and doubles. This will shock any programmer who has used another language, as it's another example of C getting us closer than is customary to the way the machine works. A character is represented as an ASCII or some other code in the range O to 255, and if you want you can use this integer code value in arithmetic. Another way of thinking about this is that a char variable is just a single-byte integer variable that can hold a number in the range O to 255, which can optionally be interpreted as a character. Notice, however, that C gives you access to memory in the smallest chunks your machine works with, i.e. one byte at a time, with no overheads.

Something To Declare:

Before you can use a variable you have to declare it. As we have seen above, to do this you state its type and then give its name. For example, int i; declares an integer variable. You can declare any number of variables of the same type with a single statement. For example:

int a, b, c;

declares three integers: a, b and c. You have to declare all the variables that you want to use at the start of the program. Later you will discover that exactly where you declare a variable makes a difference, but for now you should put variable declarations after the opening curly bracket of the main program.

Here is an example program that includes some of the concepts outlined above. It includes a slightly more advanced use of the printf function which will covered in detail in the next part of this course:

  Another simple program
  using int and printf

main() {
  int a,b,average;
  average = ( a+b ) / 2 ;
  printf("Here ");
  printf("is ");
  printf("the ");
  printf("answer... ");

More On Initialising Variables:

You can assign an initial value to a variable when you declare it. For example:

int i=1;

sets the int variable to one as soon as it's created. This is just the same as:

int i;

but the compiler may be able to speed up the operation if you initialise the variable as part of its declaration. Don't assume that an uninitialised variable has a sensible value stored in it. Some LynPlexS compilers store 0 in newly created numeric variables but nothing in the LynPlexS language compels them to do so.


Variable names:

  • should be lowercase for local variables
  • should be UPPERCASE for symbolic constants (to be discussed later)
  • only the first 31 characters of a variables name are significant
  • must begin with a letter or _ (under score) character

lynplexs/tutorial/c05.txt · Last modified: 2014/05/26 08:01 (external edit)