Programming I
Variables, Types and Constants
Dimitrios Michail
Dept. of Informatics and Telematics
Harokopio University of Athens
. . . .... .... .... . . . . .
Memory
0
4
8
12 byte
16
20
24
28 32-bit word
32
36
40
Memory behaves like an one dimensional array which we can address
using an address which is either a 32-bit or 64-bit number depending on
the architecture. The figure above presents the 32-bit version.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Variables in C
C language provides with an easy way to address the memory, without
the need to memorize memory addresses.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Variables in C
int main() {
int x1, x2, sum;
x1 = 1;
x2 = 2;
sum = x1 + x2;
}
In the program above we inform the compiler that we are going to require
the use of three memory locations in order to store integer numbers.
These 3 memory locations are going to be named x1, x2, and sum
respectively.
The compiler remembers the mapping between names and addresses.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Memory
0
4
8
12
16
20
24
28
32
36
40
x1
x2
sum
Variable names are shorthands for memory addresses.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Variables in C
int main() {
int x1, x2, sum;
x1 = 1;
x2 = 2;
sum = x1 + x2;
}
Memory locations of local variables are not initialized. It is the duty of
the programmer to provide with initial values.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Variables in C
#include <stdio.h>
int main() {
int x1, x2, sum;
x1 = 1;
x2 = 2;
sum = x1 + x2;
}
▶ Store value 1 at the memory location of variable x1 and 2 at the
memory location of variable x2.
▶ Finally read these two values again, add them up and store the
result at the memory location of variable sum.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Variables in C
0
4
8
12
16
20
24
28
32
36
40
x1 00000000 00000000 00000000 00000001
00000000 00000000 00000000 00000010
x2
sum 00000000 00000000 00000000 00000011
Variables are shorthands for memory addresses.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Variables in C
Every variable has:
1. name
2. type
3. value
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Variables in C
Name
A valid variable name in C must begin with a letter (not a digit), it
should not contain any spaces and should be equal to certain reserved
keywords such as main.
wrong variable names
int main;
int 3x;
int hello world;
correct variable names
int Main;
int x123456;
int hello_world;
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Variables in C
Type
When we are declaring a variable, we explain to the compiler what kind
of information we are going to store in that location.
Basic data types
1. integer: int x;
2. character: char x;
3. floating point (approximate representation for real numbers):
float x;
There are more data types. We are going to see them in more detail after
we learn a few things about number representation in a computer.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Variables in C
C language requires all variable sto be declared at the beginning of a
block. For example:
int main() {
int x, y, z; /* declare all variables */
x = 1;
y = 2;
z = x + y;
int i; /* ΝΟ! */
}
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Variables in C
From C99 and afterwards, we can also declare variable in other locations.
int main() {
int x, y, z; /* declare some variables */
x = 1;
y = 2;
z = x + y;
int i; /* YES! */
}
It is nowadays considered best practice to declare variables as close to
their use as possible.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Type int
Type int stores integers and its size depends on the architecture of the
computer that we are compiling our program.
▶ it must be able to take any value ∈ [−32767, 32767]
▶ in recent architectures, it can take any value
∈ [−2147483648, 2147483647]
This means that it needs 32-bits.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Type char
Type char is used to store characters.
int main() {
char c;
c = 'x';
}
In C characters are representation by numbers using the ASCII encoding.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Type char
Decimal Hex Char Decimal Hex Char Decimal Hex Char Decimal Hex Char
The 95 printable characters from 32 to 126 (decimal). Characted from 0
to 31 are special characters for controlling the output devices, e.g. 8 is
BACKSPACE, 13 is ENTER and 27 is ESC. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
printf and characters
#include <stdio.h>
int main() {
char c = 'a';
printf("character %c is number %d in ASCII encoding\n", c, c);
}
The above program prints:
character a is number 97 in ASCII encoding
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Type float
float is a type for approximately representing real numbers.
#include <stdio.h>
int main() {
float pi = 3.14159265;
printf("pi is approximately %f\n", pi);
}
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Maximum and Minimum Values for Integer Types
The table below is taked from the C specification.
type minimum value maximum value
char ≤ −127 ≥ +127
unsigned char ≤0 ≥ +255
short int ≤ −32767 ≥ +32767
unsigned short int ≤0 ≥ +65535
int ≤ −32767 ≥ +32767
unsigned int ≤0 ≥ +65535
long ≤ 2147483647 ≥ +2147483647
unsigned long ≤0 ≥ +4294967295
Recent compilers have larger bounds. For example type int usually has
the bounds that are shown for long in the table above.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Types and Limits of Floating Point Numbers
type minimum value maximum value
float ≤ −1E − 37 ≥ 1E + 37
double ≤ −1E − 37 ≥ 1E + 37
Modern compilers have larger limits from the ones mentioned in the
ANSI C specification. For example, gcc on my computer has:
−1.175494E − 38 ≤ x ≤ 3.402823E + 38
for type float and:
−2.225074E − 308 ≤ x ≤ 1.797693E + 308
for type double.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Function printf
The general form of printf() is:
int printf(const char * format, ...);
The parameter format contains the text to be printed along with special
character sequences which help to print the expressions that follow.
These special sequences have the general form:
%[flags][width][.precision][length]specifier
Except for the specifier everything else is optional.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Specifiers of printf()
Most specifiers are shown in the following table:
specifier Output Example
c character a
d�i decimal with sign 392
e scientific notation using e 3.9265e+2
E scientific notation using E 3.9265E+2
f decimal floating point number 392.65
o octal with sign 610
s string sample
u decimal without sign 7235
x hexadecimal without sign 7fa
X hexadecimal without sign with capitals 7FA
Line
printf("%d, %o and %x\n", 27, 27, 27);
prints 27, 33 and 1b.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
printf() and padding
The width is a number which tells printf how many spaces to add to
the output in order for the result to have the specified characters.
#include <stdio.h>
#include <stdlib.h>
int main() {
int a = 100;
int b = 1000;
int c = 10000;
printf("%7d\n", a);
printf("%7d\n", b);
printf("%7d\n", c);
printf("%7d\n", 1000000);
}
prints
100
1000
10000
1000000 .
.
.
.
.
. . . . .
. . . .
. . . .
. . . .
. . . .
. . . . .
.
.
.
.
.
.
.
.
.
printf() and precision
Precision has different meaning based on each type:
▶ for integers it denotes the least amount of digits to be printed
(possible by including additional zeros a the beginning)
▶ for floats is represents the number of digits after the decimal
▶ for strings it denotes the maximum number of characters to be
printed
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
int and precision
Denotes the least amount of digits to be printed (possible by including
additional zeros a the beginning)
#include <stdio.h>
#include <stdlib.h>
int main() {
int a = 100;
int b = 10000;
int c = 1000000;
printf( "%10.7d\n", a );
printf( "%.7d\n", b );
printf( "%.7d\n", c );
return 0;
}
prints
0000100
0010000
1000000 .
.
.
.
.
. . . . .
. . . .
. . . .
. . . .
. . . .
. . . . .
.
.
.
.
.
.
.
.
.
float and precision
Denotes the number of digits after the decimal.
#include <stdio.h>
#include <stdlib.h>
int main() {
float pi = 3.14159265;
printf( "%.3f\n", pi );
printf( "%.10f\n", pi );
return 0;
}
prints
3.142
3.1415927410
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
printf() and Special Characters
The special characters in C can be found in the following table:
character ASCII code special character in C
newline 10 '\n '
tab 9 '\t '
carriage return 13 '\r '
backspace 8 '\b '
form feed 12 '\f '
backslash 92 '\\'
single quotation mark 39 '\''
double quotation mark 34 '\"'
null character 0 '\0'
for example the following code
printf("Very\tSimple\nExample");
prints
Very Simple
Example . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Constants
There are several different kind of constants:
▶ literals
▶ symbolic constants
▶ declared constants using const
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Constants
There are several different kind of constants:
▶ literals: types directly in the code
int count;
count = 3;
▶ symbolic constants
▶ declared constants using const
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Constants
There are several different kind of constants:
▶ literals
▶ symbolic constants: the pre-processor allows us to define symbols
which during the pre-processing phase are replaced with
corresponding values.
#include <stdio.h>
#define MAX 100
int main() {
int x = MAX;
printf( "%d\n", x );
return 0;
}
▶ declared constants using const
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Constants
There are several different kind of constants:
▶ literals
▶ symbolic constants
▶ declared constants using const:
used in variable declarations and informs the compiler that a variable
is not supposed to change value.
int main() {
const int x = 3;
x = 5; /* Compilation error! */
}
If anyone tries to change the value, the compiler reports an error.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
