Variables Symbol representing a place to store information name value memory location Example: someone’s age An integer variable age; age = 20; Contrasted with constants No change in constants Computer memory age 20

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) Provides an easy way (name) to access your computer's memory Computer memory v1 50 v2 30 sum 80

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 As always, case-sensitive

Variable Names – cont. Cannot be C's keywords Size Limitation 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 Preprocessor: interact with input/output of your computer #include <stdio.h> int main() Start point of the program { } Start and finish of function int value1, value2, sum; Declear Variables value1 = 50; value2 = 30; Define Values sum = value1 + value2; Summation printf(“The sum of 50 and 30 is %i\n“, sum); Print the value of an integer variable Printing results return 0; Finish and return value 0

Display Integer Variables – II #include <stdio.h> int main() { int value1, value2, sum; value1 = 50; value2 = 30; sum = value1 + value2; return 0; } printf(“The sum of %i and %i is %i\n“, value1, value2, sum);

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; 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; 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 ±3.4×1038

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.79769×10308 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 integerVar = 100; float floatingVar = 331.79; double doubleVar = 8.44e+11; char 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 Examples: Format: op= Examples: count = count + 10; count += 10; count = count - 5; count -= 5; a /= b + c; a = a / (b + c);

Unary Operators M += 1; M = M + 1; ++M; M++; Unary plus / minus + / - Example: -a Unary increment/decrement ++ / -- M += 1; M = M + 1; ++M; M++;

Arithmetic Operators add: +, minus: -, multiply: *, divide: /, modulus: % Parentheses (grouping): ( ) Unary plus / minus + - Unary increment/decrement ++ --

Operator Precedence Precedence Order for 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