PImpl Idiom in C++ with Examples

27 Dec, 2021
When changes are made to a header file, all sources including it needs to be recompiled. In large projects and libraries, it can cause build time issues due to the fact that even when a small change to the implementation is made everyone has to wait some time until they compile their code. One way to solve this problem is by using the PImpl Idiom, which hides the implementation in the headers and includes an interface file that compiles instantly.
The PImpl Idiom (Pointer to IMPLementation) is a technique used for separating implementation from the interface. It minimizes header exposure and helps programmers to reduce build dependencies by moving the private data members in a separate class and accessing them through an opaque pointer.
How to implement: 
Create a separate class ( or struct ) for implementationPut all private members from the header to that class.Define an Implementation class ( Impl ) in the header file.In the header file create a forward declaration (a pointer), pointing at the implementation class.Define a destructor and a copy/assignment operators.
Create a separate class ( or struct ) for implementation
Put all private members from the header to that class.
Define an Implementation class ( Impl ) in the header file.
In the header file create a forward declaration (a pointer), pointing at the implementation class.
Define a destructor and a copy/assignment operators.
The reason to declare explicitly a destructor is that when compiling, the smart pointer ( std::unique_ptr ) checks if in the definition of the type exists a visible destructor and throws a compilation error if it’s only forward declared.
Using a smart pointer is a better approach since the pointer takes control over the life cycle of the PImpl.
Example: 
The class definition in the header file included is the public interface of the class.
We define a unique pointer instead of a raw one because the object of the interface type is responsible for the lifetime of the object.
Since std::unique_ptr is a complete type it requires a user-declared destructor and copy/assignment operators in order for the implementation class to be complete.
The pimpl approach is transparent from the user’s viewpoint. Changes made to the IMPLementation structure, internally, affect only the file containing it (User.cpp). This means that the user does not need to recompile in order for these changes to get applied.
Header file
Implementation file
/* |INTERFACE| User.h file */ #pragma once#include <memory> // PImpl#include <string>using namespace std; class User {public:    // Constructor and Destructors     ~User();    User(string name);     // Assignment Operator and Copy Constructor     User(const User& other);    User& operator=(User rhs);     // Getter    int getSalary();     // Setter    void setSalary(int); private:    // Internal implementation class    class Impl;     // Pointer to the internal implementation    unique_ptr<Impl> pimpl;};
/* |IMPLEMENTATION| User.cpp file */ #include "User.h"#include <iostream>using namespace std; struct User::Impl {     Impl(string name)        : name(move(name)){};     ~Impl();     void welcomeMessage()    {        cout << "Welcome, "             << name << endl;    }     string name;    int salary = -1;}; // Constructor connected with our Impl structureUser::User(string name)    : pimpl(new Impl(move(name))){    pimpl->welcomeMessage();} // Default ConstructorUser::~User() = default; // Assignment operator and Copy constructor User::User(const User& other)    : pimpl(new Impl(*other.pimpl)){} User& User::operator=(User rhs){    swap(pimpl, rhs.pimpl);    return *this;} // Getter and setterint User::getSalary(){    return pimpl->salary;} void User::setSalary(int salary){    pimpl->salary = salary;    cout << "Salary set to "         << salary << endl;}
Advantages of PImpl:
Binary Compatibility: The binary interface is independent of the private fields. Making changes to the implementation would not break the dependent code.
Compilation time: Compilation time drops due to the fact that only the implementation file needs to be rebuilt instead of every client recompiling his file.
Data Hiding: Can easily hide certain internal details such as implementation techniques and other libraries used to implement the public interface.
Disadvantages of PImpl:
Memory Management: Possible increase in memory usage due to more memory allocation than with the default structure which can be critical in embedded software development.
Maintenance Effort: The maintenance is becoming more complex due to the additional class in order to use pimpl and additional pointer indirection (Interface can be used only via pointer/reference).
Inheritance: Hidden implementation cannot be inherited, although a class PImpl can.
Reference: https://en.cppreference.com/w/cpp/language/pimpl
anikakapoor
bh5peo6qcfmksnh36kx7ugqdzds1gs5q8nv43m4j
C++
Programming Language
CPP
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Polymorphism in C++
Queue in C++ Standard Template Library (STL)
List in C++ Standard Template Library (STL)
Command line arguments in C/C++
Exception Handling in C++
Modulo Operator (%) in C/C++ with Examples
Arrow operator -> in C/C++ with Examples
Differences between Procedural and Object Oriented Programming
Advantages and Disadvantages of OOP
Difference between while and do-while loop in C, C++, Java