C programming for Engineers

1. C programming for Engineers • Lcc compiler – a free C compiler available on the web. • http://www.cs.virginia.edu/~lcc-win32/ • Some instructions

2. What are variables? • A named area in the computer memory, intended to contain values of a certain kind (integers, real numbers, etc.) • They contain the data your program works with. • They can be used to store data to be used elsewhere in the program. • In short – they are the only way to manipulate data.

3. Variables in memory int my_int = 5; double my_double = 3.5; my_int 5 my_double 3.5

4. Variables in memory • Whenever we write the variable name (my_int), we ask to read the value of that variable • If we write &variable_name, we ask for the address of that variable my_int 5 my_double 3.5

5. Example /* Get a length in cm and convert to inches */ #include <stdio.h> int main() { double cm, inches; printf("Please enter length in centimeters: "); scanf("%lf", &cm); inches = cm / 2.54; printf("This is equal to %g inches\n", inches); return 0; }

6. Declaring variables in C double cm, inches; • Before using a variable, one must declare it. • The declaration first introduces the variable type, then its name. • When a variable is declared, its value is undefined.

7. Example: variable declarations • int i; • char c; • float f1, f2; • float f1=7.0, f2 = 5.2; • unsigned int ui = 0;

8. Variable naming rules • Letters, digits, underscores • i • CSE_5a • a_very_long_name_that_isnt_very_useful • fahrenheit • First character cannot be a digit • 5a_CSE is not valid! • Case sensitive • CSE_5a is different from cse_5a

9. Data types in C • char – a single byte character. • int – an integer number – usually 4 bytes. • float – a single precision real number – usually 4 bytes. • double – a double precision real number – usually 8 bytes. char float int double

10. Data types in C • short int (or just short) – an integer number, usually 2 bytes (rarely used). • long int (or just long) – an integer number, 4 or 8 bytes (rarely used). • long double - a double precision real number – usually 8 bytes (rarely used). • unsigned vs. signed

11. That example again /* Get a length in cm and convert to inches */ #include <stdio.h> int main() { double cm, inches; printf("Please enter length in centimeters: "); scanf("%lf", &cm); inches = cm / 2.54; printf("This is equal to %g inches\n", inches); return 0; }

12. printf and scanf • printf – prints to the screen. • Can also accept variables and print their values. • scanf – gets values from the standard input and assigns them to variables.

13. printf can print variable values printf("z=%d\n",z); • The sequence %d is a special sequence and is not printed! • It indicates to printf to print the value of an integer variable written after the printed string.

14. scanf gets input from the user scanf("%lf", &cm); • This statement waits for the user to type in a double value, and stores it in the variable named ‘cm’. • To get 2 doubles from the user, use –scanf("%lf%lf", &var1, &var2);

15. prinft/scanf conversion codes • A %<conversion code> in the printf/scanf string is replaced by the respective variable. • %c – a character • %d – an integer, %u – an unsigned integer. • %f – a float • %lf – a double • %g – a nicer way to show a double (in printf) • %% - the ‘%’ character (in printf)

16. One last time /* Get a length in cm and convert to inches */ #include <stdio.h> int main() { double cm, inches; printf("Please enter length in centimeters: "); scanf("%lf",&cm); inches = cm / 2.54; printf("This is equal to %g inches\n", inches); return 0; }

17. Exercise Write a program that accepts as input - • The Dollar-Shekel exchange rate • An integer amount of dollars and outputs - • The equivalent amount in Shekels

18. Solution #include <stdio.h> int main() { double shekels, xchange; int dollars; printf("Enter the US$-NIS exchange rate: "); scanf("%lf", &xchange); printf("Enter the amount of dollars: "); scanf("%d", &dollars); shekels = dollars * xchange; printf("%d dollars = %g shekels\n", dollars, shekels); return 0; }

19. Char is also a number! • A char variable is used to store a text character: • Letters. • Digits. • Keyboard signs. • Non-printable characters. • But also small numbers (0 to 255 or -128 to 127).

20. Text as numbers • Every character is assigned a numeric code. • There are different sets of codes: • ASCII (American Standard Code for Information Interchange) – most common. • EBCDIC – ancient, hardly used today. • Maybe others. • We will use ASCII. • The ASCII table.

21. More about character encoding • Most of the time, you don't care what the particular numbers are. • The table above shows only 128 characters (7 bits). Some are non-printable. • Extended ASCII code contains 256 characters.

22. More about character encoding • ASCII code 0 (NULL character) is important – we will see it again. • Note contiguous sets of numbers, upper case and lower case characters.

23. Example of char as both a character and a small number #include <stdio.h> int main() { char i = 'b'; printf("i as a character is %c\n", i); printf("i as an integer is %d\n", i); printf("The character after %c is %c\n", i, i + 1); return 0; }

24. Another example /* Get the position of a letter in the abc */ #include <stdio.h> int main() { char letter; printf("Please enter a lowercase letter\n"); scanf("%c", &letter); printf("The position of this letter in the abc is %d\n", letter - 'a' + 1); return 0; }

25. Exercise Write a program that accepts as input – • A lowercase letter and outputs – • The same letter in uppercase (e.g., if the input is ‘g’, the output should be ‘G’)

26. Solution /* Convert a letter to uppercase */ #include <stdio.h> int main() { char letter; printf("Please enter a lowercase letter\n"); scanf("%c", &letter); printf("This letter in uppercase is %c\n", letter - 'a' + 'A'); return 0; }

