DEV Community: Moksh Upadhyay

printf() and scanf() in C: Understanding Input and Output

Moksh Upadhyay — Mon, 22 Jun 2026 18:07:53 +0000

One of the first things every C programmer learns is how to interact with users. A program that cannot receive input or display output is not very useful.

In C, this interaction is handled primarily by two standard library functions:

printf() for output
scanf() for input

Let's see how they work and why they are so important.

What is printf()?

printf() stands for Print Formatted.

It is used to display output on the screen.

#include <stdio.h>

int main()
{
    printf("Hello, World!");
    return 0;
}

Output:

Hello, World!

The function can also display variable values using format specifiers.

int age = 23;

printf("Age = %d", age);

Output:

Age = 23

Here, %d tells printf() to display an integer.

What is scanf()?

scanf() stands for Scan Formatted.

It reads input from the keyboard and stores it in variables.

int age;

scanf("%d", &age);

The & operator is important because scanf() needs the memory address where the value should be stored.

Complete example:

#include <stdio.h>

int main()
{
    int age;

    printf("Enter your age: ");
    scanf("%d", &age);

    printf("You entered: %d", age);

    return 0;
}

Common Format Specifiers

Specifier	Type
`%d`	int
`%f`	float
`%lf`	double
`%c`	char
`%s`	string

Example:

float salary = 45000.50;
char grade = 'A';

printf("%f\n", salary);
printf("%c\n", grade);

A Common Beginner Mistake

Many beginners forget the & operator.

Incorrect:

scanf("%d", age);

Typical compiler warning:

warning: format '%d' expects argument of type 'int *'

Correct:

scanf("%d", &age);

How scanf() and printf() Work Internally

A useful mental model is:

Keyboard
   ↓
scanf()
   ↓
Memory
   ↓
printf()
   ↓
Monitor

When a user enters a value:

scanf() reads the input.
The value is stored in memory.
printf() reads the value from memory.
The result is displayed on the screen.

Understanding this flow makes later topics such as pointers and memory management much easier.

Key Takeaways

printf() displays output.
scanf() accepts input.
Format specifiers determine how data is interpreted.
The & operator provides a memory address.
These functions are fundamental to almost every beginner C program.

What are you learning? Drop your Comments

Moksh Upadhyay — Tue, 09 Jun 2026 19:09:37 +0000

Most Beginners Learn C Program Structure Wrong — Here's the Correct Layout

Moksh Upadhyay — Tue, 09 Jun 2026 19:08:20 +0000

Most beginners think a C program is just a collection of statements written from top to bottom.

In reality, every C program follows a structure. Understanding this structure makes your code easier to read, easier to debug, and easier to scale as programs become larger.

In this article, we'll break down the different sections of a C program, understand why they are arranged in a specific order, and build a complete example.

Why Does Program Structure Matter?

Imagine building a house without a blueprint.

You might eventually get walls, doors, and windows in place, but the process would be confusing and error-prone.

A C program works the same way.

Each section has a specific purpose, and organizing them properly helps both the programmer and the compiler understand the code.

A well-structured C program is easier to maintain, debug, and expand.

Components of a C Program

A typical C program is organized into the following sections:

Let's understand each part.

Documentation Section

The documentation section contains comments that describe the purpose of the program.

Example

/* Program: Student Management System
   Author: Moksh Upadhyay
*/

Comments are ignored by the compiler but help developers understand the code.

Header Files

Header files are included using the #include directive.

Example

#include <stdio.h>

Header files provide declarations for library functions.

Without stdio.h, functions such as printf() and scanf() would not be available.

Constants and Macros

Constants are values that do not change during program execution.

Example

#define PI 3.14159

Using constants improves readability and makes code easier to maintain.

Global Variables

Global variables are declared outside all functions.

Example

int totalStudents = 100;

They can be accessed from multiple functions throughout the program.

Use global variables carefully to avoid unnecessary dependencies between functions.

The main() Function

The main() function is the entry point of every C program.

Execution always starts here.

Example

