C Language Overview

Unit I, Chapter I: Overview of C

• C Language is a structured, high-level, machine-independent language.
• ALGOL is the root of modern programming languages. Introduced in the 1960s.
• ALGOL uses structured programming.
• Corrado Bohm, Guiseppe Jacopini, and Edsger Dijkstra popularized structured programming concepts.
• In 1967, Martin Richards created BCPL (Basic Combined Programming Language).
• BCPL was primarily developed for system software.
• In 1970, Ken Thompson created a new language called B.
• B was created for UNIX operating systems at Bell Laboratories.
• BCPL and B were typeless languages.
• C was developed by Dennis Ritchie in 1972 at Bell Laboratories.
• C was evolved from ALGOL, BCPL, and B, adding features like data types.
• C was developed alongside the UNIX operating system.
• ANSI (American National Standards Institute) appointed a technical committee to standardize C in 1983.
• In December 1989, the committee approved a version of C, now known as ANSI C.
• ISO (International Organization for Standardization) approved C in 1990, and this version is referred to as C89.
• C99 is another important version.

Unit I, Chapter 1.2: Importance of C

• C is a robust language with built-in functions and operators for complex programs.
• C combines the capabilities of assembly language with high-level language features.
• C is well-suited for writing system software and business packages.
• Programs written in C are efficient and fast.
• C is highly portable.
• C is well-suited for structured programming.
• C has the ability to extend itself.
• A C program is a collection of functions supported by the C library.

Unit I, Chapter 1.3: Sample Program 1

• Sample C code to print "Hello Program" to the console.
• Includes function main(), curly braces {}, and comments.
• Function main() is the entry point of a C program.

Unit I Chapter 1.4: Basic Structure of C Program

• Documentation Section: (Optional) Comments about the program, author, etc.
• Link Section: (Optional) Instructions for the compiler to link external functions.
• Definition Section: (Optional) Symbolic constants are defined here.
• Global Declaration Section: (Optional) Global variables and user-defined functions are declared here.
• **main() Function:**The main function section starts with main() followed by {} brackets.
• Declaration Part: Declares variables (data types).
• Executable Part: Contains statements that execute the program logic.
• Subprogram Section: (Optional) User-defined functions are placed here after the main function.

Unit I Chapter 1.5: Process of Compiling and Running a C Program

• Creating the program.
• Compiling the program.
• Linking the program with functions from the C library.
• Executing the program.

Unit I Chapter 1.6: Writing and Executing a C Program in UNIX

• Writing the C program using text editors (e.g., vi, ed).
• Entering the program into a file with a .c extension (e.g., firstcpgm.c).
• Compiling the program (using cc or gcc). Using command cc filename.
• Executing the compiled program (e.g., using a.out).

Unit I Chapter 1.7: Compiling and Linking

• Use gcc or cc compilers to create executables.
• Compile with command cc filename1, filename2, filename3...
• Common command-line options: -lm (math library), -c (compiles without linking), -o filename (specifies output file name).

Unit II, Chapter 2.1: Character Set

• Characters available for forming words, numbers, and expressions in C.
  • Uppercase letters (A-Z), Lowercase letters (a-z).
  • Digits (0-9).
  • Special characters (e.g., comma, semicolon, parentheses, operators).
  • White spaces (e.g., space, tab).

Unit II Chapter 2.2: C Tokens

• Individual words and punctuation marks.
• The smallest units in a C program are called tokens.
• Examples: keywords, identifiers, constants, strings, operators, special symbols.

Unit II Chapter 2.2.1: Keywords and Identifiers

• Keywords have fixed meanings that cannot be changed.
• Keywords are used as building blocks for program statements.
• Reserved words for specific tasks. Predefined and written in lowercase. Cannot be used as variable names.

Unit II Chapter 2.2.2: ANSI C Keywords

• A list of predefined keywords in ANSI C. e.g., auto, break, case, char, const, continue, default, do, else, enum, extern, float, for, goto, if, int, long, register, return, short, signed, sizeof, static, struct, switch, typedef, union, unsigned, void, volatile, while.

Unit II Chapter 2.2.3: Identifiers

• User-defined words that name entities (variables, arrays, functions, etc. ).
• Rules for forming identifiers:
  • Must start with a letter or underscore.
  • Can include letters, digits, and underscores.
  • First 31 characters are significant.
  • Cannot use keywords.
  • Case Sensitive.
  • Cannot contain spaces.

