12 Jun Write a C program To Add Two Integers

Posted at 12:13h in C by

In this comprehensive guide, we will explore multiple ways to write a C program to add two numbers. We will cover everything from hardcoded values to dynamic user inputs, examine different data types like integers and floating-point numbers, and break down every single line of code so you understand exactly what the computer is doing behind the scenes. Here are the examples to sum two numbers in C programming with exercises:

C Program to Add Two Numbers Using Hardcoded Values

This is the simplest version of the program. Here, we pre-define the numbers directly within the source code. This approach doesn’t require any interaction from the user, making it excellent for understanding basic syntax and arithmetic operations.

The Code

#include <stdio.h>

int main() {
    // Declaring variables to store the integers
    int firstNumber = 25;
    int secondNumber = 40;
    int sum;

    // Performing the arithmetic addition
    sum = firstNumber + secondNumber;

    // Displaying the result on the screen
    printf("The sum of %d and %d is: %d\n", firstNumber, secondNumber, sum);

    return 0;
}

Expected Output

The sum of 25 and 40 is: 65

Detailed Code Breakdown

Let’s dissect this program line by line to understand how the C compiler interprets it:

  • #include <stdio.h>: This line is a preprocessor directive. It tells the compiler to include the Standard Input Output library before compiling the code. This library contains built-in functions like printf(), which we need to display text on the screen.
  • int main() { ... }: Every C program must have a main() function. This is the absolute starting point of execution. The execution begins at the opening curly brace { and ends at the closing curly brace }. The int keyword means this function will return an integer value to the operating system upon completion.
  • int firstNumber = 25;: Here, we do two things at once: declaration and initialization. We tell the computer to reserve a space in memory for an integer (int), name that space firstNumber, and immediately store the value 25 inside it.
  • int sum;: This line simply declares a variable named sum without giving it a starting value. It is an empty container waiting for our calculation.
  • sum = firstNumber + secondNumber;: The computer evaluates the right side first. It fetches the value in firstNumber (25) and adds it to the value in secondNumber (40), resulting in 65. It then uses the assignment operator (=) to save that 65 into the sum variable.
  • printf("The sum of %d and %d is: %d\n", firstNumber, secondNumber, sum);: The printf function scans the text inside the quotation marks. Every time it hits a %d format specifier, it swaps it out for the actual value of the variables listed afterward, in strict chronological order. The \n sequence simply forces the console cursor to jump to a new line.
  • return 0;: This signals to the operating system that the program ran successfully without encountering any critical errors.

C Program to Add Two Numbers via User Input

Hardcoded values are rarely useful in real-world software. To make our program dynamic and interactive, we need to allow the user to type in whatever numbers they want while the program is running. We achieve this using the scanf() function.

The Code

#include <stdio.h>

int main() {
    int num1, num2, total;

    // Requesting input for the first integer
    printf("Enter the first integer: ");
    scanf("%d", &num1);

    // Requesting input for the second integer
    printf("Enter the second integer: ");
    scanf("%d", &num2);

    // Calculating the total
    total = num1 + num2;

    // Printing the final calculation
    printf("Result: %d + %d = %d\n", num1, num2, total);

    return 0;
}

Expected Output

Enter the first integer: 128
Enter the second integer: 72
Result: 128 + 72 = 200

Detailed Code Breakdown

This program introduces a crucial concept: interacting with user memory via pointers.

  • int num1, num2, total;: C allows us to declare multiple variables of the same data type on a single line, separated by commas. This keeps our code clean and concise.
  • scanf("%d", &num1);: The scanf() function pauses program execution and waits for the user to type a number and hit Enter.
    • The %d tells scanf to expect an integer format.
    • The ampersand (&) is the address-of operator. It acts like a GPS locator, telling scanf exactly where the variable num1 physically lives in the computer’s RAM. Without the &, the program would not know where to save the typed number, causing the application to crash.

C Program to Add Floating-Point (Decimal) Numbers

What happens if you want to add 10.5 and 4.2? If you try to pass these into an int variable, C will brutally chop off the decimal parts (a process called truncation), turning them into 10 and 4. To handle fractions and decimals accurately, we must use the float or double data types.

The Code

#include <stdio.h>

int main() {
    float dailyExpense, weeklyExpense, totalSpent;

    printf("Enter your daily coffee expense (e.g., 4.50): ");
    scanf("%f", &dailyExpense);

    printf("Enter your weekly grocery expense (e.g., 85.75): ");
    scanf("%f", &weeklyExpense);

    // Adding decimal numbers together
    totalSpent = dailyExpense + weeklyExpense;

    // Printing results limited to 2 decimal places
    printf("Your total expenses are: $%.2f\n", totalSpent);

    return 0;
}

