Member Functions in C++: An Easy Guide.

Welcome to the world of C++ programming! Today, we’re going to dive into an essential part of C++: member functions. But before we start, let’s make sure we’re on the same page. This article is written with beginners in mind, so don’t worry if you’re just starting out. We’ll take it step by step, making sure everything is easy to understand. Ready? Let’s get started!

What is Member Function in C++?

A member function is a function that belongs to a class. It’s declared within the class using one of the visibility modes: public, private, or protected. A member function can access all the class’s data members. If the member function is defined within the class definition, it can be directly defined there. Otherwise, if defined outside the class, we use the scope resolution operator (::) in C++.

The main purpose of using member functions is to make programs more organized. They enhance code reusability and maintainability.

Syntax:

returnType ClassName::functionName(parameters) {
    // Function body
    // Code to be executed
}

• returnType: The data type of the value that the function will return, such as int, void, double, etc.
• ClassName: The name of the class to which the member function belongs.
• functionName: The name of the member function.
• parameters: Any input parameters that the function may require

Definition:

A member function in C++ is a function that belongs to a class. It’s defined or declared within the class, just like any other variable.

When you have a member function, you can use it on any object that belongs to the same class. This function can work with all the variables and functions that are part of that class. To use a member function, you first need to create an object of the class it belongs to.

How are Member Functions Used?

Let’s look at an example. We’ll create a class Dog and give it some member functions.

class Dog {
public:
    void bark() {
        cout << "Woof!" << endl;
    }

    void eat() {
        cout << "The dog is eating." << endl;
    }

    void sleep() {
        cout << "The dog is sleeping." << endl;
    }
};

Explanation:

• The code involves a class named ‘Dog‘.
• Inside the class, there are three member functions: bark(), eat(), and sleep().
• To use these functions, an object of the Dog class must be created.
• The created object can then call the bark(), eat(), and sleep() functions to perform their respective actions.

Dog myDog;
myDog.bark();
myDog.eat();
myDog.sleep();

When you run this code, you’ll see the following output:

Woof!
The dog is eating.
The dog is sleeping.

Each line of output corresponds to a member function being called on the ‘myDog‘ object.

Member Function inside the Class

Code Example:

#include <iostream>
using namespace std;

class Calculator {
  public:
    // Member function to add two numbers
    int add(int a, int b) {
        return a + b;
    }
};

int main() {
    Calculator calc; // Creating an instance of the Calculator class

    int num1 = 5, num2 = 7;
    int sum = calc.add(num1, num2); // Calling the add function

    cout << "Sum of " << num1 << " and " << num2 << " is: " << sum << endl;

    return 0;
}

Output:

Sum of 5 and 7 is: 12

Explanation:

• The example involves a class named ‘Calculator‘.
• Inside the class, there’s a member function named add which takes two integers and returns their sum.
• In the ‘main‘ function, an instance of the ‘Calculator‘ class is created.
• The ‘add‘ function is called using the instance, passing two numbers.
• The result is printed, showing the sum of the numbers.

The Problem with Function Definition inside

When you define member functions inside a class, it can cause a problem known as inline expansion. This means that the function code is directly inserted wherever it’s called, which can lead to a larger code size. This might sound good, but it can actually slow down the program because it can cause memory issues, like thrashing and more page faults. It’s usually better to define the function outside the class to avoid these problems. Let’s take a look at how this works:

Member Function outside the Class

When we define member functions inside a class, they become inline functions, meaning the code of the function is inserted directly wherever it’s called. This can lead to larger code size and reduced performance due to increased memory usage. When functions are called frequently, it can lead to memory issues and page faults.

To avoid these problems, it’s better to define member functions outside the class. This separates the function’s implementation from its declaration and helps in better memory management.

Code Example:

#include <iostream>
using namespace std;

class Calculator {
public:
    int add(int a, int b);  // Declaration
};

int Calculator::add(int a, int b) {
    return a + b;  // Definition outside the class
}

int main() {
    Calculator calc;
    int result = calc.add(5, 7);
    cout << "Sum: " << result << endl;
    return 0;
}

Output:

Sum: 12

Explanation:

• The ‘add()‘ function is declared within the class ‘Calculator‘.
• The actual implementation (definition) of the ‘add()‘ function is placed outside the class.
• This separation helps to improve memory usage and program performance.
• It avoids the potential issues of inlining large code and memory thrashing.
• The main advantage is better memory management and more efficient execution.

Accessing the Private Member Function of A Class