Unit II Chapter 2.2.4: Constants

• Fixed values that don't change during program execution.
• Types of constants:
  • Numeric (integer, real, etc.).
  • Character.
  • String.

Unit II Chapter 2.2.5: Integer Constant

• Sequence of digits.
• Types: decimal, octal, hexadecimal (e.g., 123, 017, 0xAF)

Unit II Chapter 2.2.6: Real Constants

• Decimal values with optional decimal points (e.g., 3.14, -2.7, 1E-3). Can also be exponential.

Unit II Chapter 2.2.7: Character Constants

• Single character enclosed in single quotes (e.g., 'A', '5', ' ').

Unit II Chapter 2.2.8: String Constants

• Sequence of characters enclosed in double quotes (e.g., "Hello", "123", " ").

Unit II Chapter 2.2.9: Backslash Character Constants

• For special characters in strings (e.g., '\n' for newline, '\t' for tab).

Unit II Chapter 2.2.10: Symbolic Constants

• Named constants defined using #define. - Naming rules similar to identifiers. - Use for substituting values for better code readability.
• Example: #define PI 3.14159.

Unit II Chapter 2.3: Variables

• Data names that store values that can change during program execution.
• Rules similar to identifiers.
• Variables must have a data type.
• Declaration: data_type variable_name;

Unit II Chapter 2.4: Declaration of Variables

• Tell the compiler variable name and type.
• Separate multiple variables with commas
• Statements end with semicolons. e.g., int count; float total;

Unit II Chapter 2.5: Declaration Of Storage Class

• Storage classes provide information about variables.
• Types: auto, register, static, extern.
  • Auto: Declared inside a block, Local (function), no default value
  • Register: Stored in register, speed up execution, Limited data size & type.
  • Static: Outside function scope. value persists.
  • Extern: Declared outside any function but in the source code

Unit II Chapter 2.6: Assigning Values to Variables

• Assigning values to variables with =. - Use = to give values to variables. - Example: x = 10;

Unit II Chapter 2.7: User defined types - typedef

• Allow you to create new names for existing types. - e.g typedef int units; means from now on units can be used in place of int - Using this typedef will improve the readability and maintainability of the code.

Unit II Chapter 2.9: Enumerated Types

• Allows you to create a named set of constant values.
  • Example: enum color {RED, GREEN, BLUE};

Unit III, Chapter 3.1: Introduction to Operators and Expressions

• Symbols performing operations on operands.
• There are various categories of operators. e.g Arithmetic, relational, logical, assignment, increment/decrement, conditional, bitwise, special.
• Expressions: Combinations of operators, operands, and constants combined according to language syntax

Unit III Chapter 3.1.1: Arithmetic Operators

• Operations for numerical calculations (e.g., +, -, *, /, %)

Unit III Chapter 3.1.2: Relational Operators

• Used to compare values (e.g., == for equal, != for not equal, < for less than).

Unit III Chapter 3.1.3: Logical Operators

• Operators for logical operations (e.g., && for AND, || for OR, ! for NOT).

Unit III Chapter 3.1.4: Assignment Operators

• Used to assign values to variables (e.g., =, +=, -=, *=, /=, %=).

Unit III Chapter 3.1.5: Increment and Decrement Operators

• Used to increment or decrement variables by one (e.g., ++, --).

Unit III Chapter 3.1.6: Conditional Operator

• Ternary operator for conditional expressions (e.g., exp1? exp2: exp3).

Unit III Chapter 3.1.7: Bitwise Operators

• Used to manipulate bits of data at a low level. (e.g., &, |, ^, <<, >>)

Unit III Chapter 3.1.8: Special Operators

• Operators that perform specific tasks (e.g., sizeof, comma operator).

Unit III Chapter 3.2: Arithmetic Expressions

• Combining constants, variables, and operators for numerical calculations.
• Evaluation in accordance with precedence and associativity rules.

Unit III Chapter 3.3: Operator Precedence and Associativity

• Rules determining the order of operations.
• Order of operation for operators.
• Parentheses have highest priority.

Unit III Chapter 3.4: Type Conversion

• Implicit (automatic) and explicit (static) type conversion.
• Conversion hierarchy.

This quiz covers the foundational concepts of the C programming language, including its history and evolution from earlier languages like ALGOL, BCPL, and B. It highlights key figures in structured programming and the significance of ANSI standardization. Test your understanding of how C was developed and its role alongside UNIX.