Lesson 1: Introduction to Functions - Purna Tech LMS

C Programming – Complete Course Lesson 1: Introduction to Functions

C Programming – Complete Course

0% Completed

Module 0: Course Orientation and Learning Setup

Lesson 1: Welcome to the C Programming Master Course

Lesson 2: How to Use the Tutor LMS Platform

Lesson 3: Complete C Programming Learning Roadmap

Lesson 4: Course Resources and Practice Materials

Lesson 5: Assessment and Certification Process

Module 1: Introduction to C Programming

Lesson 1: Introduction to Computer Programming

Lesson 2: History and Evolution of C Language

Lesson 3: Features and Advantages of C

Lesson 4: Applications of C Programming

Lesson 5: Structure of a C Program

Lesson 6: Writing the First C Program

Lesson 7: Compilation and Execution Process

Module 2: C Development Environment

Lesson 1: Understanding Compilers and IDEs

Lesson 2: Installing Code::Blocks with GCC

Lesson 3: Setting Up C in Visual Studio Code

Lesson 4: Creating and Saving C Source Files

Lesson 5: Compiling and Running C Programs

Lesson 6: Understanding Compiler Errors and Warnings

Module 3: C Tokens, Keywords and Identifiers

Lesson 1: Character Set in C

Lesson 2: Introduction to C Tokens

Lesson 3: Keywords in C

Lesson 4: Identifiers and Naming Rules

Lesson 5: Constants and Literals

Lesson 6: Comments and Documentation

Lesson 7: Separators and Special Symbols

Module 4: Data Types, Variables and Constants

Lesson 1: Introduction to Data Types

Lesson 2: Integer Data Types

Lesson 3: Floating-Point Data Types

Lesson 4: Declaring Variables

Lesson 5: Initializing Variables

Lesson 6: Constants and the const Keyword

Lesson 7: Type Modifiers

Lesson 8: Size and Range of Data Types

Module 5: Input and Output Functions

Lesson 1: Introduction to Standard Input and Output

Lesson 2: Displaying Output with printf()

Lesson 3: Reading Input with scanf()

Lesson 4: Format Specifiers

Lesson 5: Escape Sequences

Lesson 6: Field Width and Precision

Lesson 7: Character Input and Output

Lesson 8: Common Input Problems

Module 6: Operators and Expressions

Lesson 1: Arithmetic Operators

Lesson 2: Relational Operators

Lesson 3: Logical Operators

Lesson 4: Assignment Operators

Lesson 6: Conditional Operator

Lesson 7: Bitwise Operators

Lesson 8: Special Operators

Lesson 9: Operator Precedence and Associativity

Module 7: Type Conversion and Type Casting

Lesson 1: Introduction to Type Conversion

Lesson 2: Implicit Type Conversion

Lesson 3: Explicit Type Casting

Lesson 4: Integer Promotion

Lesson 5: Mixed-Mode Expressions

Lesson 6: Data Loss and Precision Problems

Lesson 7: Overflow and Underflow

Module 8: Decision-Making Statements

Lesson 1: Introduction to Decision Making

Lesson 2: Simple if Statement

Lesson 3: if-else Statement

Lesson 4: Nested if Statements

Lesson 5: else-if Ladder

Lesson 6: Conditional Operator

Lesson 7: Common Conditional Errors

Lesson 8: Real-Time Conditional Programs

Module 9: Switch Statements

Lesson 1: Introduction to switch Statement

Lesson 2: case Labels

Lesson 3: break and default

Lesson 4: Multiple Cases with Common Statements

Lesson 5: Nested switch Statements

Lesson 6: switch versus else-if Ladder

Lesson 7: Menu-Driven Programming

Lesson 8: Limitations of switch

Module 10: Looping Statements

Lesson 1: Introduction to Loops

Lesson 2: while Loop

Lesson 3: do-while Loop

Lesson 4: for Loop

Lesson 5: Nested Loops