Expected Output

Enter your daily coffee expense (e.g., 4.50): 5.25
Enter your weekly grocery expense (e.g., 85.75): 120.40
Your total expenses are: $125.65

Detailed Code Breakdown

Switching from whole numbers to fractions requires updating our data types and format specifiers:

  • float dailyExpense...: The float keyword allocates memory specifically structured to hold floating-point numbers containing fractional values.
  • %f Specifier: We swap out %d for %f in both scanf() and printf(). This tells the computer’s compiler to read and display data as floating-point decimals.
  • %.2f Custom Formatting: By default, C loves to print floats with six decimal digits (e.g., 125.650000). By placing %.2f inside the printf statement, we instruct the computer to round the output and display exactly two digits past the decimal point, which is ideal for working with currency or clean metrics.

Add Two Numbers by Creating a Reusable Addition Function

As programs scale, writing the same code repeatedly leads to bulky, disorganized projects. To adhere to clean coding practices, we can encapsulate our addition logic inside a separate, dedicated user-defined function. This makes our mathematical logic highly reusable throughout an entire application.

The Code

#include <stdio.h>

// Function declaration/prototype
int calculateSum(int a, int b);

int main() {
    int x, y, result;

    printf("Enter value for X: ");
    scanf("%d", &x);
    
    printf("Enter value for Y: ");
    scanf("%d", &y);

    // Invoking the custom function and passing variables as arguments
    result = calculateSum(x, y);

    printf("The functional output of X + Y is: %d\n", result);

    return 0;
}

// Function definition
int calculateSum(int a, int b) {
    int computationalResult;
    computationalResult = a + b;
    
    // Sending the calculated value back to the main function
    return computationalResult;
}

Expected Output

Enter value for X: 500
Enter value for Y: 350
The functional output of X + Y is: 850

Detailed Code Breakdown

Functions break our logic up into modular, structured blocks:

  1. Function Prototype (int calculateSum(int a, int b);): C reads code sequentially from top to bottom. This line serves as an advance notice to the compiler, telling it: “Hey, later down the line, there is a function called calculateSum that takes two integers and hands back an integer. Keep an eye out for it.”
  2. Function Invocation (result = calculateSum(x, y);): When execution hits this line, the program stops what it is doing in main(), duplicates the values stored in x and y, and jumps down to the calculateSum function block, passing those duplicates into variables a and b.
  3. The Return Mechanism (return computationalResult;): Once the sub-function adds a and b together, the return keyword acts like a messenger. It carries the resulting value back up to the exact spot where the function was called in main(), dropping that value cleanly into the waiting result variable.

Best Practices & Common Pitfalls

Even in a simple addition program, errors can creep in. Keep these essential principles in mind to write flawless C code:

1. Variable Initialization

If you declare an integer variable like int sum; and try to print it before adding numbers together, you will get an unpredictable, strange number (like -858993460). This is known as a garbage value. It happens because C doesn’t clear memory automatically when variables are declared; it simply hands you whatever leftover data was sitting in that RAM slot from previous computer tasks. Always ensure your variables are properly assigned or initialized before utilization.

2. Guarding Against Integer Overflow

An integer (int) in standard modern C systems usually takes up 4 bytes (32 bits) of memory space. This means it can safely hold values ranging from -2,147,483,648 to +2,147,483,647. If you attempt to add two incredibly massive numbers together that exceed this upper ceiling, the value will experience overflow, wrapping around into a bizarre negative number. If you intend to calculate exceptionally massive sums, use the long long int data type coupled with the %lld format specifier instead.

3. Case Sensitivity

C is strictly case-sensitive. The variable names sum, Sum, and SUM represent three entirely different, distinct blocks of memory. Keeping a consistent naming standard (like camelCase) will protect you from unexpected compilation errors.

Conclusion

Whether you are performing a quick hardcoded addition, building interactive data inputs for decimals, or writing highly organized custom functions, adding two numbers forms the ultimate gateway to mastering C syntax. By commanding control over variables, recognizing how memory locations interact through pointer references (&), and formatting text outputs dynamically, you establish the bedrock skills required to construct intricate software architectures. Take these patterns, modify the numbers, experiment with mixing data types, and use them as your stepping stone toward advanced computer programming mastery.

If you liked the tutorial, spread the word and share the link and our website, Studyopedia, with others:

For Videos, Join Our YouTube Channel: Join Now

Read More:

C Tutorial | Learn C Programming
Print page
0 Likes
Studyopedia Editorial Staff
contact@studyopedia.com

We work to create programming tutorials for all.

No Comments

Post A Comment