Data

• char - usually single byte
• int - two or four byte integer
• float - single precision reals
• double - double precision reals

• int can be qualified by short, long, or long long, indicating smaller and bigger integers. The int can be omitted.
• char and any integer can be qualified by signed or unsigned, indicating an integer or natural value respectively. The default for integers is signed. unsigned char have values 0 - 255, signed from -128 to 128. Plain char may be either, and is machine dependant.
• long double specifies extended floating point.

• NumericLimits.c - Limits of various data types

• The sizeof function returns an integral value giving the number of bytes required to store an object.
• The result type is defined as size_t in <stddef.h>.
• SizeOf.c - Program that tells the size of various types

• \n = newline
• \t = tab
• \a = bell
• \b = backspace
• \r = carriage return
• \f = formfeed
• \v = vertical tab
• \\ = backslash
• \' = single quote
• \" = double quote
• \? = question mark.

• The compiler appends the \0 character to the end of all such strings (and ones input) so their end can be found.
• String constants that are only separated by white space are concatenated by the compiler.
• Strings may be prefixed with l or L to indicate that an extended character set should be used.

//----Returns the length of s1 (This is in a library)
int strlen(char TheString[]) {

    int Length;

    Length = 0;
    while (TheString[Length] != '\0') {
        ++Length;
    }
    return(Length);
} 

• Local variables and formal parameters have, by default, the storage class auto.
• Automatic variables come into existance on invocation and disappear when the function is exited.

• A variable declared to be register informs the compiler that it will be used heavily. Where possible such variables are maintained in machine registers. This is achieved by preceeding the declaration with the word register.
• Register can only be applied to automatic variables and function arguments (which are automatic).
• RegisterVar.c - Program with a register variable

• Objects may be declared static to make them permanent or private. This achieved by prefixing the definition with the word static.
• Internal static variables in functions remain in existance even after the function has exited. Very useful indeed.
• StaticCallCounter.c - Program with a static counter in a function.

• All objects defined at the outer level in a file, e.g. functions, are external objects.
• Externals are defined once only, but may be declared often.
• Each function that uses an external object must either declare it with an explicit extern declaration, or the object must be declared earlier in the same file to provide an implicit declaration.
• External (global) variables may be defined outside any function and then exist independently of the functions.
  • Externals.c - Program to find the longest line in the input.
  • External variables will give you warts, and may be used only when there's no alternative, e.g., interrupt handling.
  • If you have to use them, put them at the end of the file to force extern declarations.
• C programs can be kept in several source files and external objects are visible between files.
  • extern declarations may be at the external level, or within a function. In the latter case the object is only known locally.
  • ExternData.c - External data definition
    UseExternData.c - Use of external data definition
• Put externals at the end or in a separate file, and you'll force yourself to declare them
• External static objects cannot be accessed from any other file. This is useful for "local" routines in libraries.
  • ExternalStatic.c - Program to find the longest line in the input.
  • Good idea for encapsulation

• Mixed expressions. In mixed expressions the type conversions and result type are governed by promotion rules.
  • Firstly integral promotion takes place, converting char, short, bit fields, and enum constants to int (or unsigned int if too large).
  • Then if either operand is of higher type, the other is converted to that type. The order is long double > double > float > unsigned long int > long int (with an exception) > unsigned int > int.
• Assignment across types, the value on the RHS is converted to the type of the variable on the LHS.
• Actual argument values are converted to the formal argument type when a function is called.
• Casting. Type conversions can be forced by casting an expression into a type using the construct :

  (<type>) <expression> 

• char to int - chars and ints may be freely mixed in expressions as char are converted to int. As char are represented as byte it is possible for the msb to be interpreted as a sign bit. In the conversion to int some machines (including the PDP11) will do sign extension, so the conversion may produce a negative integer. Other machines will simply pad with zeros. C guarantees that characters in the machine's standard printing character set will never be negative (i.e., will have int values 0 to 127).

  A problem arises when chars are compared with ints on machines which do not provide sign extension. The char is converted to int for the comparison and will always be positive. Thus if the int is negative the two can never be equal. An important case of this is when EOF is -1. This is the reason for using an int to hold characters returned by getchar().

• Any int to any unsigned - in 2's complement arithmetic the bit pattern representing the integer is copied across. Extra bits are truncated if the unsigned is narrower, 0 fill and sign extend if the unsigned is wider.
• Any int to any signed type, the value is unchanged if it fits, undefined otherwise.
• Logical to int - logical expressions that are true are defined to have the value 1 and those that are false the value 0.
• Any integral to any floating type, directly copied if it fits, undefined otherwise.
• float to int - the fractional part is truncated, but the direction of truncation for -ve values and the method of dealing with overflow is undefined.
• Larger floating point to smaller floating point - done by rounding if its fits, undefined otherwise.
• Smaller floating point to larger floating point - straight assignment with zero padding.