files added

Author: Mabdullahatif

Beginners_3/Stage_10/manual.docx

@@ -0,0 +1,157 @@
+/*
+This C++ program demonstrates the concept of polymorphism using a simple banking system.
+
+There is a base class 'Account' that represents a generic bank account with attributes 'AN' (Account Number) and 'AB' (Account Balance).
+It has member functions to get and set these attributes, and also virtual functions 'Print', 'Credit', and 'Debit'.
+
+Two derived classes, 'CurrentAccount' and 'SavingAccount', are created from the 'Account' class.
+The 'CurrentAccount' class adds attributes 'SC' (Service Charges) and 'MB' (Minimum Balance) and overrides the 'Print', 'Credit', and 'Debit' functions.
+The 'SavingAccount' class adds an attribute 'IR' (Interest Rate) and also overrides the 'Print', 'Credit', and 'Debit' functions.
+
+In the 'main' function, an array of pointers to the 'Account' base class is created, and three different account objects (one 'SavingAccount', one 'CurrentAccount', and one 'Account') are dynamically allocated and assigned to the array elements.
+
+Polymorphism is demonstrated by calling the 'Print', 'Credit', and 'Debit' functions on the array elements, which results in calling the appropriate functions based on the object type.
+
+Sample output:
+------------------
+Account Number : 0
+Account Balance : 0
+Interest Rate : 5
+Account Number : 0
+Account Balance : 0
+Services Charges : 100
+Minimum Balance : 1000
+Account Number : 0
+Account Balance : 0
+Account destroyed !!
+Saving Account destroyed !!
+Current Account destroyed !!
+------------------
+*/
+
+#include <iostream>
+using namespace std;
+
+class Account {
+private:
+    int AN, AB;
+
+public:
+    int getAN() {
+        return AN;
+    }
+
+    int getAB() {
+        return AB;
+    }
+
+    void setAN(int acn) {
+        AN = acn;
+    }
+
+    void setAB(int acb) {
+        AB = acb;
+    }
+
+    virtual void Print() {
+        cout << "Account Number : " << AN << endl
+             << "Account Balance : " << AB << endl;
+    }
+
+    virtual void Credit(float) {
+    }
+
+    virtual void Debit(float) {
+    }
+
+    virtual ~Account() {
+        cout << "Account destroyed !!" << endl;
+    }
+};
+
+class CurrentAccount : public Account {
+private:
+    int SC, MB;
+
+public:
+    CurrentAccount() {
+        SC = 100; // Default service charges
+        MB = 1000; // Default minimum balance
+    }
+
+    void Print() {
+        Account::Print();
+        cout << "Services Charges : " << SC << endl
+             << "Minimum Balance : " << MB << endl;
+    }
+
+    void Credit(float amount) {
+        setAB(getAB() + amount);
+    }
+
+    void Debit(float amount) {
+        if (amount <= getAB()) {
+            setAB(getAB() - amount);
+            if (getAB() < MB) {
+                setAB(getAB() - SC);
+            }
+        }
+    }
+
+    ~CurrentAccount() {
+        cout << "Current Account destroyed !!" << endl;
+    }
+};
+
+class SavingAccount : public Account {
+private:
+    int IR; // Interest Rate
+
+public:
+    SavingAccount() {
+        IR = 5; // Default interest rate
+    }
+
+    void Print() {
+        Account::Print();
+        cout << "Interest Rate : " << IR << endl;
+    }
+
+    void Credit(float amount) {
+        setAB(getAB() + amount);
+    }
+
+    void Debit(float amount) {
+        if (amount <= getAB()) {
+            setAB(getAB() - amount);
+        }
+    }
+
+    ~SavingAccount() {
+        cout << "Saving Account destroyed !!" << endl;
+    }
+};
+
+int main() {
+    // Array of base pointers
+    Account** alist = new Account*[3];
+    alist[0] = new SavingAccount;
+    alist[1] = new CurrentAccount;
+    alist[2] = new Account;
+
+    // Print data of all accounts polymorphic behavior
+    for (int i = 0; i < 3; i++)
+        alist[i]->Print();
+
+    // Credit and debit polymorphic behavior
+    alist[0]->Credit(50);
+    alist[2]->Debit(333);
+
+    // Freeing the dynamically allocated objects
+    for (int i = 0; i < 3; i++) {
+        delete alist[i];
+    }
+    delete[] alist;
+
+    return 0;
+}

Beginners_3/Stage_10/task1.cpp

@@ -0,0 +1,38 @@
+/*
+This C++ program demonstrates the use of a function template to compare two values for equality.
+
+The function template 'isEqualTo' is defined, which takes two parameters of the same data type 'T'.
+It compares the values of 'a' and 'b' using the '==' operator and returns true if they are equal, otherwise false.
+
+In the 'main' function, we have variables of different data types: 'num1' and 'num2' of type int, 'f1' and 'f2' of type float, and 'ch1' and 'ch2' of type char.
+
+The 'isEqualTo' function is called with each pair of variables, and the result is printed to the console.
+
+Sample output:
+------------------
+Is num1 equal to num2? 0
+Is f1 equal to f2? 1
+Is ch1 equal to ch2? 0
+------------------
+Here, num1 is not equal to num2, f1 is equal to f2, and ch1 is not equal to ch2.
+*/
+
+#include <iostream>
+using namespace std;
+
+template <typename T>
+bool isEqualTo(T a, T b) {
+    return a == b;
+}
+
+int main() {
+    int num1 = 5, num2 = 10;
+    float f1 = 3.14, f2 = 3.14;
+    char ch1 = 'A', ch2 = 'B';
+
+    cout << "Is num1 equal to num2? " << isEqualTo(num1, num2) << endl;
+    cout << "Is f1 equal to f2? " << isEqualTo(f1, f2) << endl;
+    cout << "Is ch1 equal to ch2? " << isEqualTo(ch1, ch2) << endl;
+
+    return 0;
+}

