C++: أساسيات الدوال

#include <iostream>

int main() {
 // Calculate area of the first rectangle
 double width1 = 5.0, height1 = 3.0;
 double area1 = width1 * height1;
 std::cout << "Area 1: " << area1 << std::endl;
 
 // Calculate area of the second rectangle
 double width2 = 7.0, height2 = 2.5;
 double area2 = width2 * height2;
 std::cout << "Area 2: " << area2 << std::endl;
 
 // Calculate area of the third rectangle
 double width3 = 4.0, height3 = 6.0;
 double area3 = width3 * height3;
 std::cout << "Area 3: " << area3 << std::endl;
 
 return 0;
}

#include <iostream>

// Define the function
double calculateArea(double width, double height) {
 return width * height;
}

int main() {
 std::cout << "Area 1: " << calculateArea(5.0, 3.0) << std::endl;
 std::cout << "Area 2: " << calculateArea(7.0, 2.5) << std::endl;
 std::cout << "Area 3: " << calculateArea(4.0, 6.0) << std::endl;
 
 return 0;
}

ReturnType functionName(parameterList) {
 // function body
 return returnValue; // if return type is not void
}

#include <iostream>

// Function definition: calculate the sum of two numbers
int add(int a, int b) {
 return a + b;
}

int main() {
 int result = add(3, 5); // Call the function
 std::cout << "3 + 5 = " << result << std::endl;
 return 0;
}

3 + 5 = 8

functionName(argumentList);

#include <iostream>

int max(int a, int b) {
 if (a > b) {
 return a; // End function, return a
 } else {
 return b; // End function, return b
 }
 std::cout << "This line never executes" << std::endl; // Dead code
}

int main() {
 std::cout << "Maximum: " << max(10, 20) << std::endl;
 return 0;
}

#include <iostream>

void printWelcome() { // void means no return value
 std::cout << "========== Welcome ==========" << std::endl;
 std::cout << "This is a void function, no return needed" << std::endl;
}

int main() {
 printWelcome(); // Call void function, no need to receive a return value
 return 0;
}

void printIfPositive(int x) {
 if (x <= 0) {
 return; // Exit the function early
 }
 std::cout << x << " is positive" << std::endl;
}

#include <iostream>

int main() {
 std::cout << add(3, 5) << std::endl; // ❌ Error: compiler hasn't seen add's definition yet
 return 0;
}

int add(int a, int b) {
 return a + b;
}

error: 'add' was not declared in this scope

#include <iostream>

int add(int a, int b); // Function prototype (ends with semicolon!)

int main() {
 std::cout << add(3, 5) << std::endl; // ✅ Compiler knows add exists
 return 0;
}

int add(int a, int b) { // Function definition
 return a + b;
}

#include <iostream>
#include <iomanip>

// Function prototypes
double add(double a, double b);
double subtract(double a, double b);
double multiply(double a, double b);
double divide(double a, double b);

int main() {
 double num1, num2;
 char op;
 
 std::cout << "Please enter the first number: ";
 std::cin >> num1;
 
 std::cout << "Please enter an operator (+ - * /): ";
 std::cin >> op;
 
 std::cout << "Please enter the second number: ";
 std::cin >> num2;
 
 std::cout << std::fixed << std::setprecision(2);
 
 switch (op) {
 case '+':
 std::cout << "Result: " << add(num1, num2) << std::endl;
 break;
 case '-':
 std::cout << "Result: " << subtract(num1, num2) << std::endl;
 break;
 case '*':
 std::cout << "Result: " << multiply(num1, num2) << std::endl;
 break;
 case '/':
 if (num2 != 0) {
 std::cout << "Result: " << divide(num1, num2) << std::endl;
 } else {
 std::cout << "Error: Divisor cannot be 0!" << std::endl;
 }
 break;
 default:
 std::cout << "Error: Unsupported operator!" << std::endl;
 break;
 }
 
 return 0;
}

// Function definitions
double add(double a, double b) {
 return a + b;
}

double subtract(double a, double b) {
 return a - b;
}

double multiply(double a, double b) {
 return a * b;
}

double divide(double a, double b) {
 return a / b;
}

Please enter the first number: 
Please enter an operator (+ - * /): 
Please enter the second number: 
Result: 
Result: 
Result: 
Result: 
Error: Divisor cannot be 0!
Error: Unsupported operator!

int main() {
 foo(); // ❌ Compiler doesn't know what foo is yet
 return 0;
}

void foo() {
 std::cout << "Hello" << std::endl;
}

void foo(); // ✅ Function prototype

int main() {
 foo();
 return 0;
}

void foo() {
 std::cout << "Hello" << std::endl;
}

int foo(int a); // Prototype: returns int

int main() {
 foo(5);
 return 0;
}

double foo(int a) { // ❌ Error: definition returns double, doesn't match prototype
 return a + 0.5;
}

int add(int a, int b) {
 int sum = a + b;
 // ❌ Forgot to write return
}

int main() {
 int result = add(3, 5);
 std::cout << result << std::endl; // Outputs garbage value
 return 0;
}

#include <iostream>

int max(int a, int b) {
    return (a > b) ? a : b;
}

int main() {
    int x = 10, y = 20;
    std::cout << "Larger value: " << max(x, y) << std::endl;

    return 0;
}

Larger value: 20