cpp
parameters
01_parameters.cpp⚙️cpp
/**
* ============================================================
* C++ FUNCTION PARAMETERS
* ============================================================
*
* This file covers:
* - Pass by value
* - Pass by reference
* - Pass by pointer
* - Const parameters
* - Array parameters
* - Default arguments
*
* Compile: g++ -std=c++17 -Wall 01_parameters.cpp -o parameters
* Run: ./parameters
*
* ============================================================
*/
#include <iostream>
#include <vector>
#include <string>
using namespace std;
// ============================================================
// FUNCTION DECLARATIONS
// ============================================================
// Pass by value
void incrementByValue(int x);
// Pass by reference
void incrementByReference(int& x);
void swap(int& a, int& b);
// Pass by pointer
void incrementByPointer(int* x);
void setToZero(int* ptr);
// Const parameters
void printValue(const int& x);
void printString(const string& str);
int sumArray(const int arr[], int size);
void displayVector(const vector<int>& vec);
// Array parameters
void fillArray(int arr[], int size, int value);
void printArray(int arr[], int size);
void modifyArray(int* arr, int size);
// Default arguments
void greet(string name = "Guest");
void printRectangle(int width, int height, char ch = '*');
int power(int base, int exp = 2);
// ============================================================
// MAIN FUNCTION
// ============================================================
int main() {
cout << "============================================" << endl;
cout << " C++ FUNCTION PARAMETERS" << endl;
cout << "============================================" << endl << endl;
// ========================================================
// PART 1: PASS BY VALUE
// ========================================================
cout << "--- PART 1: PASS BY VALUE ---" << endl << endl;
/*
* Pass by value: A COPY of the argument is passed
* - Original variable is NOT modified
* - Safe, but copies large objects
*/
int num = 10;
cout << "Before incrementByValue: num = " << num << endl;
incrementByValue(num);
cout << "After incrementByValue: num = " << num << " (unchanged!)" << endl;
// Pass by value creates a copy
// Good for: small types (int, char, etc.), when you don't want to modify original
cout << endl;
// ========================================================
// PART 2: PASS BY REFERENCE
// ========================================================
cout << "--- PART 2: PASS BY REFERENCE ---" << endl << endl;
/*
* Pass by reference: The actual variable is passed (via alias)
* - Original variable CAN be modified
* - No copying - efficient for large objects
* - Syntax: use & after the type
*/
int value = 10;
cout << "Before incrementByReference: value = " << value << endl;
incrementByReference(value);
cout << "After incrementByReference: value = " << value << " (modified!)" << endl;
// Swap example
int a = 5, b = 10;
cout << "\nBefore swap: a=" << a << ", b=" << b << endl;
swap(a, b);
cout << "After swap: a=" << a << ", b=" << b << endl;
cout << endl;
// ========================================================
// PART 3: PASS BY POINTER
// ========================================================
cout << "--- PART 3: PASS BY POINTER ---" << endl << endl;
/*
* Pass by pointer: Address of variable is passed
* - Original variable CAN be modified (via dereference)
* - Can be nullptr (handle null checks!)
* - Syntax: use * after the type, pass &variable
*/
int x = 10;
cout << "Before incrementByPointer: x = " << x << endl;
incrementByPointer(&x); // Pass address using &
cout << "After incrementByPointer: x = " << x << " (modified!)" << endl;
// Pointer can be null
int y = 100;
setToZero(&y);
cout << "After setToZero: y = " << y << endl;
setToZero(nullptr); // Safe - function checks for null
cout << endl;
// ========================================================
// PART 4: CONST PARAMETERS
// ========================================================
cout << "--- PART 4: CONST PARAMETERS ---" << endl << endl;
/*
* Const reference: Pass by reference but prevent modification
* - Efficient (no copy)
* - Safe (can't modify)
* - Best of both worlds!
*/
int number = 42;
printValue(number); // Can pass variable
printValue(100); // Can pass literal (const ref allows this!)
string longString = "This is a very long string that we don't want to copy";
printString(longString);
// Const with arrays
int arr[] = {1, 2, 3, 4, 5};
int sum = sumArray(arr, 5);
cout << "Sum of array: " << sum << endl;
// Const with vectors
vector<int> vec = {10, 20, 30, 40, 50};
displayVector(vec);
cout << endl;
// ========================================================
// PART 5: ARRAY PARAMETERS
// ========================================================
cout << "--- PART 5: ARRAY PARAMETERS ---" << endl << endl;
/*
* Arrays decay to pointers when passed to functions
* - int arr[] is same as int* arr
* - Size must be passed separately
* - Original array CAN be modified
*/
int myArray[5];
fillArray(myArray, 5, 42);
cout << "After fillArray: ";
printArray(myArray, 5);
modifyArray(myArray, 5);
cout << "After modifyArray: ";
printArray(myArray, 5);
cout << endl;
// ========================================================
// PART 6: DEFAULT ARGUMENTS
// ========================================================
cout << "--- PART 6: DEFAULT ARGUMENTS ---" << endl << endl;
/*
* Default arguments: Values used when argument is not provided
* - Declared in function declaration (not definition)
* - Must be at the END of parameter list
* - Once you have a default, all following must have defaults
*/
greet(); // Uses default "Guest"
greet("Alice"); // Uses provided argument
cout << endl;
printRectangle(5, 3); // Uses default '*'
cout << endl;
printRectangle(5, 3, '#'); // Uses provided '#'
cout << endl;
cout << "power(3): " << power(3) << " (uses default exp=2)" << endl;
cout << "power(2, 8): " << power(2, 8) << " (explicit exp=8)" << endl;
cout << endl;
// ========================================================
// PART 7: COMPARISON SUMMARY
// ========================================================
cout << "--- PART 7: COMPARISON ---" << endl << endl;
cout << "┌──────────────────┬─────────────┬─────────────┬─────────────┐" << endl;
cout << "│ Feature │ By Value │ By Reference│ By Pointer │" << endl;
cout << "├──────────────────┼─────────────┼─────────────┼─────────────┤" << endl;
cout << "│ Modifies orig │ No │ Yes │ Yes │" << endl;
cout << "│ Copies data │ Yes │ No │ No │" << endl;
cout << "│ Can be null │ N/A │ No │ Yes │" << endl;
cout << "│ Syntax (call) │ func(x) │ func(x) │ func(&x) │" << endl;
cout << "│ Syntax (param) │ int x │ int& x │ int* x │" << endl;
cout << "└──────────────────┴─────────────┴─────────────┴─────────────┘" << endl;
cout << "\n💡 Best Practices:" << endl;
cout << "• Small types (int, char): pass by value" << endl;
cout << "• Large objects (read-only): pass by const reference" << endl;
cout << "• Need to modify: pass by reference" << endl;
cout << "• Optional/nullable: pass by pointer" << endl;
cout << endl;
cout << "============================================" << endl;
cout << "PARAMETER PASSING SUMMARY:" << endl;
cout << "============================================" << endl;
cout << "• By value: copies, original unchanged" << endl;
cout << "• By reference: no copy, can modify" << endl;
cout << "• By pointer: uses address, can be null" << endl;
cout << "• Use const& for read-only efficiency" << endl;
cout << "• Default args must be at end" << endl;
cout << "============================================" << endl;
return 0;
}
// ============================================================
// FUNCTION DEFINITIONS
// ============================================================
// Pass by value - receives a COPY
void incrementByValue(int x) {
x++; // Only modifies the local copy
cout << " Inside function: x = " << x << endl;
}
// Pass by reference - receives the ACTUAL variable
void incrementByReference(int& x) {
x++; // Modifies the original variable
}
// Swap using references
void swap(int& a, int& b) {
int temp = a;
a = b;
b = temp;
}
// Pass by pointer
void incrementByPointer(int* x) {
if (x != nullptr) { // Always check for null!
(*x)++; // Dereference and increment
}
}
void setToZero(int* ptr) {
if (ptr != nullptr) {
*ptr = 0;
} else {
cout << "Received null pointer - no action taken" << endl;
}
}
// Const reference - efficient and safe
void printValue(const int& x) {
cout << "Value: " << x << endl;
// x = 10; // ERROR: cannot modify const reference
}
void printString(const string& str) {
cout << "String: " << str << endl;
// str = "changed"; // ERROR: cannot modify const reference
}
// Const with array
int sumArray(const int arr[], int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
sum += arr[i];
// arr[i] = 0; // ERROR: cannot modify const array
}
return sum;
}
// Const with vector
void displayVector(const vector<int>& vec) {
cout << "Vector: ";
for (int val : vec) {
cout << val << " ";
}
cout << endl;
}
// Array parameters (arrays decay to pointers)
void fillArray(int arr[], int size, int value) {
for (int i = 0; i < size; i++) {
arr[i] = value;
}
}
void printArray(int arr[], int size) {
for (int i = 0; i < size; i++) {
cout << arr[i] << " ";
}
cout << endl;
}
// Using pointer syntax explicitly
void modifyArray(int* arr, int size) {
for (int i = 0; i < size; i++) {
arr[i] *= 2; // Double each element
}
}
// Default arguments
void greet(string name) { // Default value in declaration only!
cout << "Hello, " << name << "!" << endl;
}
void printRectangle(int width, int height, char ch) {
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
cout << ch;
}
cout << endl;
}
}
int power(int base, int exp) {
int result = 1;
for (int i = 0; i < exp; i++) {
result *= base;
}
return result;
}
// ============================================================
// EXERCISES:
// ============================================================
/*
* 1. Write a function that finds min and max of an array
* using reference parameters for the results
*
* 2. Write a function that reverses a string in place
* using pass by reference
*
* 3. Write a function with default arguments that calculates
* simple interest (principal, rate, time)
*
* 4. Write a function that safely divides two numbers
* using pointers to return both quotient and remainder
*
* 5. Write a function that modifies a vector to remove
* all negative numbers
*/