Introduction to C and C++

• C is a general-purpose, procedural programming language.
• It was developed in 1972 to develop the UNIX operating system.
• C doesn't support OOP, meaning no polymorphism, inheritance, or encapsulation.
• C programs are written in plain text files with the extension ".c".

C/C++ Compilers and IDEs

• Many C/C++ compilers and IDEs exist.
• IDEs include Code::blocks (Windows/Linux/MacOS), Visual Studio (Windows), and Dev-C++ (Windows).
• Compilers include GCC (Linux), MinGW (Minimalist GNU for Windows), and Clang (OS X).
• There have been four standard revisions: C++11, C++14, and C++17

C vs C++

• C uses procedural programming.
• C does not support polymorphism, encapsulation, and inheritance.
• C does not support function and operator overloading.
• C lacks namespace features
• C does not have virtual and friend functions
• C uses scanf for input and printf for output.
• C uses malloc() and free() for memory allocation/deallocation.
• C++ uses both procedural and OOP (Hybrid) programming.
• C++ supports polymorphism, encapsulation, and inheritance.
• C++ supports function and operator overloading.
• C++ uses the namespace feature.
• C++ supports virtual and friend functions.
• C++ uses cin for input and cout for output.
• C++ uses new and delete for memory allocation/deallocation.

C++ vs Java

• C++ compiles to machine code.
• C++ supports pointers and references.
• C++ utilizes manual garbage collection.
• C++ offers operator and method overloading.
• C++ supports multiple inheritance.
• C++ supports structures and unions.
• C++ provides access specifiers when inheriting from a class.
• Java compiles to byte code
• Java doesn't support pointers
• Java utilizes automatic garbage collection.
• Java does not have operator overloading.
• Java uses single inheritance.
• Java has no support for structures and unions.
• Java, access specifiers are not supported when inheriting.

First C Example

• The statement #include <stdio.h> is a directive to the C preprocessor.
• It tells the preprocessor to include the contents of the standard input/output header (<stdio.h>) in the program.
• #include is similar to import in Java but the code is copied and added to the current file, increasing its size.
• Every program in C contains one or more functions, one of them must be the main function.
• The program begins executing with the main() function.
• The returning value of the main function is an integer.
• The statement printf("Welcome to CMPS270! \n"); prints to the standard output.

Compiling Stages

• Compilation of C code involves four stages: preprocessing, compilation, assembly, and linking.
• Preprocessing is the first stage of compilation.
• Lines starting with a # are interpreted by the preprocessor as preprocessor commands.
• These commands form a simple macro language with its own syntax.
• It reduces repetition in source code
• Compilation translates the preprocessed code to assembly instructions specific to the target processor architecture.
• It forms intermediate, human-readable language.
• Some compilers support an integrated assembler that directly generates machine code.
• Assembly translates assembly instructions into machine code or object code using an assembler.
• The output is the actual instructions for the target processor.
• An object file with the extension .obj is created.
• Linking: The object code, generated in the previous stage, is raw machine instructions that the processor understands.
• The linker arranges pieces of object code and adds pieces for library functions used by the program.
• The result of this stage is the final executable program.

Input / Output

• scanf reads input data from the standard input stream (keyboard).
• printf outputs data to the standard output stream (screen).
• printf contains a format control string that describes the format of the output.

Printf Format Control String

• Possible format control string consists of conversion specifiers (like %d, %f, %c, %s), flags (like +, -, 0), field widths, precisions, and literal characters.
• Possible formats include rounding floating-point values to a specific number of decimal places, aligning numbers in a column, and output justification (right / left).

Integer Conversion Specifiers

• d: Display as a signed decimal integer.
• i: Display as a signed decimal integer. The i and d specifiers are different when used with scanf.
• o: Display as an unsigned octal integer.
• u: Display as an unsigned decimal integer.
• x or X: Display as an unsigned hexadecimal integer. X causes the digits 0-9 and the uppercase letters A-F to be used in the display and x causes the digits 0-9 and the lowercase letters a-f to be used in the display.
• h, l, or ll: Placed before any integer conversion specifier, these indicate that a short, long, or long long integer is displayed, respectively. They are called length modifiers.

