C Programming Tutorial: Setup

• Introduction to a C tutorial aimed at beginners to advanced learners.
• The tutorial is designed to help with coding skills and college exams.
• The tutorial is divided into 11 chapters with timestamps for easy navigation.
• Includes 100 questions, with 70 solved and 30 for homework.
• Links to codes and notes are provided for revision.
• Viewers are encouraged to leave comments for important points or questions.

Setting up for C Coding

• Two main components needed: VS Code (code editor) and a C compiler (GCC).
• VS Code is used for its versatility across multiple programming languages.
• A compiler checks the code for correctness and runs it.

Installing VS Code

• Search "download VS Code for Windows" and download.
• Tick all checkboxes during installation, including creating a desktop icon.
• VS Code can then be found in the system search.
• Choose a theme (light or dark).
• VS Code is used as the code editor, but other editors can also be used.

Installing the C Compiler (GCC)

• Search for "MinGW GCC" and download from sourceforge.net.
• During installation, the directory is set.
• Select additional packages for different languages.
• Apply changes for all packages to download.
• Wait for all packages to download based on internet speed.

Setting Up Environment Variables

• Environment variables are required for running C code in the system.
• Go to File Explorer, find "This PC," and search for the MinGW folder.
• Open the "bin" folder inside MinGW.
• Copy the path displayed (e.g., C:\MinGW\bin).
• Search for "Control Panel" in the computer.
• Go to "Systems" > "Advanced System Settings."
• Open "Environment Variables."
• In "System Variables," find "Path" and edit it.
• Add the copied MinGW bin folder path as a new entry.
• Press "OK" on all windows to save, adding the MinGW to the PATH variable.

Testing the Setup

• Open VS Code and create a new file.
• Save the file as "hello_world.c" inside a new folder named "C Tutorials".
• Install the C/C++ extension pack in VS Code for additional functionalities.
• Open a new terminal in VS Code.
• Run the C code with the appropriate commands.
• The output "Hello, World!" should be displayed on the screen if the environment is set up correctly.
• Additional videos for troubleshooting installation issues are available.

Creating a C File

• In VS Code, create a new file within the created C tutorials folder.
• Name the file hello_world.c.
• The text provides a detailed explanation of fundamental programming concepts in C, formatted as a study guide.
• It covers variables, data types, constants, keywords, and program structure, then introduces input/output, operators, control flow, and finally functions, including recursion.
• The guide includes examples and step-by-step explanations tailored for students.

Variables

• Variables are names given to memory locations that store data.
• They hold data, which can then be recalled and used.
• Variables are analogous to labeled containers, such as spice containers in a kitchen.
• Declaring a variable reserves space in memory for a specific data type and associates a name with that location.
• Example: int number = 25; declares an integer variable named "number" and assigns it the value 25.
• Variables are case-sensitive: a and A are treated as distinct variables.
• Variable names must begin with an alphabet character or an underscore (_).
• Variable names cannot include commas or blank spaces.
• The value of a variable can be updated.
• Recommended: Variable names should be meaningful.

Data Types

