Mutable keywords in C++:

Mutable keywords are very useful keywords in C++. It is used to change or modify the class data member even if the object is a const function. Let's take an example if there is a class containing five non-static variables. All these were assigned a value with the help of a class constructor. In the main function, you created an object and decided not to change that particular object, so you used const for that object. However, after some time, you wanted to change only two particular variables. Now, you have a problem: if you want to change only two variables, you cannot remove the const before the object. Now, the mutable keyword is used in this situation. Suppose you make those two non-static variables mutable in class. In that case, you can make changes for only that particular variable, and other variables remain in const and cannot be changed.

Example:

A simple program to demonstrate the usage of mutable keywords:

#include<iostream>
using namespace std;
class MyClass {
    public:
        int variable1;
        mutable int variable2;
        MyClass(int x,int y){
            variable1 = x;
            variable2 = y;
        }
        void setVariable2(int z) const{
            variable2 =z;
        }
        void display() const {
            cout<< "variable1 is "<< variable1 << endl;
            cout << "Variable2 is "<< variable2 << endl;
        }
};
int main(){
    const MyClass my(10,20);
    cout<< "Before changing the variable2 "<< endl;
    my.display();
    my.setVariable2(2000);
    cout<< "After changing the variable2 "<< endl;
    my.display();
}

Output:

Explanation:

In this example, this simple program contains a main function and a class named MyClass again. In MyClass, there are two variables named variable1 and variable2, those two belong to int datatype, and variable1 is not mutable as the variable2 is mutable. This class contains two methods or functions named setVariable2, and other is the simple function display method. The setVariable2 method takes an argument and assigns that argument to the variable2. Another function display method is used to display both variable1 and variable2.

Now, in the main class, an object is created, and the const keyword is used to make it constant. Therefore, the variables in the object cannot be modified, but the second variable, variable2 can be modified or changed by using the setVariable2 method because the variable2 is mutable. Here, the keyword mutable is used for changing only a particular variable in the whole const object.

Example:

Now, we will bind a daily life application for the above concept:

#include <iostream>
#include <string>
#include <ctime>
using namespace std;
class BankAccount {
    string accountHolderName;
    int accountNumber;
    mutable double balance; 
    mutable string lastTransactionDate; 

public:
    BankAccount(string name, int number, double initialBalance){
        accountHolderName = name;
        accountNumber = number;
        balance = initialBalance;
        time_t now = time(0);
        lastTransactionDate = ctime(&now); 
    }

    void deposit(double amount) const {
        balance += amount;
        time_t now = time(0);
        lastTransactionDate = ctime(&now);
    }

    void withdraw(double amount) const {
        if (balance >= amount) {
            balance -= amount;
            time_t now = time(0);
            lastTransactionDate = ctime(&now);
        } else {
            cout << "Insufficient funds!" << endl;
        }
    }

    void display() const {
        cout << "Account Holder: " << accountHolderName << endl;
        cout << "Account Number: " << accountNumber << endl;
        cout << "Current Balance:  " << balance << endl;
        cout << "Last Transaction Date: " << lastTransactionDate;
        cout << " " << endl;
    }
};

int main() {
    const BankAccount account("SriRam", 12345, 1000.0);
    account.display();

    account.deposit(500.0);
    account.display();

    account.withdraw(200.0);
    account.display();

    return 0;
}

Output:

Explanation:

The above program contains a class and a main function. In the class, there is a constructor and other methods like deposit, withdraw, and display methods. These all together make the class work as a bank functionality. This class is named as BankAccount. It contains four variables: accountHolderName, which is of string datatype, accountNumber, which is of int datatype, balance, which is of double datatype, and lastTransactionDate, which is of string datatype. Here, the two variables, balance and lastTransactionDate are mutable.

The deposit method takes an argument, which is the amount to be added to the balance and updates the time of the last transaction. It makes the mutable variable to be changed. The withdraw method also takes an argument, which is the amount to be subtracted from the balance, and again updates the time of the last transaction. If the sufficient amount is not present in the bank, it displays "Insufficient funds". After that, the display method is used to display all the four variables.

In the main function, an object is created and named an account by taking four arguments: name, number, intitalbalance. The first display method is called. Now, some amount is deposited, and again, the display method is called. After that, the withdraw method is called again, and the display method is called. After every display method, we can see the changes in balance and lastTranscationDate, which are mutable and can be modified.

Next TopicMove all zeroes to end of array in C++

← prev next →