27. Arithmetic operators • An operator is an action performed on something (e.g. constants, variables). • That “something” is called an operand. • Common operators: • Assignment = • Addition + • Subtraction - • Multiplication * • Division / • Modulo %

28. Example Arithmetic operators on variables - digits.c

29. Let’s see how it works int main() { int sum, num; sum = 0; printf("Enter 3-digits number\n"); scanf("%d", &num); /*extract the first digit*/ sum = sum + num % 10; num = num / 10; num sum 1350 5198 Arbitrary numbers (garbage)

30. Let’s see how it works int main() { int sum, num; sum = 0; printf("Enter 3-digits number\n"); scanf("%d", &num); /*extract the first digit*/ sum = sum + num % 10; num = num / 10; num sum 1350 5198

31. Let’s see how it works int main() { int sum, num; sum = 0; printf("Enter 3-digits number\n"); scanf("%d", &num); /*extract the first digit*/ sum = sum + num % 10; num = num / 10; num sum 1350 0

32. Let’s see how it works int main() { int sum, num; sum = 0; printf("Enter 3-digits number\n"); scanf("%d", &num); /*extract the first digit*/ sum = sum + num % 10; num = num / 10; num sum 1350 0

33. Let’s see how it works int main() { int sum, num; sum = 0; printf("Enter 3-digits number\n"); scanf("%d", &num); /*extract the first digit*/ sum = sum + num % 10; num = num / 10; num sum 369 0

34. Let’s see how it works int main() { int sum, num; sum = 0; printf("Enter 3-digits number\n"); scanf("%d", &num); /*extract the first digit*/ sum = sum + num % 10; num = num / 10; num sum 369 0

35. Let’s see how it works int main() { int sum, num; sum = 0; printf("Enter 3-digits number\n"); scanf("%d", &num); /*extract the first digit*/ sum = sum + num % 10; num = num / 10; num sum 369 9

36. Let’s see how it works int main() { int sum, num; sum = 0; printf("Enter 3-digits number\n"); scanf("%d", &num); /*extract the first digit*/ sum = sum + num % 10; num = num / 10; num sum 369 9

37. Let’s see how it works int main() { int sum, num; sum = 0; printf("Enter 3-digits number\n"); scanf("%d", &num); /*extract the first digit*/ sum = sum + num % 10; num = num / 10; num sum 36 9

38. Let’s see how it works /*extract the second digit*/ sum = sum + num % 10; num = num / 10; /*extract the third digit*/ sum = sum + num % 10; printf("The digits sum is %d\n", sum); return 0; } num sum 36 9

39. Let’s see how it works /*extract the second digit*/ sum = sum + num % 10; num = num / 10; /*extract the third digit*/ sum = sum + num % 10; printf("The digits sum is %d\n", sum); return 0; } num sum 36 15

40. Let’s see how it works /*extract the second digit*/ sum = sum + num % 10; num = num / 10; /*extract the third digit*/ sum = sum + num % 10; printf("The digits sum is %d\n", sum); return 0; } num sum 36 15

41. Let’s see how it works /*extract the second digit*/ sum = sum + num % 10; num = num / 10; /*extract the third digit*/ sum = sum + num % 10; printf("The digits sum is %d\n", sum); return 0; } num sum 3 15

42. Let’s see how it works /*extract the second digit*/ sum = sum + num % 10; num = num / 10; /*extract the third digit*/ sum = sum + num % 10; printf("The digits sum is %d\n", sum); return 0; } num sum 3 15

43. Let’s see how it works /*extract the second digit*/ sum = sum + num % 10; num = num / 10; /*extract the third digit*/ sum = sum + num % 10; printf("The digits sum is %d\n", sum); return 0; } num sum 3 18

44. Operations with different types • When operands of two different types are involved in an operation, the operand of the ‘weaker’ type is promoted to the other type (int → float → double). • The result of the operation is of the higher type. • When the operands are of the same type, the result is of that type as well.

45. Operations with different types For example - • 3 + 4 = 7 • 3.0 + 4 = 7.0 • 3 / 4 = 0 !!! • 3.0 / 4 = 0.75

46. Operations with different types • Sometimes it is desirable for a variable of one type to be considered as belonging to another in an operation • We say the variable is cast to the new type. • The casting operator is of the form: (type) • For example, (float)i casts the variable i to a float.

47. Casting variables #include <stdio.h> int main() { int a=1, b=2; printf("%d / %d = %d\n", a, b, a/b); printf("%d / %d = %g\n", a, b, (float)a / b); }

48. Example – find what’s wrong #include <stdio.h> int main() { int a = 10; int b = 20; printf("The average of %d and %d is %d\n", a, b, (a + b) * (1 / 2)); return 0; }

49. Will this work? #include <stdio.h> int main() { int a = 10; int b = 20; printf ("The average of %d and %d is %d\n", a, b, (a + b)*(1.0 / 2)); return 0; }

50. The unsigned qualifier • Normally, the last bit of a variable serves as a sign bit. • In unsigned variables, it has the same role as an ordinary bit. • Because of the extra bit, the range of possible values is doubled – but only for positive numbers. • For example, unsigned chars can range from 0 to 255 while (signed) chars range from -128 to 127. • To declare a variable as unsigned, add the ‘unsigned’ keyword before its type. For example – unsigned int ui;