Conversion Specifiers

• e or E: Display a floating-point value in exponential notation.
• f or F: Display floating-point values in fixed-point notation (F is supported in the Microsoft Visual C++ compiler in Visual Studio 2015 and higher).
• g or G: Display a floating-point value in either the floating-point form f or the exponential form e (or E), based on the magnitude of the value.
• L: Place before any floating-point conversion specifier to indicate that a long double floating-point value should be displayed.
• p: Display a pointer value in an implementation-defined manner.
• %: Display the percent character.
• c: Display a character argument.
• s: Displays a string (array of characters).

Format String Flags

• - (minus sign): Left justify the output within the specified field.
• • Display a plus sign preceding positive values and a minus sign preceding negative values.
• space Print a space before a positive value not printed with the + flag.
• #: Prefix 0 to the output value when used with the octal conversion specifier o.
• Prefix 0x or 0X to the output value when used with the hexadecimal conversion specifiers x or X.
• Force a decimal point for a floating-point number printed with e, E, f, g or G that doesn't contain a fractional part.
• (Normally the decimal point is printed only if a digit follows it.) For g and G specifiers, trailing zeros are not eliminated.
• 0 (zero) Pad a field with leading zeros.

Escape Sequences

• ': Output the single quote (') character.
• ": Output the double quote (") character.
• ?: Output the question mark (?) character.
• \: Output the backslash () character.
• \a: Cause an audible (bell) or visual alert (typically, flashing the window in which the program is running).
• \b: Move the cursor back one position on the current line.
• \f: Move the cursor to the start of the next logical page.
• \n: Move the cursor to the beginning of the next line.
• \r: Move the cursor to the beginning of the current line.
• \t: Move the cursor to the next horizontal tab position.
• \v: Move the cursor to the next vertical tab position.

Scanf_s

• scanf(): reads input from the standard input. If the input exceeds the variable's size, it overrides the adjacent memory.
• scanf_s(): a safer function takes width specification, memory address, buffer size, and terminating character.
• scanf_s() checks the size of the buffer and prevents writing to the buffer if the input is too large.

C Data Types

• char: 1 byte, range: -128 to 127 or 0 to 255.
• unsigned char: 1 byte, range: 0 to 255.
• signed char: 1 byte, range: -128 to 127.
• int: 2 or 4 bytes, range: -32,768 to 32,767 or -2,147,483,648 to 2,147,483,647.
• unsigned int: 2 or 4 bytes, range: 0 to 65,535 or 0 to 4,294,967,295.
• short: 2 bytes, range: -32,768 to 32,767.
• unsigned short: 2 bytes, range: 0 to 65,535.
• long: 4 bytes, range: -2,147,483,648 to 2,147,483,647.
• unsigned long: 4 bytes, range: 0 to 4,294,967,295.

C / C++ Operators

• Parentheses (): Evaluated first.
• Multiplication (*), Division (/), Remainder (%) Evaluated second from left to right.
• Addition (+), Subtraction (-) Evaluated third from left to right.
• Assignment (=) Evaluated last.

Relational Operators

• Relational operators compare two values and return a Boolean result.
• Equality operators check for equality or inequality.
• Logical operators (&&, ||, !) perform logical AND, OR, and NOT operations.

Bitwise Operators

• Bitwise operators:
  • AND (&): Sets each bit in the result to 1 if both operands are 1, otherwise 0.
  • inclusive OR (|): Sets each bit to 1 if either (or both) operand(s) is 1.
  • exclusive OR (^): Sets each bit to 1 if exactly one operand is 1; otherwise, it sets the bit to 0.
  • Left shift (<<): Shifts bits to the left by the number specified.
  • Right shift (>>): Shifts bits to the right by the number specified.
  • Complement (~): Sets all 0 bits to 1 and all 1 bits to 0.
• Bitwise AND, OR, and XOR compare their operands bit by bit.