• Data type defines the type of data a variable can hold (e.g., integer, character, decimal).
• Different data types occupy differing amounts of memory (e.g., character-1 byte, integer-2 bytes, float-4 bytes).
• Some core data types: integers (int), floating-point numbers (float), and Characters (char).
• Early languages don't include more recent data types like Booleans, or Strings.
• Integer (int) stores whole numbers, positive or negative (e.g., +1, -1, 0).
• Float stores decimal numbers (e.g., 3.14).
• Character (char) stores characters (e.g., #, *, @).

Constants

• Constants are values that cannot be changed during the execution of a program.
• Types of constants include:
  • Integer constants: whole numbers (e.g., 1, 2, 0, -1).
  • Real constants: real numbers, containing a decimal (e.g., 1.0, 2.0, 3.14).
  • Character constants: single characters enclosed in single quotes (e.g., 'A', '#', '*').
• A character constant's value remains fixed.

Keywords

• Keywords are reserved words with predefined meanings in the C language, that the compiler knows.
• They cannot be used as variable names or identifiers.
• C has 32 keywords.
• Examples: int, float, char, return.
• Not all languages include the same keywords.

C Program Structure

• A basic C program structure includes:
  • Preprocessor directive: #include <stdio.h> (includes standard input/output library).
  • int main() function: the entry point of the program.
  • Curly braces {} enclose the body of the main function.
  • Statements within main are executed sequentially.
  • Each line of code typically ends with a semicolon (;).
  • return 0; indicates successful program execution with zero errors.
  • The instructions are case-sensitive.

Comments

• Comments are explanatory notes in the code that are ignored by the compiler.
• Single-line comments start with //.
• Multi-line comments are enclosed between /* and */.
• Used to annotate code for easier understanding.

Output (printf)

• In C, the printf function is used for displaying output to the screen.
• Example: printf("Hello, world!"); will print the text "Hello, world!".
• Special formatting characters enable printing variables along with text strings.
  • %d is used as a placeholder for integer values.
  • %f is used for floating-point values (decimal numbers).
  • %c is used for characters.
• Use \n for adding a newline.

Input (scanf)

• The scanf function reads input from the user's keyboard.
• It requires format specifiers to match the data type being read.
• Example: scanf("%d", &age); reads an integer and stores it in the variable age, using its memory address.

Operators

• Plus sign (+) performs addition.
• Assignment operator (=) assigns a value to a variable.

Compilation

• Compilation is a process where the C code converts to machine code executable by a computer.
• The compiler checks the C code.
• The compiler generates executable files (.exe for Windows, .out for Linux).

Chapter Summary: Basic Concepts of C

• Variables, data types, constants, program structure, input/output, operators, and program compilation.

Instructions

• Instructions, also known as statements, are commands that the program performs step-by-step.
• Three types of instructions: declaration, arithmetic, and control.

Type Declaration Instruction

• Type declaration associates a variable with a specific data type, such as int a = 4;.
• It's important to declare a variable before using it in any operation.

Arithmetic Instruction

• Arithmetic instructions are for performing math operations such as addition, subtraction, multiplication, and division.
• Operands are the values involved in the operation, and operators define the type of operation.
• Only a single variable can be on the left-hand side of an assignment.
• Modular operator % returns the remainder of a division operation.

Key concepts of type conversion:

• If operands have the same type, the output has the same type.
• If operands have different types, the output type is promoted to the larger memory-occupying type.
• Implicit Conversions: The compiler automatically converts without explicit instruction (automatic type upgrades).
• Explicit Conversions: The programmer uses casting to force a type conversion.

Operator precedence:

• Parentheses () are evaluated first.
• Followed by multiplication *, division /, and modulus %.
• Then, followed by addition + and subtraction -.
• Finally, the assignment operator = is processed.

Associativity

• Associativity determines the order within the same precedence.
• Usually, calculations are performed from left to right.

Control Instructions

• Control instructions determine the sequence of operations in a program.
• Types include sequence, decision-making, loop, and case-based control.

Operators

• Relational operators compare values (e.g., ==, >, = 18) { printf("Adult"); } else { printf("Not adult"); }.
• Multiple conditions can be checked using else if statements.
• Multiple if statements are checked independently without relying on the other statements.

Ternary Operator

• A shorthand way to write simple if-else statements.
• Syntax: condition ? expression_if_true : expression_if_false.
• Example: age >= 18 ? printf("Adult") : printf("Not adult").

switch Statement

• Used for multi-way branching based on the value of an expression.
• Cases are checked until a match is found, and the corresponding code block is executed
• Include a break; statement at the end of each case to prevent fall-through to the next case.
• Include a default: case to handle any unmatched values (like an "else").

Nesting

• Multiple if blocks can be put inside a singular if statement.
• Cases can also be embedded.
• Has to be taken care to have right break instructions.

Loops

• Allows for repeatedly executing same block of code as long as condition is true.
• Can be either while, for, or do while.

for Loop

• Useful for initializing values.
• Useful for setting a condition or a step to make.
• For is just a standard, can be used, changed, removed.

while loop

• Loops until condition equals zero.
• Good for something like reading a file line by line.

do while Loop

• Runs at least once.

Other Loop Facts

• Loop Counter can be Floats, Char, or Integers.

• Assigning strings to structure members defined with array notation in C is not allowed using the direct assignment operator (=).

• Strings declared with array notation have fixed memory locations and cannot be changed directly.

• To assign a string value to a character array within a structure, the strcpy function must be used.

• strcpy copies the content of one string to another.

• The syntax for strcpy is strcpy(destination, source), where the contents of source are copied to destination.

• To use strcpy, include the string.h header file.

• If a character pointer is used instead of array notation, direct assignment would be possible.

• Printing structure members is achieved by using the dot operator . to access the member, which is a standard feature.

• The text describes how to work with structures in C, including declaration, initialization, memory allocation, and usage with functions and pointers.

Structure Declaration & Initialization

• Structures declared using the struct keyword, followed by the structure name.
• Members within a structure can be of different data types.
• To use a structure, a variable of that structure type has to be created.
• Structure members are accessed using the dot operator (.)
• Structure members are initialized upon declaration
• Memory allocation occurs contiguously for structure members, in the order they are defined.
• Can initialize all members to 0 using = {0}.

Memory Allocation

• Structures allocate memory in contiguous blocks, similar to arrays.
• Size of the memory block depends on the data types of the structure members.
• Memory is allocated sequentially, so after 100 characters of name, integer space is allocated (4 Bytes)
• Some compilers may have slight variations in memory allocation.

Working With Structures

• Structures can be used to store and manage data for multiple students.
• Copying structure initialization helps memorization.
• Provides good data management and organization due to structured format.

Arrays of Structures

• Arrays of structures can be created to store data for multiple entities.
• They are declared similarly to arrays of primitive data types.
• Individual structure members are accessed using array indexing and the dot operator (e.g., EC[0].rollNumber).
• Can be used for different departments, like electronics (EEC), computer science (COE), and IT, to store data

Initialization of Structures

• Structures can be initialized during declaration.
• All members can be initialized to zero implicitly.
• The direct initialization approach avoids repetitive assignments and . operator.

Pointers to Structures

• Pointers to structures can be declared using the * notation (e.g., struct student *ptr).
• Assign the address of a structure variable to a structure pointer using the & operator (e.g.,ptr = &s1).
• Structure members accessed from pointer using (*ptr).rollNumber.
• (*pointer).member retrieves the value of the member the pointer points to

Arrow Operator

• The arrow operator (->) simplifies accessing structure members through a pointer (e.g., ptr->rollNumber).
• The arrow operator avoids use of parentheses and is more readable,
• pointer -> member gets values, same as (*pointer).member

Passing Structures to Functions

• Structures can be passed as arguments to functions.
• Function declarations must include the structure definition before use.
• To pass them to functions specify struct <name> <variable>.
• Can retrieve the functions of passed structures with . operator.