int main()
{
    printf("Hello, World!");
    return 0;
}

The operating system calls main() when the program starts.

User-Defined Functions

User-defined functions help break large programs into smaller, reusable pieces.

Example

void greet()
{
    printf("Welcome to C Programming\n");
}

Instead of writing the same code repeatedly, you can place it inside a function and call it whenever needed.

Complete Example

/* Documentation */
#include <stdio.h>

/* Constants */
#define PI 3.14159

/* Global Variable */
int totalStudents = 100;

/* Function Prototype */
void greet(void);

/* Main Function */
int main()
{
    printf("Students = %d\n", totalStudents);

    greet();

    return 0;
}

/* User Function */
void greet(void)
{
    printf("Welcome to C Programming\n");
}

Common Beginner Mistakes

Forgetting Header Files

printf("Hello");

Without:

#include <stdio.h>

the compiler may generate warnings or errors.

Writing Everything Inside main()

Many beginners place all logic inside one function.

int main()
{
    // Hundreds of lines of code
}

A better approach is to separate logic into smaller functions.

Using void main()

Prefer:

int main()
{
    return 0;
}

over:

void main()
{
}

int main() follows the C standard and allows the program to return a status code to the operating system.

Frequently Asked Questions

Is Every Section Mandatory?

No.

A small program may only contain:

#include <stdio.h>

int main()
{
    return 0;
}

However, larger programs often use all sections.

Why Are Functions Placed After main()?

This is a common style.

The compiler simply needs to know about the function before it is used, often through a function prototype.

Can a Program Work Without Global Variables?

Yes.

Many professional applications minimize the use of global variables to improve maintainability.

Final Thoughts

The structure of a C program is more than a formatting convention.

It provides a logical organization that helps programmers write cleaner code and helps the compiler understand the program correctly.

Once you understand:

Documentation
Header Files
Constants & Macros
Global Variables
main()
User-Defined Functions

you've built a strong foundation for learning the rest of C programming.

What's Next?

If you're learning C, continue with:

printf() and scanf()
Variables in C
Data Types in C
Operators in C
Functions in C

These topics build directly on the structure you've learned today.

Which section of a C program was hardest for you to understand when you started?

Let me know in the comments.

What Happens Before Your C Program Reaches the CPU?

Moksh Upadhyay — Sat, 30 May 2026 19:14:05 +0000

Most developers know how to write C code.

Far fewer know what actually happens after they press Run.

A common mental model looks like this:

Write Code
    ↓
Click Run
    ↓
Get Output

Simple. Intuitive. Completely wrong.

Between your source code and the CPU sits an entire toolchain. Before a processor executes a single instruction, your code passes through preprocessing, compilation, assembly, linking, and loading.

Understanding this pipeline explains:

Why compiler errors happen
Why linker errors happen
What object files are
How libraries work
What GCC is actually doing

Let's walk through the complete journey.

The Complete Pipeline

A C program typically moves through the following stages:

main.c
   ↓
Preprocessor ───► main.i
   ↓
Compiler ───────► main.s
   ↓
Assembler ──────► main.o
   ↓
Linker ─────────► app
   ↓
Loader ─────────► Memory
   ↓
CPU ────────────► Execution

Each stage has one job.

Each stage produces output consumed by the next.

Stage 1: The Preprocessor

The compiler is not the first tool that touches your code.

The preprocessor runs before compilation begins.

Consider:

#include <stdio.h>
#define PI 3.14

int main() {
    printf("Hello World");
    return 0;
}

The preprocessor handles:

Header inclusion (#include)
Macro expansion (#define)
Comment removal
Conditional compilation (#ifdef)

For example:

#define PI 3.14

float radius = PI;

becomes:

float radius = 3.14;

before compilation even starts.

Output:

main.i

View it yourself:

gcc -E main.c -o main.i

Stage 2: The Compiler

The compiler's job is much more than translation.

It performs:

Lexical analysis
Syntax analysis
Semantic analysis
Optimization
Code generation

Example:

x = y + z;

might become:

MOV AX, y
ADD AX, z
MOV x, AX

The compiler also catches errors such as:

printf("Hello"

Missing parentheses.

Type mismatches.

Undeclared variables.

Output:

main.s

Generate it:

gcc -S main.c -o main.s

Stage 3: The Assembler

Assembly language is readable by humans.

CPUs cannot execute it directly.

The assembler converts assembly instructions into machine code.

Example:

ADD AX, BX

becomes something closer to:

00000011 11000011

Output:

main.o

Generate it:

gcc -c main.s -o main.o

At this point you have machine code, but not a complete executable.

Stage 4: The Linker

This is where many developers get confused.

Suppose your code contains:

printf("Hello");

The compiler verifies that printf() exists.

The assembler creates machine code referencing it.

But where is the actual implementation?

The linker finds it.

It combines:

Your object files
Standard libraries
Third-party libraries

and produces a complete executable.

Output:

app

Why "Undefined Reference" Happens

One of the most common C errors:

undefined reference to 'myFunction'

This is not a compiler error.

It is a linker error.

Typical causes:

Function declared but not defined
Source file not compiled
Library not linked
Incorrect linker flags

A useful rule:

The compiler checks correctness. The linker checks completeness.

Stage 5: The Loader

After linking, you finally have an executable.

But the CPU still cannot execute a file sitting on disk.

The operating system loader:

Allocates memory
Loads instructions into RAM
Maps shared libraries
Initializes the process

Only then does execution begin.

What GCC Actually Does

Most developers use:

gcc main.c -o app

Behind that single command, GCC runs multiple stages.

You can execute them manually:

[Preprocessor]
gcc -E main.c -o main.i

[Compiler]
gcc -S main.i -o main.s

[Assembler]
gcc -c main.s -o main.o

[Linker]
gcc main.o -o app

Understanding these commands makes debugging much easier.

Compiler Error vs Linker Error

Type	Stage	Meaning
Compiler Error	Compilation	Invalid code
Linker Error	Linking	Missing implementation

Examples:

Compiler Error:

printf("Hello"

Linker Error:

undefined reference to 'test'

Remember:

Compiler = correctness
Linker = completeness

Key Takeaways

The CPU cannot understand C directly.
The preprocessor handles directives.
The compiler analyzes and transforms code.
The assembler generates machine code.
The linker builds a complete executable.
The loader places the program into memory.
undefined reference is a linker error.
GCC automates the entire pipeline.

The next time you press Run, you'll know exactly what happens before your program reaches the CPU.

What part of the compilation pipeline confused you the most when you started learning C?

If you found this useful, you can read more articles on C Programming, Java, and Software Engineering at:
Originally published on Moksh eLearning Blog.

Full article: C Compliation Process

Additional content on C Programming, Java, Spring Boot, and Software Engineering:
https://mokshelearning.blogspot.com

How I Built My Developer Portfolio (React + Netlify) and What I Improved

Moksh Upadhyay — Tue, 10 Mar 2026 18:00:05 +0000

Recently I spent some time refining my developer portfolio.

Instead of treating it like just another “portfolio page”, I tried to approach it the same way I would approach a real product — thinking about performance, structure, and maintainability.

The result was a series of small improvements that made the site much cleaner and more production-ready.

The Stack I Used
The portfolio itself is built using a pretty simple stack:

React for the UI
Netlify for deployment
Vanilla CSS for styling
JavaScript for interactions

I intentionally kept the stack lightweight so the site remains fast and easy to maintain.

Performance Improvements

One of the first things I noticed was the size of some assets.

For example, my profile image was originally 4.7MB, which is way too heavy for a simple landing page.

After optimizing it, I reduced it to 95KB without noticeable quality loss.
That alone improved the loading experience quite a bit.

I also cleaned up unused assets and simplified the HTML structure to reduce the final bundle size.

Small changes like this make a big difference.

Handling SPA Routing on Netlify

React applications commonly use client-side routing. When deployed on static hosting platforms, refreshing a routed page may result in a 404 error.

Example route:

/project/1

To address this, Netlify redirect rules can be configured so all routes fallback to the main application entry point.

Example configuration:

/* /index.html 200

This allows the React router to manage navigation correctly.

Small UI Improvements

I also added a couple of small UI touches.

The scrollbar changes color based on the theme (light or dark mode), which keeps the interface consistent.

I also made the favicon theme-aware, so it stays visible whether the browser is in light or dark mode.

They’re small details, but they help the site feel more polished.

Spam Protection for the Contact Form
Instead of adding CAPTCHA, I implemented a honeypot field in the contact form.

Basically:
A hidden field is added to the form, Bots usually fill it automatically. If that field has data, the submission gets rejected
It helps filter spam without affecting real users.

Adding Dedicated Project Pages
Originally my portfolio just showed project cards. Now when you click a project, it opens a detailed page explaining the project — including:

why it was built
what technologies were used
what problems came up during development
how those problems were solved

I think projects become much more meaningful when you can see the thinking behind them, not just screenshots.

Why I Treated It Like a Real Project

Even though it’s “just a portfolio”, it’s still a reflection of how you build things.

Things like:

structure
performance
deployment
UX details

These are the same things that matter in real products.
You Can Check It Out Here
If you’re curious, you can see the portfolio here:
👉 https://mokshcodes.netlify.app

🚀 Understanding Strings and Characters in C

Moksh Upadhyay — Sun, 09 Mar 2025 16:34:46 +0000

In C programming, Strings and Characters are fundamental for handling text-based data. But did you know there’s a major difference between 'A' and "A" in C?

✅ 'A' is a Character → Stored as a single byte in memory.
✅ "A" is a String → Stored as two bytes (A + \0).

💡 Memory Representation:

'A' → Stored as ASCII value 65
"A" → Stored as 65 + 0 (null character)
Quick Tip 💡
👉 Always use single quotes for characters ('A').
👉 Use double quotes for strings ("Hello").
👉 C strings always end with a null character (\0).

🔥 Bonus: Want to master Strings in C? Check out my detailed blog where I covered:

✅ String functions like strlen(), strcpy().
✅ Pointer to String (the most powerful technique).
✅ Detailed memory representation for both.
👉 Read my full blog here: Strings and Character in C

How to Swap Variables in C: A Simple Guide

Moksh Upadhyay — Sun, 24 Nov 2024 09:33:47 +0000

Swapping variables is a core concept in programming that comes in handy in many scenarios, such as sorting algorithms, data manipulation, or simply reversing values. If you're a beginner learning C programming, understanding how to swap two variables is essential to building your coding foundation.

In C, swapping two variables can be done in a variety of ways. The most common and straightforward method involves using a temporary variable. This temporary variable holds the value of one of the variables while the other variable's value is assigned to the first. While this approach works well in many cases, it's important to note that C uses a call-by-value mechanism when passing variables to functions. This means changes made inside a function don’t reflect outside of it, which can sometimes confuse beginners.

But fear not! If you want to ensure that the original values are modified, you can use pointers. Pointers allow you to directly access and modify the variables' memory locations, ensuring that the swap is reflected outside the function as well.

There are other advanced techniques, such as swapping using arithmetic or XOR bitwise operations, which eliminate the need for a temporary variable. Each method has pros and cons, depending on the specific use case.

If you want to learn how to implement swapping in C with detailed explanations, code examples, and the pros and cons of each method, be sure to head over to my blog. I walk you through all the different ways to swap variables, ensuring you understand how each approach works and when to use it.

Happy coding, and don’t forget to check out the full tutorial! 🚀

Understanding Electricity Billing: A Comprehensive Guide

Moksh Upadhyay — Fri, 12 Jul 2024 08:09:44 +0000

Electricity billing is a crucial aspect of utility management, involving the calculation of costs based on the amount of electricity consumed by users. This process is essential for both residential consumers and businesses, ensuring accurate invoicing and financial management. In this guide, we'll explore the fundamental principles behind electricity billing systems.

How Electricity Billing Works
Electricity billing typically involves several key components:

Measurement of Electricity Consumption:

Electricity usage is measured in units of kilowatt-hours (kWh). The more electricity consumed, the higher the bill.

Tariffs and Pricing Structures:

Tariffs determine the cost per unit of electricity consumed. These tariffs may vary based on factors such as time of day (e.g., peak vs. off-peak hours) and total consumption levels.

Calculation of Charges:

Once the consumption in kWh is recorded, charges are calculated based on the applicable tariff rates. Additional charges, such as taxes or surcharges, may also apply.

Billing Cycles and Invoicing:

Utility companies typically issue bills periodically (e.g., monthly) to customers based on their consumption during a specific billing cycle. Bills detail the amount of electricity consumed, applicable charges, and payment due dates.

Factors Affecting Electricity Bills
Several factors can influence the amount of an electricity bill:

Consumption Levels: Higher electricity consumption results in higher bills.
Tariff Structures: Different tariffs can significantly impact the cost per unit of electricity consumed.
Seasonal Variations: Electricity usage may fluctuate based on seasonal factors such as heating or cooling needs.
Energy Efficiency: Adopting energy-efficient practices and technologies can help reduce overall consumption and lower bills.

Understanding Your Electricity Bill
To interpret your electricity bill accurately, it's essential to understand the breakdown of charges and the terms used:

Unit Price: The cost per kWh of electricity consumed.
Fixed Charges: Base fees or minimum charges applied regardless of consumption.
Taxes and Surcharges: Additional fees imposed by regulatory authorities or utility providers.

Conclusion
Understanding electricity billing is crucial for consumers and businesses to manage energy consumption effectively and budget accordingly. By grasping the principles of how electricity bills are calculated, you can make informed decisions to optimize energy usage and reduce costs.

For further insights into utility management and related topics, continue exploring resources that deepen your understanding of energy economics and sustainability.

Building a Sleek C++ Calculator: Harnessing the Power of Modular Functions

Moksh Upadhyay — Sat, 06 Jul 2024 12:30:51 +0000

In the world of programming, creating practical applications that demonstrate elegance and efficiency is a testament to skillful craftsmanship. One such project that exemplifies this is building a calculator using C++ and modular functions. In this blog post, we'll explore the journey of constructing a functional calculator from scratch, focusing on the principles of modular programming.

Why Build a Calculator?
While a calculator may seem like a simple tool, its construction offers valuable insights into fundamental programming concepts such as functions, control flow, and data handling. By building a calculator, we not only practice these concepts but also learn how to structure our code in a modular and reusable manner—a cornerstone of software engineering.

Getting Started: Preparation and Environment Setup
Before diving into the implementation, it's essential to set up your C++ development environment. Choose an IDE or text editor with a C++ compiler that suits your preferences. This ensures a smooth development process and efficient coding workflow.

Step-by-Step Guide to Building the Calculator
Designing the Functionality: Begin by outlining the basic functionalities your calculator will support. This typically includes arithmetic operations such as addition, subtraction, multiplication, and division. Plan how users will interact with the calculator through a simple user interface.

Implementing Modular Functions: Modular programming involves breaking down complex tasks into smaller, independent modules or functions. Create separate functions for each arithmetic operation to maintain clarity and reusability in your code.
Handling User Input and Output: Develop mechanisms to receive user input for numbers and operation selection. Use conditional statements (if-else or switch-case) to direct the program flow based on user choices. Ensure robust error handling to manage unexpected inputs effectively.
Testing and Validation: Once the core functionalities are implemented, rigorously test the calculator to ensure accuracy and reliability. Verify edge cases such as division by zero or non-numeric inputs. Debug any issues to achieve a stable and user-friendly application.

Conclusion
Building a C++ calculator using modular functions not only enhances your programming skills but also reinforces essential software development principles. By organizing code into reusable modules, you promote maintainable and scalable application development practices.

Ready to embark on this coding journey? Explore further by implementing additional features or refining the calculator's UI to expand its functionality and usability.

Finding Numbers Divisible by 3 and 5

Moksh Upadhyay — Wed, 03 Jul 2024 13:32:11 +0000

Hey Dev Community!

Are you diving into C programming and looking for a hands-on exercise to sharpen your skills? I've just published a new blog post where I walk you through writing a simple C program to find numbers between 1 and 50 that are divisible by both 3 and 5. This exercise is perfect for beginners aiming to understand loops and conditional statements in C.

In the blog, I cover:

Setting up a for loop to iterate through numbers
Using conditional statements to check for divisibility
Printing the results and counting the qualifying numbers

Check out the full blog here

I'd love to hear your feedback and any questions you may have. Let's learn and code together! 💻🎉

Unveiling the Fibonacci Sequence in C Programming

Moksh Upadhyay — Tue, 02 Jul 2024 17:05:29 +0000

𝐖𝐡𝐚𝐭 𝐢𝐬 𝐭𝐡𝐞 𝐅𝐢𝐛𝐨𝐧𝐚𝐜𝐜𝐢 𝐒𝐞𝐫𝐢𝐞𝐬?
The Fibonacci series is a sequence of numbers where each number is the sum of the two preceding ones. It starts from 0 and 1, and the series looks something like this:
0,1,1,2,3,5,8,13,21,34,…

𝐖𝐡𝐲 𝐢𝐬 𝐢𝐭 𝐈𝐦𝐩𝐨𝐫𝐭𝐚𝐧𝐭?
The Fibonacci series transcends its mathematical roots, manifesting in various natural phenomena and human creations. From the spiral patterns of galaxies to the arrangement of petals in flowers and the proportions of ancient architecture, the Fibonacci sequence embodies a universal pattern recognized across disciplines. In art, its rhythmic progression and harmonious proportions have inspired countless works. In computer science and algorithms, Fibonacci numbers serve as a foundation for efficient problem-solving techniques, from dynamic programming to optimizing recursive functions.

Understanding and generating the Fibonacci series not only deepen one's grasp of mathematical concepts but also nurtures an appreciation for the intricate patterns woven into our world. It encourages creativity in problem-solving and fosters a deeper connection between mathematics and its practical applications.

🚀 Mastering Loop Control in C Programming: Leveraging break and continue 🌟

Moksh Upadhyay — Tue, 02 Jul 2024 05:34:02 +0000

Hey Dev Community! Are you ready to enhance your C programming skills and optimize your code? Today, let's delve into the powerful world of loop control with break and continue statements.

Understanding break and continue
In C programming, break and continue are essential tools for managing loops effectively:

break: This statement allows you to exit a loop prematurely based on a specified condition. It's perfect for terminating loops early when certain criteria are met, ensuring efficient program execution.
continue: Unlike break, continue skips the current iteration of the loop and proceeds directly to the next iteration. This helps in bypassing specific iterations without exiting the loop entirely, enabling selective processing of loop iterations.

Practical Applications
Here’s how you can apply a break and continue in your code:

Input Validation: Use a break to stop processing input when an invalid value is encountered, preventing further unnecessary iterations.
Error Handling: Employ continue to skip over error-prone iterations while continuing to process valid data within the loop, enhancing program robustness and stability.

Benefits of Using Break and Continue
Mastering these loop control statements offers several advantages:

Enhanced Code Efficiency:
Exit loops early or skip unnecessary iterations to optimize program performance.
Improved Code Readability: Clearly define loop termination conditions and iteration skips, making code logic more transparent and maintainable.

Conclusion
Incorporating break and continue statements into your C programming toolkit empowers you to write cleaner, more efficient code. Whether you’re validating input, implementing search algorithms, or handling error conditions, these tools enhance your ability to control loop behavior effectively.

Ready to elevate your programming skills? Dive into my detailed blog post on mastering loop control with break and continue: https://mokshelearning.blogspot.com/2024/07/programn%20to%20show%20the%20usage%20of%20break%20and%20continue.html

Master these fundamental tools and unlock new levels of efficiency and precision in your coding journey!