Programming in C

• short ints is no longer than int

• int is no longer than long int

Example of size reporting program

Signed and Unsigned Characters and Integers

• C allows you to specify that the first bit, in an int, long, short, float, double or char is used to carry a sign indicator.

• By default all data types are unsigned

• But a signed data type means that instead of using 8 bits to hold a number, you will have 7 bits + 1 for the sign

• a char, by default allows values in the range 0 - 255

• A signed char allows values in the range of -128 - 127

• Usually, signed char is used to force a char to carry a sign - otherwise it is allowed but redundant

• Sometimes you want to use variables that cannot have there values changed

• We have used Symbolic Constants, but these have not been given a data type - they are just used at compile-time, not run-time

Integer Constants

• To declare a constant use the const qualifier
  const float pi = 3.1417;

• Symbolic constants are available anywhere in the program, and a Symbolic Constant always has the same value. But you can define local constants with the same name in different functions and these constants can have different values

• You can force C to reserve space for Symbolic Constants efficiently by using the following post-fixes

  #define PI 3.1417F /* float constant */

  #define BIG 12345678UL /* unsigned long int */

Character Constants

• An integer representation of a character

  'x', '\n', etc.

  '\677' Octal

  '\xFF' Hex

String Constants

• All variables must be declared before they can be used

• There are two new ways in which variables can be classified: Automatic and Not Automatic

• When we wrote our power() function, we declared a variable that was also declared in the calling function (main())

• C created space for the new variables and removed it when we exited the function

• C did not initialise the variable to some default values - C does not initialise the memory location assigned to the new variable - we have to explicitly initialise the variables we create

• Other variables are not automatic - these do not disappear when we exit function, and we can access the original value of the variable from any function

• These must be declared outside main()

  const float pi = 3.1417;

• If you want to refer to the variable inside a function, then supply a 'dummy' declaration

  const extern float pi;

• You cannot change the variable as part of the declaration

• C will initialise externs

extern.c

Arithmetic Operators

• 5 binary arithmetic operators: +, -, *, /, % (modulus)

• % cannot be used with float and double

• truncation of / and the sign of the result of % are machine-dependent

Relational Operators

• 6 relational operators: > >= <= < == !=

• Relational operations have a lower precedence than arithmetic operators

  i < lim - 1;

Logical Operators

• 3 logical operators: ||, &&, !

• ! flips the binary value

  if x = 1, !x = 0

• In conditionals, it can be used as follows

  int x = 0; /* binary x */

  if (!x) {...} /* equivalent to unless (x) */

  if (x == 0) {...}

  The conditionals are equivalent, but the former is more succinct.

• What is the data type of the result of the following expressions?

  2 + 5 = ?

  2.0 + 5 = ?

  2 + 5.0 = ?

  2.0 + 5.0 = ?

• C automatically converts ints to longs, ints to doubles, and longs to doubles, depending on the type of variables used in an expression program. Example of type conversions in printf statements

• Additionally, if functions in the <math.h> library are used, all variables are automatically converted to double

• When we kept a count of letters of the alphabet, we were converting characters to integers, e.g.

  ++nletters[c - 'a']

• The standard library <ctype.h> contains lots of functions for test whether input is within a particular range, e.g.

  c >= '0' && c <= '9'

  can be replaced by

  isdigit(c);

• Back to signed chars...

  On some machines, if a signed char is converted to an int it will be converted to a negative number (if the left most bit is a 1). On others, leading zeros are added to the char so that it can never be a negative int. ANSI C guarantees that printable characters will always be positive, but for other chars ....

• Because conditionals can be used in if statements, they have to return some value some that if can see if the conditional is true or false

• Now, if (while, for, etc.) expects a 0 if the conditional / expression is false, and a non-zero value if true

• Conditionals return 1 and 0

  a > b

• But expressions can return anything they like - but they will always return a 0 (false) if they can be used in a conditional

• So, in

  if ((c = getchar()) != EOF) {...}

  c = getchar() /* c ASCII value of char input */

  c != EOF /* 1 if true, 0 if false (if c==EOF)*/

• and in

  while (isdigit(c = getchar()) && c != EOF) {...}

  c = getchar() /* same as before */

  isdigit(...) /* 0 if false, else anything */

  c != EOF /* as before */

  ... && ... /* 1 if both 1, 0 otherwise */

Forcing Type Conversion

• So far C has been automatically converting types for us, but what if we want to force type conversion?

• C will always attempt to convert a data type into a larger data type. Sometimes, we may want to convert a data type into a smaller data type(!), or we may want to convert an integer into a char (which C will not, by default, do, although it will convert a char into an int)

  for (i = 0; i < 26; ++i) {
  	c = 'a' + i;
  	putchar(c);
  	printf(" = %d\n", nletters[i]);
  }
  
  

  a = 2
  b = 2
  c = 2...
  

• c had to be output using putchar()

• Alternatively, we could have used

  printf("%c = %d\n", c, nletters[i]);

• But say we wanted C to be forced to treat 'a' + i as though it was a char, so that we could do without c.

  printf("%c = %d\n",(char) 'a' + i,nletters[i]);

• (char) is known as a type cast. It tells C to convert the data type of the returned variable to the specified data type

• C manipulates the same data types that are directly supported by the hardware, as binary

• C can manipulate the binary versions of char, int, long, and short (signed and unsigned)

• The following operations can be applied

  & bitwise AND

  | bitwise inclusive OR

  ^ bitwise exclusive OR

  << left shift

  >> right shift

  ~ one's complement

  /* x = 01010101 (85, U) */

  /* y = 01101101 (109, m) */

  n = x & y /* = 11000111 (199, -71, <<, [[pi]]) */

  n = x | y /* = 01111101 (125, }) */

  n = x ^ y /* = 00111000 */

  n = x << 2 /* = 01010100 (84, overflow!

  340 otherwise (*4))*/

  n = x >> 2 /* = 00010101 (21, (/4) )*/

  n = ~x /* = 10101010 */

Next Lecture...