SYSC 2006: Foundations of Imperative Programming - Lecture 2

SYSC 2006: Foundations of Imperative Programming - Lecture 2

• Previous Lecture Summary:

  • Defined programming and programs
  • Differentiated between programming paradigms and named languages in those paradigms
  • Understood fundamentals of imperative programming languages
  • Familiarized with basic C syntax and variables
  • Wrote basic programs in C

• Lecture 2 Objectives:

  • Become familiar with C syntax and variables
  • Understand and properly utilize basic C data types
  • Differentiate between static and dynamic typing in programming languages
  • Employ C operators to write expressions and programs
  • Grasp how operator precedence affects expression execution

• Types and Variables in C:

• Data Types:

  • Data types are particular data items defined by their values, the programming language used, and the operations performed.
  • Basic data types are fundamental building blocks provided by a programming language

• Basic Data Types in Python:

  • Numeric types:
    • int: unlimited precision signed integers
    • float: floating-point numbers
    • complex: real and imaginary parts are floating point numbers
  • bool: boolean, a subtype of integers
  • str: immutable character strings

• Basic Data Types in C:

  • char: character (typically an 8-bit byte)

  • int: signed integer

  • float: single-precision floating-point number

  • double: double-precision floating-point number

  • _Bool: Boolean (introduced in C99)

  • _Complex: complex number (introduced in C99)

  • Strings are implemented as arrays of characters

  • Data Type Qualifiers in C (signed):

    • int: signed integers with typical 32-bit size, ranging from -2³¹ to 2³¹ - 1

  • Data Type Qualifiers in C (unsigned):

    • unsigned int: positive or zero integers with typical 32-bit size, ranging from 0 to 2³² - 1

  • Data Type Qualifiers in C (short, long):

    • short int: at least 16 bits long
    • int: at least 16 bits long (although 32 bits is common)
    • long int: at least 32 bits long
    • long long int: at least 64 bits long
    • size short int <= size int <= size long int <= size long long int

  • C Data Type Qualifiers (Short, Long, Unsigned):

    • Combinations of short, long, long long with signed or unsigned are valid.

• Variable Overflow:

  • Entering a value outside the variable's range causes overflow.
  • This happens without an error message or warning.
  • Value wraps around rather than a failure occurring

• Data Type Qualifiers in C (float & double):

  • signed, unsigned, and short cannot used with float or double
  • long can also be used with double
  • long double is at least as precise as double.
  • Depending on the compiler long double can be an extended precision type
    • long cannot be used with float

• Literal Values (Constants):

  • int: 42, -1234

  • double: 1.2, -7.2, 2e-3, 5e+7, 7.3e+4

  • float: 1.2f, -7.2f

  • char: x, 1, $ (not a string, a single character)

  • string: "x", "hello"

• Python variables differ from C variables Python variables are reference based, while C variables directly store the value

• Remarks on C Variables:

  • Variables can be initialized at declaration. 
  • C variables are never empty.
  • Uninitialized variables hold unknown values.

• Static vs. Dynamic Typing:

  • Python:

    • Variables can change types during their lifetime.
    • Dynamic type checking occurs at runtime.
    • Example: Trying to add a string to a number. (TypeError)

  • C:

    • Variables have fixed types that remain constant throughout their lifetime.
    • Static type checking occurs during compilation.
      • Example of static type error; adding a string to a number will result in a compilation error

• Operators in C:

  • Arithmetic operators: +, -, *, /, %. / for integers yields an integer, but differs in Python3. % for floats not supported
  • Precedence: Operators have specific order when evaluated. Parentheses can be used to control precedence

• Assignment operators: op= where op is one of +, -, *, /, %, or bitwise operations. expr1 op= expr2 is shorthand for expr1 = expr1 op expr2

• Relational Operators:

  • ==, >=, <=, > < and != Comparisons, equality operators have precedence over relational operators

• Logical operators:

  • ! (not), && (and), || (or) have higher precedence over arithmetic operators
  • && has precedence over ||  

• Other Operators and C Elements:

  • Character escape sequences, enumeration constants, const qualifier, casts.

• Expressions:

  • Descriptions of computations that evaluate to values.
  • They consist of operands and operators.
  • Operands evaluate to values which are literal values, variables, function calls and expressions
  • Avoid unnecessary brackets for clarity in expressions

• Expressions and Type Conversion:

  • Operands with different types are converted to common type before evaluation.
  • Type conversion rules exist which include, but aren't limited to, converting char, short and possible long to an int

• Assignment and Type Conversions:

  • Conversion of values occurs when an expression assigned to a variable of a different type; expression evaluated and the obtained value is then assigned

• Functions and Type Conversions:

  • Functions (e.g., pow) perform type conversions on parameter values

• Recap of Learning Outcomes:

  • Understanding of C syntax and variables.
  • Use of basic C data types.
  • Static and dynamic typing differences.
  • Using C operators to write expressions.
  • Understanding of precedence in expressions

This quiz covers key concepts from Lecture 2 of SYSC 2006, focusing on C syntax, data types, and variable management. You will test your understanding of static versus dynamic typing and how operator precedence impacts programming expressions. Prepare to apply basic C operators in your programming tasks.