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.
    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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;
    }

    chevron_right

    
    

    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

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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;
    }

    chevron_right

    
    

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

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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;
    }

    chevron_right

    
    

    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

This article is contributed by Mandeep Singh. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.



My Personal Notes arrow_drop_up


Article Tags :
Practice Tags :


6


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.