In C++, when certain class members are declared as private, they can only be accessed by functions within that class and not by any objects of the class. To access private member functions, we utilize public member functions of the same class. Public member functions are granted access to private member functions.

The following code example illustrates how public member functions can encapsulate and enable the usage of private member functions through class objects.

Code Example:

#include <iostream>
using namespace std;

class MyClass {
private:
    void privateFunction() {
        cout << "This is a private member function." << endl;
    }

public:
    void publicFunction() {
        cout << "This is a public member function." << endl;
        privateFunction(); // Accessing private function within the class
    }
};

int main() {
    MyClass obj;
    obj.publicFunction(); // Calling the public function

    return 0;
}

Output:

This is a public member function.
This is a private member function.

Explanation:

• The code example features a class called ‘MyClass‘.
• Inside ‘MyClass‘, there’s a private member function named ‘privateFunction()‘.
• The private function is accessed within the class using the public member function ‘publicFunction()‘.
• The ‘main()‘ function creates an object of ‘MyClass‘.
• The ‘publicFunction()‘ is called on the object, which also internally calls the ‘privateFunction()‘.
• This demonstrates that private member functions can be accessed and used within the same class.

Real-Life Scenarios and Hooks

Member Functions in Simple Terms:
Think of a class in C++ as a blueprint for creating objects. This blueprint defines the characteristics (data) and actions (functions) that the objects can perform. These actions defined within the class are what we call “member functions”.

Real-life Analogy: A Television Set

Imagine a class being like a blueprint for a television set. A television set has characteristics, such as brand, screen size, and volume level. It also has actions it can perform, like turning on/off, increasing/decreasing volume, and changing channels.

Blueprint (Class) for a Television:

class Television {
private:
    string brand;     // Brand of the television.
    int screenSize;   // Size of the screen (in inches).
    int volumeLevel;  // Current volume level.
    bool isOn;        // Whether the TV is on or off.

public:
    // Constructor
    Television(string b, int s) : brand(b), screenSize(s), volumeLevel(50), isOn(false) {}

    // Member Function to turn on the TV
    void turnOn() {
        isOn = true;
        cout << "TV is now turned on!" << endl;
    }

    // Member Function to turn off the TV
    void turnOff() {
        isOn = false;
        cout << "TV is now turned off!" << endl;
    }

    // Member Function to increase the volume
    void increaseVolume() {
        if (isOn && volumeLevel < 100) {
            volumeLevel++;
            cout << "Volume: " << volumeLevel << endl;
        }
    }

    // Member Function to decrease the volume
    void decreaseVolume() {
        if (isOn && volumeLevel > 0) {
            volumeLevel--;
            cout << "Volume: " << volumeLevel << endl;
        }
    }

    // ... You can add more functions like changeChannel(), mute(), etc.
};

In this example:

• The attributes like brand, ‘screenSize‘, ‘volumeLevel‘, and ‘isOn‘ are the characteristics of the television.
• The functions like ‘turnOn()‘, ‘turnOff()‘, ‘increaseVolume()‘, and ‘decreaseVolume()‘ are the actions (or member functions) that the television can perform.

When you buy a television and bring it home, you’re essentially creating an object of this Television blueprint. You can then perform actions on it, like turning it on, adjusting the volume, and so on.

In C++, the member functions are the actions that an object (like our television set) can perform. The object uses these functions to interact with its data and the outside world.

Problem to Solve

Problem Statement: Digital Library System

A digital library wants to maintain a catalog of its books. Each book has a title, author, publication year, and a unique identification number.

Design a class Book that represents a book in this digital library. The class should have the following capabilities:

1. Attributes:
   • title: A string to store the name of the book.
   • author: A string to store the author’s name.
   • pubYear: An integer to store the publication year of the book.
   • bookID: A unique integer for every book in the library.
2. Member Functions:
   • A constructor to initialize a new book. The constructor should accept values for the title, author, and publication year. The ‘bookID‘ should be auto-generated (you can simply increment it for each new book).
   • A function ‘displayBook()‘ to display the details of the book.
   • Functions to modify and retrieve each attribute (i.e., ‘setTitle()‘, ‘getTitle()‘, ‘setAuthor()‘, ‘getAuthor()‘, and so on).
   • A function ‘updateBookDetails()‘ which allows updating the title, author, and publication year at once.

Task:

1. Design the Book class based on the above requirements.
2. Create three objects (books) and initialize them with some data.
3. Display the details of each book using the displayBook() function.
4. Update the details of one book using the updateBookDetails() function and display the updated details.

Bonus:

