Variables
Symbol representing a place to store information
name value memory location Example: someones age
An integer variable age; age = 20;
Computer memory
age
20
Contrasted with constants
No change in constants
Why use Variables
Remembers a value
Results from calculation Example:
int v1, v2, sum; v1 = 50; v2 = 30; sum = v1 + v2; (= means assign a new value)
Computer memory
v1
50
v2
sum
30
80
Provides an easy way (name) to access your computer's memory
Variable Declaration
A variable must be declared before it can be used.
Tell the compiler that you want to reserve some memory in which to store data of some specified type.
Usually declared at the start of each function. Declaration format:
type name = initial_value; type name1 = initial_value1, name2 = initial_value2, ;
Initial values in declaration are optional.
Declaration of Variables
type name = initial_value; type name1 = initial_value1, name2 = initial_value2, ;
{ int v1, v2, sum; v1 = 50; v2 = 30; sum = v1 + v2; }
{
int v1= 50, v2 = 30, sum; sum = v1 + v2;
Basic Variables types in C
int
integer
float
single-precision floating point
double
double-precision floating point
char
one byte character
Variable Names
Contains one or more characters,
A-Z, a-z 0-9 _
Must start with a non-digit character
A-Z, a-z _
As always, case-sensitive
Variable Names cont.
Cannot be C's keywords
int, main, while, etc
Size Limitation
Maximum of 63 characters for a variable name
Sometimes 31 or 8 in very old C
Case sensitive: upper and lower case characters are regarded as different
floating int Int main3 4yi
int: integer Variables
For integral values only
10, -5, 1000 no fraction
10.2
no commas
12,000
Ranges
Machine dependent
Minimum: 16 digits in a literal integer 32 bits of storage
Signed: 2,147,483,648 to +2,147,483,647 Unsigned: 0 to +4,294,967,295
Maybe 64 on others
Operations for int type
Declaration
int x, y, z;
Assignment
y = 10; z = 5;
Operations Plus: +
x = y + z;
Minus: x = y z;
Muliply: *
x = y * z;
Divide: /
x = y / z;
Modulus
x = y % z;
result of y/z will be truncated
Display Integer Variables I
#include <stdio.h> int main() { int value1, value2, sum;
Preprocessor: interact with input/output of your computer Start point of the program Start and finish of function Declare Variables Define Values Summation Printing results
value1 = 50; value2 = 30; sum = value1 + value2;
printf(The sum of 50 and 30 is %i\n, sum); return 0; }
Finish and return value 0
Print the value of an integer variable
Display Integer Variables II
#include <stdio.h> int main() { int value1, value2, sum; value1 = 50; value2 = 30; sum = value1 + value2; printf(The sum of %i and %i is %i\n, value1, value2, sum); return 0;
int: integer Variables Special Case I
Starting with digit 0
Octal notation. Base 8, not 10
0,1,2,3,4,5,6,7 0177 = 1*64 + 7*8 + 7 = 127 0256 = ?
Display
%i print out the decimal value %o print out the octal value
int: integer Variables Special Case II
Starting with digit 0x
Hexadecimal notation. Based 16, not 10
0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F 0x177 = 1*256 + 7*16 + 7 = 375 0xAF = ? 0x2AF = ?
Display
%i print out the decimal value %x print out the hexadecimal value
Example - I
#include <stdio.h> int main() { int a, b, c, d; a = 10; b = 20; c = 0177; d = 0xAF; printf(The four numbers are %i, %i, %o, %x\n, a, b, c, d); printf(The four decimal numbers are %i, %i, %i, %i\n, a, b, c, d); }
Example II
#include <stdio.h> int main() { int a, b, c, f; a = 10; b = 20; c = 0177; f = a/b; printf(%i / %i = %i\n, a, b, f); f = b/a; printf(%i / %i = %i\n, b, a, f); f = c/a; printf(%i / %i = %i\n, c, a, f); }
float: single-precision Variables
For values containing a fractional value
3., 125.8, -0.1 Scientific notation 2.25e-3 = 2.25 * 10-3 = 0.00225
Use e or E for exponent
no commas used in big numbers
float Variables - II
Ranges
IEEE floating-point standard
e = 8, f = 23
3.41038
float Variables - III
Display
%f print out the decimal value %e print out the scientific notation %g let printf decide the format
-4 < value of exponent < 5: %f format Otherwise: %e format
Operations for float type
Declaration
float x, y, z;
Assignment
y = 10.00; z = 5.8;
Calculation Plus: +
x = y + z;
Minus: x = y z;
Muliply: *
x = y * z;
Divide: /
x = y / z;
result of y/z will NOT be truncated
Example I
#include <stdio.h> int main() { int a, b, c; float f; a = 10; b = 20; c = a/b; printf(%i / %i = %i\n, a, b, c); f = a/b; printf(%i / %i = %f\n, a, b, f); }
double: double-precision Variables
Similar to float
More storage space (IEEE floating-point standard)
float variables: e+f+1 = 32 double variables: e+f+1 = 64
Ranges 1.7976910308
Same display method as float Operation similar as float
char: character Variables
For single character
Enclosing the character within a pair of
a ; P \n 1
Display
%c
Example II
#include <stdio.h> int main() { int a, b, f; char c;
a = 36; b = 52; c = a;
printf(The three numbers are %i , %i, %i\n, a, b, c); printf(The three characters are %c , %c, %c\n, a, b, c); }
Finish the Code
#include <stdio.h> int main(void) { int float double char integerVar = 100; floatingVar = 331.79; doubleVar = 8.44e+11; charVar = W;
printf(integerVar = %? \n, integerVar); printf(floatingVar = %? \n, floatingVar ); printf(doubleVar = %? \n, doubleVar ); printf(doubleVar = %? \n, doubleVar ); // scientific notation printf(charVar = %? \n, charVar ); return 0; }
Special variable types
short
usually use less space add h after % in printf
long, long long
usually use more space use l to indicate add l after % in printf
signed, unsigned
specify whether is a signed quantity use u to indicate unsigned %u for unsigned
Assignment Operators
Join the arithmetic operators
Format: op=
Examples:
count = count + 10;
count = count - 5; a /= b + c;
count += 10; count -= 5; a = a / (b + c);
Unary Operators
Unary plus / minus
+/ Example: -a
Unary increment/decrement
++ / --
M = M + 1;
M += 1;
++M;
M++;
Arithmetic Operators
add: +, minus: -, multiply: *, divide: /, modulus: % Parentheses (grouping): ( ) Unary plus / minus
+ -
Unary increment/decrement
++ --
Operator Precedence
Precedence
Operators with higher precedence are evaluated first Operators with same precedence are evaluated from left to right In decreasing precedence
() unary increment (++), unary decrement (--) unary plus (+), unary minus (-) multiply (*), divide(/), modulus(%) add(+), minus(-)
Order for
c = -a * b a+b*c/d
