In C++, a class is a blueprint for creating objects (a particular data structure), providing initial values for state (member variables or attributes), and implementations of behavior (member functions or methods). In this article, we will focus on class methods and how they are used to define the behavior of objects created from a class.
Creating a Class Method
A class method is a function that is declared as a member of a class. It has access to the member variables of the class and can modify their values. To create a class method, we use the following syntax:
class MyClass {
public:
void myMethod() {
// method body
}
};
In this example, we have created a class named MyClass with a single method named myMethod. The keyword void is the return type of the method, which means it does not return any value. The method body is enclosed in curly braces {}. We can also create methods that return a value by specifying the return type before the method name.
class MyClass {
public:
int myMethod() {
return 5;
}
};
In this example, the myMethod returns an integer value of 5.
Accessing Class Methods
We can access class methods by creating an object of the class and then calling the method on the object using the dot operator (.).
MyClass myObject; myObject.myMethod();
In this example, we have created an object of the class MyClass named myObject. We then call the myMethod on this object using the dot operator. If the method returns a value, we can store it in a variable as follows:
MyClass myObject; int result = myObject.myMethod();
Method Parameters and Arguments
Class methods can also accept parameters, which are values passed to the method when it is called. These values are used to perform the method’s behavior. The syntax for creating a method with parameters is as follows:
class MyClass {
public:
void myMethod(int x, int y) {
// method body
}
};
In this example, the myMethod accepts two integer parameters named x and y. To call the method and pass in values for the parameters, we use the following syntax:
MyClass myObject; myObject.myMethod(5, 10);
In this example, we are passing the values 5 and 10 as arguments to the myMethod when it is called on the myObject.
Method Overloading
C++ allows for method overloading, which means that a class can have multiple methods with the same name but different parameter lists. The correct method is chosen at compile-time based on the type and number of arguments passed to it. The following example illustrates method overloading:
class Calculator {
public:
int add(int x, int y) {
return x + y;
}
double add(double x, double y) {
return x + y;
}
};
In this example, we have a class named Calculator with two methods named add. The first method accepts two integer parameters and returns an integer value, while the second method accepts two double parameters and returns a double value. When we call the add method on a Calculator object and pass in integer arguments, the first method is called. If we pass in double arguments, the second method is called.
Method Access Modifiers
C++ provides three access modifiers for class methods: public, private, and protected. The access modifiers determine the level of access other parts of the code have to the method.
- Public methods can be accessed by any part of the code.
- Private methods can only be accessed by other methods of the same class.
- Protected methods can be accessed by other methods of the same class and by methods of derived classes.
The default access level for methods is private. To specify the access level of a method, we use the access level keyword before the method declaration.
class MyClass {
public:
void myPublicMethod() {
// method body
}
private:
void myPrivateMethod() {
// method body
}
protected:
void myProtectedMethod() {
// method body
}
};
In this example, myPublicMethod is a public method, myPrivateMethod is a private method, and myProtectedMethod is a protected method. The public method can be accessed by any part of the code, the private method can only be accessed by other methods of the same class, and the protected method can be accessed by other methods of the same class and by methods of derived classes.
Static Class Methods
C++ also allows for the creation of static class methods. A static method is a method that belongs to the class itself, rather than an object of the class. This means that a static method can be called without first creating an object of the class. The syntax for creating a static method is as follows:
class MyClass {
public:
static void myMethod() {
// method body
}
};
To call a static method, we use the class name followed by the scope resolution operator (::) and the method name.
MyClass::myMethod();
In this example, we call the myMethod on the MyClass class without first creating an object of the class. Static methods do not have access to the non-static members of the class, but they can access static members.
Example of a Bank Account Class and its Methods
One real-life example of class methods in C++ could be a class that represents a bank account. The class would have methods such as “deposit()” and “withdraw()” to handle transactions, and “getBalance()” to return the current balance of the account. Here is an example implementation of the “BankAccount” class:
class BankAccount {
private:
double balance;
public:
BankAccount(double initialBalance) {
balance = initialBalance;
}
void deposit(double amount) {
balance += amount;
}
void withdraw(double amount) {
if (amount > balance) {
cout << "Insufficient funds." << endl;
} else {
balance -= amount;
}
}
double getBalance() {
return balance;
}
};
In this example, the class has a private member variable “balance” which stores the current balance of the account. The class also has three public methods: “deposit()” which adds the amount passed to the method to the balance; “withdraw()” which subtracts the amount passed to the method from the balance, but only if the amount is less than or equal to the current balance; and “getBalance()” which returns the value of the balance.
To use this class, we would first create an object of the class, passing in the initial balance as an argument to the constructor. Then we could call methods on that object to perform transactions and check the balance:
int main() {
BankAccount myAccount(1000);
myAccount.deposit(500);
cout << "Current balance: " << myAccount.getBalance() << endl;
myAccount.withdraw(200);
cout << "Current balance: " << myAccount.getBalance() << endl;
myAccount.withdraw(3000);
cout << "Current balance: " << myAccount.getBalance() << endl;
return 0;
}
In this example, the initial balance of the account is 1000, we deposit 500, withdraw 200, and then try to withdraw 3000. Since there are not enough funds, the output will be “Insufficient funds.”
Summary
In C++, a class method is a function that is declared as a member of a class. It has access to the member variables of the class and can modify their values. We can access class methods by creating an object of the class and then calling the method on the object using the dot operator (.). Class methods can also accept parameters, which are values passed to the method when it is called. C++ allows for method overloading, which means that multiple methods with the same name can exist in a class as long as their parameter list is different. C++ also provides access modifiers, such as public, private, and protected, to control the level of access other parts of the code have to the method. Additionally, C++ allows for the creation of static class methods, which can be called without first creating an object of the class, and have access only to the static members of the class. Overall, class methods are an important aspect of C++ programming, allowing for the encapsulation of data and behavior within a class, and providing a way to interact with the class and its objects.