Design an additional class ‘Library‘ that holds a collection of books (using an array or vector). Include member functions to:

• Add a book to the library.
• Display all books in the library.
• Search for a book by its ID.

Examples of Input-Output and Explanation

Let’s walk through some examples to understand member functions better. We’ll start with a simple class and gradually add more complexity.

Example 1: Basic Member Function

#include <iostream>
using namespace std;

class MyClass {
public:
    void printMessage() {
        cout << "Hello from the member function!" << endl;
    }
};

int main() {
    MyClass obj; // Creating an object of the class
    obj.printMessage(); // Calling the member function
    return 0;
}

Output:

Hello from the member function!

Explanation:

• We create a class named MyClass.
• Inside the MyClass, there’s a function called printMessage().
• In the main() function, we make an object named obj of the MyClass.
• We call the printMessage() function using the obj object.
• As a result, the console displays “Hello from the member function!” message.

Example 2: Member Function with Parameters

#include <iostream>
using namespace std;

class Calculator {
public:
    int add(int a, int b) {
        return a + b;
    }
};

int main() {
    Calculator calc;
    int num1 = 5, num2 = 7;
    int sum = calc.add(num1, num2);
    
    cout << "Sum of " << num1 << " and " << num2 << " is: " << sum << endl;

    return 0;
}

Output:

Sum of 5 and 7 is: 12

Explanation:

• There’s a class named Calculator.
• The class has a member function named ‘add‘.
• The ‘add‘ function takes two integer parameters.
• It returns the sum of the two parameters.
• In the ‘main‘ function:
• An object of the ‘Calculator‘ class is created.
• The add function is used to calculate the sum of two numbers.
• The calculated sum is printed on the console.

Example 3: Member Function Returning a Value

#include <iostream>
using namespace std;

class Calculator {
public:
    int add(int a, int b) {
        return a + b;
    }
};

int main() {
    Calculator calc;
    int num1 = 5, num2 = 3;
    int sum = calc.add(num1, num2);

    cout << "The sum of " << num1 << " and " << num2 << " is: " << sum << endl;

    return 0;
}

Output:

The sum of 5 and 3 is: 8

Explanation:

• There’s a class called Calculator with a function called add that adds two integers.
• In the main function, we make an instance of the Calculator class.
• We use the add function to calculate the sum of two numbers.
• The result is displayed using cout.

Advantages and Disadvantages of Member Functions

Key Takeaways

• Organized Code: Member functions group related actions together with the data they work on, making the code more organized and easier to manage.
• Encapsulation: Member functions encapsulate the behavior of an object, providing a clear interface for interaction while hiding the implementation details.
• Data Abstraction: Member functions allow you to define how an object interacts with the outside world, abstracting away the internal complexities.
• Reusability: Once defined, member functions can be reused across different instances of the same class, promoting code reusability.
• Efficiency: Member functions can directly access the private members of a class, leading to efficient data manipulation.
• Maintenance: With well-structured member functions, debugging, testing, and maintaining the code becomes easier.
• Code Readability: Member functions improve code readability as related operations are contained within the same class.
• Polymorphism: Member functions can be overridden in derived classes, enabling polymorphism and dynamic behavior.
• Flexibility: Member functions allow you to change the internal implementation of a class without affecting the code that uses it.
• Code Collaboration: Using member functions helps multiple programmers collaborate more efficiently by defining clear interfaces.

Conclusion

In this article, we’ve explored the world of member functions in C++. We’ve learned what they are, why they’re needed, and how they’re used. We’ve also looked at some real-life scenarios, explored the concept of multiple inheritance, and worked through several examples. Whether you’re a beginner just starting out or an experienced programmer looking to brush up on your skills, understanding member functions is a crucial step in mastering C++.

Frequently Asked Questions

1. What is a member function in C++?

A member function, also known as a method, is a function that belongs to a specific class in C++. It’s like an action that an object of that class can perform.

2. Why are member functions important?

Member functions are important because they allow you to group related functions with the data they operate on. This makes your code more organized, easier to read, and easier to maintain.

3. How do I use a member function?

To use a member function, you first need to create an object of the class that the function belongs to. Then, you can call the function on that object using the dot operator (e.g., myObject.myFunction()).

4. What is multiple inheritance in C++?

Multiple inheritance is a feature of C++ that allows a class to inherit from more than one class. This means that a class can use the member functions (and other members) of multiple other classes.

5. What are the advantages and disadvantages of member functions?

Advantages of member functions include encapsulation, code organization, and code reuse. Disadvantages can include increased memory usage and potential complexity in large programs.