Can a constructor be private in C++ ?

Prerequisite : Constructors
A constructor is a special member function of a class which initializes objects of a class. In C++, constructor is automatically called when object of a class is created.

By default, constructors are defined in public section of class. So, question is can a constructor be defined in private section of class ?
Answer : Yes, Constructor can be defined in private section of class

How to use Constructors in private section?

1. Using Friend Class : If we want that class should not be instantiated by anyone else but only by a friend class.

   // CPP program to demonstrate usage of
   // private constructor
   #include <iostream>
   using namespace std;
   
   // class A
   class A{
   private:
       A(){
          cout << "constructor of A\n";
       }
       friend class B;
   };
   
   // class B, friend of class A
   class B{
   public:
       B(){
           A a1;
           cout << "constructor of B\n";
       }
   };
   
   // Driver program
   int main(){
       B b1;
       return 0;
   }

   Output:

   constructor of A
   constructor of B
   

   If you comment the line friend class B, you will encounter below error:

   test1.cpp: In constructor ‘B::B()’:
   test1.cpp:9:5: error: ‘A::A()’ is private
        A(){
        ^
   test1.cpp:19:11: error: within this context
            A a1;
   

2. Using Singleton design pattern: When we want to design a singleton class. This means instead of creating several objects of class, the system is driven by a single object or a very limited number of objects.
3. Named Constructor Idiom : Since constructor has same name as of class, different constructors are differentiated by their parameter list, but if numbers of constructors is more, then implementation can become error prone.

   With the Named Constructor Idiom, you declare all the class’s constructors in the private or protected sections, and then for accessing objects of class, you create public static functions.

   For example, consider below CPP program

   // CPP program to demonstrate
   // ambiguous nature of constructor
   // with same no of parameters of same type
   #include <iostream>
   using namespace std;
   class Point
   {
       public:
   
       // Rectangular coordinates
       Point(float x, float y);
   
       // Polar coordinates (radius and angle)
       Point(float r, float a);
   
       // error: ‘Point::Point(float, float)’ cannot
       // be overloaded
   };
   int main()
   {
       // Ambiguous: Which constructor to be called ?
       Point p = Point(5.7, 1.2);
       return 0;
   }

   This problem can be resolved by Named Constructor Idiom. The above CPP program can be improved as following :

   // CPP program to demonstrate
   // named constructor idiom
   #include <iostream>
   #include <cmath>
   using namespace std;
   class Point
   {
       private:
       float x1, y1;
       Point(float x, float y)
       {
           x1 = x;
           y1 = y;
       };
   public:
       // polar(radius, angle)
       static Point Polar(float, float);
   
       // rectangular(x, y)
       static Point Rectangular(float, float);
       void display();
   };
   
   // utility function for displaying of coordinates
   void Point :: display()
   {
       cout << "x :: " << this->x1 <<endl;
       cout << "y :: " << this->y1 <<endl;
   }
   
   // return polar coordinates
   Point Point :: Polar(float x, float y)
   {
       return Point(x*cos(y), x*sin(y));
   }
   
   // return rectangular coordinates
   Point Point :: Rectangular(float x, float y)
   {
       return Point(x,y);
   }
   int main()
   {
       // Polar coordinates
       Point pp = Point::Polar(5.7, 1.2);
       cout << "polar coordinates \n";
       pp.display();
   
       // rectangular coordinates
       Point pr = Point::Rectangular(5.7,1.2);
       cout << "rectangular coordinates \n";
       pr.display();
       return 0;
   }

   Output :

   polar coordinates 
   x :: 2.06544
   y :: 5.31262
   rectangular coordinates 
   x :: 5.7
   y :: 1.2
   

References :
1) Named Constructor Idiom
2) can a constructor be private in cpp