Pure Virtual Functions, Abstract Classes, and Interface Design

Intermediate13 min read•Updated: 2026-10-22

📐 Pure Virtual Functions, Abstract Classes, and Interface Design

Introduction

An abstract class defines an interface (a strict operational contract) that subclasses must implement. In C++, setting a virtual function signature to = 0 designates it as a pure virtual function.

📝 Syntax & Abstract Classes

An abstract class cannot be directly instantiated:

1#include <iostream>
2#include <string>
3 
4// Pure Abstract Interface
5class IPaymentGateway {
6public:
7    virtual ~IPaymentGateway() = default;
8 
9    // Pure Virtual Functions (= 0)
10    virtual bool processPayment(double amount) = 0;
11    virtual std::string getGatewayName() const = 0;
12};
13 
14// Concrete Implementation 1: UPI Gateway
15class UpiPayment : public IPaymentGateway {
16private:
17    std::string m_upiId;
18public:
19    explicit UpiPayment(const std::string& upi) : m_upiId(upi) {}
20 
21    bool processPayment(double amount) override {
22        std::cout << "[UPI]: Transferred ₹" << amount << " via UPI ID: " << m_upiId << "\n";
23        return true;
24    }
25 
26    std::string getGatewayName() const override {
27        return "National Payments UPI Gateway";
28    }
29};
30 
31// Concrete Implementation 2: Credit Card Gateway
32class CreditCardPayment : public IPaymentGateway {
33private:
34    std::string m_cardNumberMasked;
35public:
36    explicit CreditCardPayment(const std::string& card) : m_cardNumberMasked(card) {}
37 
38    bool processPayment(double amount) override {
39        std::cout << "[CARD]: Charged ₹" << amount << " to Card ending in " << m_cardNumberMasked << "\n";
40        return true;
41    }
42 
43    std::string getGatewayName() const override {
44        return "Secure VISA/MasterCard Gateway";
45    }
46};
47 
48// High-level Checkout service decoupled from concrete payment logic!
49void checkoutStudent(IPaymentGateway& gateway, double courseFee) {
50    std::cout << "Connecting to: " << gateway.getGatewayName() << "...\n";
51    gateway.processPayment(courseFee);
52    std::cout << "Payment confirmed! Enrollment active.\n";
53}
54 
55int main() {
56    UpiPayment upi("student@oksbi");
57    CreditCardPayment card("4598");
58 
59    checkoutStudent(upi, 4999.0);
60    std::cout << "---------------------------------\n";
61    checkoutStudent(card, 7999.0);
62 
63    return 0;
64}

💡 The Dependency Inversion Principle

By coding against abstract interfaces (IPaymentGateway) rather than rigid concrete implementations (UpiPayment), your systems become modular, swappable, and easily unit-tested.

Next Lesson

The override and final Specifiers, and Virtual Destructors

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Virtual Functions, Dynamic Dispatch, and the vtable Mechanism	The override and final Specifiers, and Virtual Destructors

Practice Quiz

Test your understanding of this lesson with 1 questions. Each question has one correct answer.

Previous Next

PreviousPrevNext

MSK Institute • Shikohabad

Loading Page Content...

Preparing courses, live labs, and learning resources.सामग्री लोड हो रही है, कृपया प्रतीक्षा करें...

Connecting serverPlease wait...

💻 Practical Labs🚀 Free Demo📜 Verified Certificates

📝 Syntax & Abstract Classes

An abstract class cannot be directly instantiated:

1#include <iostream>
2#include <string>
3 
4// Pure Abstract Interface
5class IPaymentGateway {
6public:
7    virtual ~IPaymentGateway() = default;
8 
9    // Pure Virtual Functions (= 0)
10    virtual bool processPayment(double amount) = 0;
11    virtual std::string getGatewayName() const = 0;
12};
13 
14// Concrete Implementation 1: UPI Gateway
15class UpiPayment : public IPaymentGateway {
16private:
17    std::string m_upiId;
18public:
19    explicit UpiPayment(const std::string& upi) : m_upiId(upi) {}
20 
21    bool processPayment(double amount) override {
22        std::cout << "[UPI]: Transferred ₹" << amount << " via UPI ID: " << m_upiId << "\n";
23        return true;
24    }
25 
26    std::string getGatewayName() const override {
27        return "National Payments UPI Gateway";
28    }
29};
30 
31// Concrete Implementation 2: Credit Card Gateway
32class CreditCardPayment : public IPaymentGateway {
33private:
34    std::string m_cardNumberMasked;
35public:
36    explicit CreditCardPayment(const std::string& card) : m_cardNumberMasked(card) {}
37 
38    bool processPayment(double amount) override {
39        std::cout << "[CARD]: Charged ₹" << amount << " to Card ending in " << m_cardNumberMasked << "\n";
40        return true;
41    }
42 
43    std::string getGatewayName() const override {
44        return "Secure VISA/MasterCard Gateway";
45    }
46};
47 
48// High-level Checkout service decoupled from concrete payment logic!
49void checkoutStudent(IPaymentGateway& gateway, double courseFee) {
50    std::cout << "Connecting to: " << gateway.getGatewayName() << "...\n";
51    gateway.processPayment(courseFee);
52    std::cout << "Payment confirmed! Enrollment active.\n";
53}
54 
55int main() {
56    UpiPayment upi("student@oksbi");
57    CreditCardPayment card("4598");
58 
59    checkoutStudent(upi, 4999.0);
60    std::cout << "---------------------------------\n";
61    checkoutStudent(card, 7999.0);
62 
63    return 0;
64}

Previous Lesson

Next Lesson

Virtual Functions, Dynamic Dispatch, and the vtable Mechanism

The override and final Specifiers, and Virtual Destructors