History of C

• The C language was first proposed in 1972 by Dennis M. Ritchie at Bell Laboratories, USA.
• In 1983, the American National Standards Institute (ANSI) established a committee to standardize the definition of C, resulting in ANSI C.
• ANSI C is the recognized standard for the language, grammar, and core set of libraries.

Characteristics of C

• C is a robust language with a rich set of built-in functions, data types, and operators.
• Programs written in C are efficient due to the availability of several data types and operators.
• C is a highly portable language, allowing code written on one machine to be easily moved to another.
• C supports low-level features like bit-level programming and direct access to memory using pointers.

Basic Structure of a C Program

• A C program consists of several sections, including:
  • Documentation section (includes comments and program description)
  • Preprocessor section (includes header files and library links)
  • Definition section (includes constants and macros)
  • Global declaration section (includes global variables and functions)
  • Main function (the entry point of the program)
  • User-defined functions (custom functions written by the programmer)

Program Execution

• When a C program is compiled and executed, the compiler generates several files, including:
  • Source file (with a .c extension)
  • Object file (with a .obj extension)
  • Executable file (with a .exe extension)
• The program is executed in the following steps:
  1. The loader loads the executable file into RAM and informs the CPU of the starting point.
  2. The CPU executes the program, using the Instruction Register and Program Counter.

C Math Functions

• C provides several math functions, including:
  • ceil() (rounds up a number)
  • floor() (rounds down a number)
  • sqrt() (returns the square root of a number)
  • pow() (returns the power of a number)
  • abs() (returns the absolute value of a number)

C Tokens

• Tokens are the individual units of a C program, including:
  • Keywords (reserved words with specific meanings)
  • Identifiers (names of variables, functions, and arrays)
  • Constants (numeric, character, or string values)
  • Operators (symbols used for arithmetic, comparison, and logical operations)
  • Punctuators (symbols used for grouping and separating tokens)

Keywords

• Keywords are reserved words in C, including:
  • auto
  • double
  • int
  • struct
  • break
  • else
  • long
  • switch
  • ...

Identifiers

• Identifiers are names of variables, functions, and arrays, and must follow certain rules:
  • Can be named from a combination of A-Z, a-z, 0-9, and _
  • First character must be an alphabet or underscore
  • Must not be a keyword
  • Can be up to 31 characters long

Data Types

• C provides several data types, including:
  • int
  • float
  • char
  • double
  • long
  • short
  • unsigned
  • ...

Variables

• Variables are named storage locations that can hold different values, and can be:
  • Local (declared inside a function or block)
  • Global (declared outside a function or block)
  • Static (retains its value between multiple function calls)
  • Automatic (allocated memory automatically at runtime)
  • External (shared across multiple C source files)

Storage Classes

• Storage classes in C determine the lifetime, visibility, memory location, and initial value of a variable, including:
  • Automatic
  • External
  • Static
  • Register### C Data Types
• C supports four classes of data types: basic, derived, user-defined, and pointer data types.

Basic Data Types

• Basic data types support arithmetic operations such as addition and subtraction.
• Examples: int a, b;, char c;
• Storage size and range of basic data types:
  • Unsigned char: 8 bits, 0 to 255
  • Char: 8 bits, -128 to 127
  • Short int: 16 bits, -32768 to 32767
  • Unsigned int: 32 bits, 0 to 4294967295
  • Int: 32 bits, -2147483648 to 2147483648
  • Unsigned long: 32 bits, 0 to 4294967295
  • Enum: 16 bits, -2147483648 to 2147483648
  • Long: 32 bits, -2147483648 to 2147483648
  • Float: 32 bits, 3.4e-38 to 3.4e38
  • Double: 64 bits, 1.7e-308 to 1.7e308
  • Long double: 80 bits, 3.4e-4932 to 1.1e4932

Derived Data Types

• Derived data types store a set of data values.
• Examples: arrays and structures.

User-Defined Data Types

• C provides a facility called typedef for creating new data type names defined by the user.
• Example: typedef int Integer; makes Integer a synonym of int.

Pointer Data Types

• Pointer data types store the address of a variable.

Constants

• A constant is a quantity that does not vary during the execution of a program.
• Two types of constants: numeric and character constants.

Numeric Constants

• Examples: 786, -127, 1234567899L (long constant)
• Unsigned constants: 123456789u (unsigned constant), 1234567891ul (unsigned long constant)
• Advantage of declaring an unsigned constant: increases the range of storage.
• Floating-point constants: 123.4, 1e-2, 1.4E-4

Character Constants

• A character constant is written as one character within single quotes, e.g. 'a'.
• Escape sequences: \a (alert), \b (backspace), \f (form feed), \n (new line), \r (carriage return), \t (horizontal tab), \v (vertical tab)

String Constants

• A string constant is a sequence of zero or more characters surrounded by a double quote, e.g. " I am a little boy".
• Quotes are not part of the string.

Enumeration Constants

• An enumeration constant is a list of constant integer values, e.g. enum color { RED, Green, BLUE }.
• The first name in the enum has the value 0, and the next 1, and so on unless explicit values are specified.

Variables

• auto variables: default initial value is garbage.
• static variables:
  • Hold their value between multiple function calls.
  • Visible only to the function or block in which they are defined.
  • Can be declared many times but can be assigned at only one time.
  • Default initial value of static integral variables is 0 otherwise null.
• register variables:
  • Allocated memory into the CPU registers.
  • Can not be dereferenced (i.e., can not use & operator).
  • Access time is faster than automatic variables.
  • Initial default value of register local variables is 0.
  • Can store pointers into the register.
• extern variables:
  • Used to tell the compiler that the variable is declared with an external linkage elsewhere in the program.
  • Not allocated any memory.
  • Default initial value of external integral type is 0 otherwise null.
  • Can only initialize the extern variable globally.
  • Can be declared many times but can be initialized at only once.