cpp
overloading
01_overloading.cpp⚙️cpp
/**
* ============================================================
* C++ FUNCTION OVERLOADING
* ============================================================
*
* This file covers:
* - Function overloading basics
* - Overloading rules
* - Ambiguity issues
* - Best practices
*
* Compile: g++ -std=c++17 -Wall 01_overloading.cpp -o overloading
* Run: ./overloading
*
* ============================================================
*/
#include <iostream>
#include <string>
#include <vector>
using namespace std;
// ============================================================
// FUNCTION OVERLOADING - SAME NAME, DIFFERENT PARAMETERS
// ============================================================
/*
* Function overloading allows multiple functions with the same name
* but different parameter lists. The compiler determines which
* function to call based on the arguments provided.
*
* What can differ:
* - Number of parameters
* - Types of parameters
* - Order of parameters (if types differ)
*
* What CANNOT differ (for overloading):
* - Return type alone
* - Parameter names
*/
// ============================================================
// OVERLOADED print() FUNCTIONS
// ============================================================
// Print integer
void print(int value) {
cout << "int: " << value << endl;
}
// Print double
void print(double value) {
cout << "double: " << value << endl;
}
// Print string
void print(const string& value) {
cout << "string: " << value << endl;
}
// Print character
void print(char value) {
cout << "char: " << value << endl;
}
// Print boolean
void print(bool value) {
cout << "bool: " << (value ? "true" : "false") << endl;
}
// Print with a label
void print(const string& label, int value) {
cout << label << ": " << value << endl;
}
// ============================================================
// OVERLOADED add() FUNCTIONS
// ============================================================
int add(int a, int b) {
return a + b;
}
double add(double a, double b) {
return a + b;
}
string add(const string& a, const string& b) {
return a + b;
}
// Three parameters
int add(int a, int b, int c) {
return a + b + c;
}
// ============================================================
// OVERLOADED max() FUNCTIONS
// ============================================================
int max(int a, int b) {
return (a > b) ? a : b;
}
double max(double a, double b) {
return (a > b) ? a : b;
}
int max(int a, int b, int c) {
return max(max(a, b), c); // Uses the two-parameter version
}
// ============================================================
// OVERLOADED area() FUNCTIONS
// ============================================================
// Area of square
double area(double side) {
cout << " (Square)" << endl;
return side * side;
}
// Area of rectangle
double area(double length, double width) {
cout << " (Rectangle)" << endl;
return length * width;
}
// Area of circle (using different parameter type)
double area(double radius, bool isCircle) {
if (isCircle) {
cout << " (Circle)" << endl;
return 3.14159 * radius * radius;
}
return area(radius); // Fall back to square
}
// ============================================================
// MAIN FUNCTION
// ============================================================
int main() {
cout << "============================================" << endl;
cout << " C++ FUNCTION OVERLOADING" << endl;
cout << "============================================" << endl << endl;
// ========================================================
// PART 1: BASIC OVERLOADING
// ========================================================
cout << "--- PART 1: BASIC OVERLOADING ---" << endl << endl;
// Compiler chooses the right function based on argument types
print(42); // Calls print(int)
print(3.14); // Calls print(double)
print("Hello"); // Calls print(const string&)
print('A'); // Calls print(char)
print(true); // Calls print(bool)
cout << endl;
// ========================================================
// PART 2: DIFFERENT NUMBER OF PARAMETERS
// ========================================================
cout << "--- PART 2: DIFFERENT PARAMETER COUNT ---" << endl << endl;
cout << "add(5, 3) = " << add(5, 3) << endl;
cout << "add(5, 3, 2) = " << add(5, 3, 2) << endl;
// With label
print("Age", 25); // Calls print(string, int)
print("Score", 100);
cout << endl;
// ========================================================
// PART 3: DIFFERENT PARAMETER TYPES
// ========================================================
cout << "--- PART 3: DIFFERENT PARAMETER TYPES ---" << endl << endl;
cout << "add(5, 3) = " << add(5, 3) << endl;
cout << "add(5.5, 3.3) = " << add(5.5, 3.3) << endl;
cout << "add(\"Hello\", \"World\") = " << add("Hello", " World") << endl;
cout << "\nmax(10, 20) = " << max(10, 20) << endl;
cout << "max(3.14, 2.71) = " << max(3.14, 2.71) << endl;
cout << "max(5, 10, 7) = " << max(5, 10, 7) << endl;
cout << endl;
// ========================================================
// PART 4: PRACTICAL EXAMPLE - AREA CALCULATION
// ========================================================
cout << "--- PART 4: AREA CALCULATIONS ---" << endl << endl;
cout << "Area of square (5): " << area(5.0) << endl;
cout << "Area of rectangle (4x6): " << area(4.0, 6.0) << endl;
cout << "Area of circle (r=3): " << area(3.0, true) << endl;
cout << endl;
// ========================================================
// PART 5: TYPE CONVERSION AND RESOLUTION
// ========================================================
cout << "--- PART 5: TYPE CONVERSION ---" << endl << endl;
// Implicit conversions can affect overload resolution
print(10); // Exact match: print(int)
print(10.5); // Exact match: print(double)
print(10.5f); // float → double conversion: print(double)
// Be careful with implicit conversions!
// print(10L); // long - might be ambiguous depending on overloads
// Character literals
print('X'); // Exact match: print(char)
print(65); // Exact match: print(int), not char!
cout << endl;
// ========================================================
// PART 6: RULES AND BEST PRACTICES
// ========================================================
cout << "--- PART 6: RULES AND BEST PRACTICES ---" << endl << endl;
cout << "OVERLOADING RULES:" << endl;
cout << "─────────────────────────────────────────" << endl;
cout << "✓ Can differ in number of parameters" << endl;
cout << "✓ Can differ in parameter types" << endl;
cout << "✓ Can differ in parameter order (if types differ)" << endl;
cout << "✗ Cannot differ ONLY in return type" << endl;
cout << "✗ Cannot differ ONLY in parameter names" << endl;
cout << "\nBEST PRACTICES:" << endl;
cout << "─────────────────────────────────────────" << endl;
cout << "• Keep overloaded functions semantically similar" << endl;
cout << "• Avoid too many overloads (confusing)" << endl;
cout << "• Be cautious with implicit conversions" << endl;
cout << "• Consider templates for type-generic functions" << endl;
cout << "• Document overloaded functions clearly" << endl;
cout << endl;
// ========================================================
// PART 7: WHAT DOESN'T WORK
// ========================================================
cout << "--- PART 7: COMMON MISTAKES ---" << endl << endl;
cout << "The following would NOT compile:" << endl;
cout << "─────────────────────────────────────────" << endl;
cout << "// Different return type only - ERROR!" << endl;
cout << "// int getValue() { return 1; }" << endl;
cout << "// double getValue() { return 1.0; }" << endl;
cout << endl;
cout << "// Different parameter names only - ERROR!" << endl;
cout << "// void func(int x) { }" << endl;
cout << "// void func(int y) { } // Same as above!" << endl;
cout << endl;
cout << "// Default arguments can cause ambiguity" << endl;
cout << "// void func(int x, int y = 0) { }" << endl;
cout << "// void func(int x) { } // Ambiguous call: func(5)" << endl;
cout << endl;
cout << "============================================" << endl;
cout << "FUNCTION OVERLOADING SUMMARY:" << endl;
cout << "============================================" << endl;
cout << "• Same name, different parameters" << endl;
cout << "• Compiler picks best match at compile time" << endl;
cout << "• Return type alone doesn't distinguish" << endl;
cout << "• Be careful with implicit type conversions" << endl;
cout << "• Use for related operations on different types" << endl;
cout << "============================================" << endl;
return 0;
}
// ============================================================
// EXERCISES:
// ============================================================
/*
* 1. Create overloaded functions to calculate the average of:
* - Two integers
* - Three integers
* - A vector of integers
*
* 2. Create overloaded functions to find minimum:
* - Of two values (int, double, string versions)
* - Of three values
* - Of an array
*
* 3. Create overloaded display() functions that:
* - Display an integer with optional label
* - Display a vector with optional separator
* - Display a 2D array with formatting
*
* 4. Create overloaded concatenate() functions for:
* - Two strings
* - String and integer
* - String and double (with precision parameter)
*/