Beginners_3/Stage_11/manual.docx

@@ -0,0 +1,147 @@
+/*
+This C++ program demonstrates the use of abstract classes and inheritance to create different types of bank accounts.
+
+The 'Account' class is defined as an abstract class with two pure virtual functions: 'Debit' and 'Credit'.
+The class also has two member variables: 'accountNumber' to store the account number and 'accountBalance' to store the current balance.
+
+Two derived classes 'CurrentAccount' and 'SavingAccount' inherit from the 'Account' class and provide their implementations of the 'Debit' and 'Credit' functions.
+Additionally, a new class 'BasicAccount' is created that also inherits from the 'Account' class and implements its own version of 'Debit' and 'Credit'.
+
+In the 'main' function, we create an array of pointers to 'Account' class objects to hold different types of accounts.
+We create instances of 'CurrentAccount', 'SavingAccount', and 'BasicAccount' using dynamic memory allocation.
+We then print the account details using the 'Print' function for each account type and finally, free the dynamically allocated memory.
+
+Sample output:
+------------------
+Account Number: 456
+Account Balance: 2000
+Minimum Balance: 500
+Service Charges: 50
+Account Number: 789
+Account Balance: 3000
+Interest Rate: 5
+Account Number: 123
+Account Balance: 1000
+------------------
+Here, we see the details for each account, including the minimum balance and service charges for the current account and the interest rate for the saving account.
+The basic account has no additional features, and its details only include the account number and balance.
+*/
+
+#include <iostream>
+using namespace std;
+
+class Account {
+protected: // Change access specifier to protected
+    int accountNumber;
+    float accountBalance;
+
+public:
+    Account(int num, float balance) : accountNumber(num), accountBalance(balance) {}
+
+    int getAccountNumber() const {
+        return accountNumber;
+    }
+
+    float getAccountBalance() const {
+        return accountBalance;
+    }
+
+    virtual void Debit(float amount) = 0;
+    virtual void Credit(float amount) = 0;
+
+    virtual void Print() {
+        cout << "Account Number: " << accountNumber << endl;
+        cout << "Account Balance: " << accountBalance << endl;
+    }
+
+    virtual ~Account() {}
+};
+
+class CurrentAccount : public Account {
+private:
+    float serviceCharges;
+    float minBalance;
+
+public:
+    CurrentAccount(int num, float balance, float charges, float minBal)
+        : Account(num, balance), serviceCharges(charges), minBalance(minBal) {}
+
+    void Debit(float amount) override {
+        if (amount <= getAccountBalance()) {
+            accountBalance -= amount;
+        } else {
+            cout << "Insufficient balance!" << endl;
+        }
+    }
+
+    void Credit(float amount) override {
+        accountBalance += amount;
+        if (accountBalance < minBalance) {
+            accountBalance -= serviceCharges;
+        }
+    }
+
+    void Print() override {
+        Account::Print();
+        cout << "Minimum Balance: " << minBalance << endl;
+        cout << "Service Charges: " << serviceCharges << endl;
+    }
+};
+
+class SavingAccount : public Account {
+private:
+    float interestRate;
+
+public:
+    SavingAccount(int num, float balance, float rate)
+        : Account(num, balance), interestRate(rate) {}
+
+    void Debit(float amount) override {
+        if (amount <= getAccountBalance()) {
+            accountBalance -= amount;
+        } else {
+            cout << "Insufficient balance!" << endl;
+        }
+    }
+
+    void Credit(float amount) override {
+        accountBalance += amount;
+    }
+
+    void Print() override {
+        Account::Print();
+        cout << "Interest Rate: " << interestRate << endl;
+    }
+};
+
+class BasicAccount : public Account {
+public:
+    BasicAccount(int num, float balance)
+        : Account(num, balance) {}
+
+    void Debit(float amount) override {
+        if (amount <= getAccountBalance()) {
+            accountBalance -= amount;
+        } else {
+            cout << "Insufficient balance!" << endl;
+        }
+    }
+
+    void Credit(float amount) override {
+        accountBalance += amount;
+    }
+};
+
+int main() {
+    Account* accounts[4];
+    accounts[0] = new CurrentAccount(456, 2000, 50, 500);
+    accounts[1] = new SavingAccount(789, 3000, 5);
+    accounts[2] = new BasicAccount(123, 1000);
+
+    for (int i = 0; i < 3; ++i) {
+        accounts[i]->Print();
+        delete accounts[i];
+    }
+
+    return 0;
+}