Lesson 6: Infinite Loops

Lesson 7: Choosing the Correct Loop

Lesson 8: Loop Tracing and Dry Runs

Module 11: Jump Statements

Lesson 1: break Statement

Lesson 2: continue Statement

Lesson 3: goto Statement

Lesson 4: return Statement

Lesson 5: Jump Statements in Nested Loops

Lesson 6: Structured Alternatives to goto

Module 12: Number-Based Programming

Lesson 1: Digit Extraction and Digit Counting

Lesson 2: Sum and Product of Digits

Lesson 3: Reversing a Number

Lesson 4: Palindrome Number .

Lesson 5: Armstrong Number

Lesson 6: Prime Number

Lesson 7: Factorial of a Number

Lesson 8: Fibonacci Series

Lesson 9: Perfect and Strong Numbers

Lesson 10: GCD and LCM

Lesson 11: Number-System Conversion.

Module 13: Pattern Programming

Lesson 1: Understanding Pattern Logic

Lesson 2: Basic Star Patterns

Lesson 3: Inverted Star Patterns

Lesson 4: Pyramid Patterns

Lesson 5: Diamond Patterns

Lesson 6: Number Patterns

Lesson 7: Alphabet Patterns

Lesson 8: Hollow Patterns

Lesson 9: Floyd’s Triangle

Lesson 10: Pascal’s Triangle

Module 14: Functions in C

Lesson 1: Introduction to Functions

Lesson 2: Function Declaration and Prototype

Lesson 3: Function Definition and Function Call.

Lesson 4: Functions without Arguments and Return Values

Lesson 5: Functions with Arguments and No Return Value

Lesson 6: Functions without Arguments and with Return Value.

Lesson 7: Functions with Arguments and Return Values.

Lesson 8: Passing Multiple Arguments

Lesson 9: Advantages of Modular Programming

Module 15: Advanced Functions, Scope and Recursion

Lesson 1: Local and Global Variables

Lesson 2: Storage Classes

Lesson 3: Static Variables in Functions.

Lesson 4: Call by Value

Lesson 5: Introduction to Recursion

Lesson 6: Recursive Factorial Program

Lesson 7: Recursive Fibonacci Program

Lesson 8: Recursion versus Iteration

Lesson 9: Command-Line Arguments

Module 16: One-Dimensional Arrays

Lesson 1: Introduction to Arrays

Lesson 2: Array Declaration and Initialization.

Lesson 3: Reading and Displaying Array Elements

Lesson 4: Array Calculations

Lesson 5: Reversing an Array

Lesson 6: Linear Search

Lesson 7: Binary Search

Lesson 8: Bubble Sort .

Lesson 9: Selection Sort

Lesson 10: Insertion Sort

Lesson 11: Frequency and Duplicate Elements

Lesson 12: Passing Arrays to Functions.

Module 17: Two-Dimensional Arrays and Matrices

Lesson 1: Introduction to Two-Dimensional Arrays

Lesson 2: Declaring and Initializing 2D Arrays .

Lesson 3: Reading and Displaying Matrices

Lesson 4: Matrix Addition

Lesson 5: Matrix Subtraction

Lesson 6: Matrix Multiplication

Lesson 7: Matrix Transpose

Lesson 8: Diagonal Matrix Operations

Lesson 9: Triangular Matrix Operations

Lesson 10: Passing 2D Arrays to Functions

Module 18: Strings and Character Handling

Lesson 1: Introduction to Strings.

Lesson 2: String Declaration and Initialization

Lesson 3: Reading and Displaying Strings

Lesson 4: String Length

Lesson 5: String Copy

Lesson 6: String Concatenation

Lesson 7: String Comparison

Lesson 8: String Reversal and Palindrome

Lesson 9: Character Classification Functions .

Lesson 10: Text Analysis Programs

Lesson 11: Array of Strings

Lesson 12: String Searching and Sorting

Module 19: Pointer Fundamentals

Lesson 1: Introduction to Memory Addresses

Lesson 2: Declaring and Initializing Pointers

Lesson 3: Address and Dereference Operators

Lesson 4: Pointer Data Types

Lesson 5: Null and Uninitialized Pointers

Lesson 6: Pointer Arithmetic .

Lesson 7: Pointers with Functions.

Lesson 8: Call by Reference

Lesson 9: Pointer Safety

Module 20: Advanced Pointers

Lesson 1: Pointers and One-Dimensional Arrays

Lesson 2: Pointers and Two-Dimensional Arrays

Lesson 3: Pointers and Strings

Lesson 4: Pointer to Pointer

Lesson 5: Array of Pointers

Lesson 6: Pointer to an Array

Lesson 7: Function Pointers

Lesson 8: Callback Functions

Lesson 9: Constant Pointers.

Module 21: Structures, Unions and Enumerations

Lesson 1: Introduction to Structures

Lesson 2: Declaring and Initializing Structures

Lesson 3: Accessing Structure Members

Lesson 4: Arrays of Structures

Lesson 5: Nested Structures

Lesson 6: Structures and Functions

Lesson 7: Pointers to Structures

Lesson 8: Self-Referential Structures

Lesson 9: Unions in C

Lesson 10: Enumerations

Lesson 11: typedef Keyword

Module 22: Dynamic Memory Management

Lesson 1: Static and Dynamic Memory Allocation

Lesson 2: Stack and Heap Memory

Lesson 3: Dynamic Allocation with malloc()

Lesson 4: Dynamic Allocation with calloc()

Lesson 5: Resizing Memory with realloc()

Lesson 6: Releasing Memory with free()

Lesson 7: Dynamic Arrays

Lesson 8: Memory Leaks

Lesson 9: Dangling and Wild Pointers

Lesson 10: Safe Memory-Management Practices

Module 23: File Handling

Lesson 1: Introduction to Files and Streams

Lesson 2: Opening and Closing Files

Lesson 3: File Opening Modes

Lesson 4: Character-Based File Operations

Lesson 5: String-Based File Operations

Lesson 6: Formatted File Input and Output

Lesson 7: Binary File Operations

Lesson 8: File Positioning Functions

Lesson 9: File Error Handling

Lesson 10: Files with Structures

Lesson 11: Searching File Records

Lesson 12: Updating and Deleting Records

Module 24: Preprocessor Directives and Header Files

Lesson 1: Introduction to the C Preprocessor

Lesson 2: Object-Like Macros

Lesson 3: Function-Like Macros

Lesson 4: File Inclusion

Lesson 5: Conditional Compilation

Lesson 6: Predefined Macros

Lesson 7: Creating User-Defined Header Files

Lesson 8: Multi-File C Programs

Lesson 9: Header Guards

Module 25: Data Structures Using C

Lesson 1: Introduction to Data Structures

Lesson 2: Singly Linked List

Lesson 3: Linked List Insertion

Lesson 4: Linked List Deletion

Lesson 5: Doubly Linked List

Lesson 6: Circular Linked List

Lesson 7: Stack Using Arrays

Lesson 8: Stack Using Linked Lists

Lesson 9: Queue Using Arrays

Lesson 10: Circular Queue

Lesson 11: Queue Using Linked Lists

Lesson 12: Introduction to Trees

Lesson 13: Binary Search Tree Basics

Module 26: Searching and Sorting Algorithms

Lesson 1: Introduction to Algorithms

Lesson 2: Linear Search

Lesson 3: Binary Search

Lesson 4: Bubble Sort

Lesson 5: Selection Sort

Lesson 6: Insertion Sort

Lesson 7: Merge Sort

Lesson 8: Quick Sort

Lesson 9: Comparing Search Algorithms

Lesson 10: Comparing Sorting Algorithms

Announcements Reviews Course Info

Explains function purpose, modularity and reusability.