[10] Constructors
(Part of C++ FAQ Lite, Copyright © 1991-96, Marshall Cline, cline@parashift.com)

FAQs in section [10]:

• [10.1] What's the deal with constructors?
• [10.2] Is there any difference between List x; and List x();?
• [10.3] How can I make a constructor call another constructor as aprimitive?
• [10.4] Is the default constructor for Fred always Fred::Fred()?
• [10.5] Which constructor gets called when I create anarray of Fred objects?
• [10.6] What is the "Named Constructor Idiom"?
• [10.7] Why can't I initialize my static member data in my constructor's initialization list?
• [10.8] Why are classes with static data members getting linker errors?

[10.1] What's the deal with constructors?

Constructors build objects from dust.

Constructors are like "init functions". They turn a pile of arbitrary bits into a living object. Minimally they initialize internally used fields. They may also allocate resources (memory, files, semaphores, sockets, etc).

"ctor" is a typical abbreviation for constructor.

[ Top | Bottom | Previous section | Next section ]

[10.2] Is there any difference between List x; and List x();?

A big difference!

Suppose that List is the name of some class. Then function f() declares a local List object called x:

    void f()
    {
      List x;     // Local object named x (of class List)
      // ...
    }

But function g() declares a function called x() that returns a List:

    void g()
    {
      List x();   // Function named x (that returns a List)
      // ...
    }

[ Top | Bottom | Previous section | Next section ]

    class Fred {
    public:
      Fred();   // Default constructor: can be called with no args
      // ...
    };

However it is possible (and even likely) that a default constructor can take arguments, provided they are given default values:

    class Fred {
    public:
      Fred(int i=3, int j=5);   // Default constructor: can be called with no args
      // ...
    };

[ Top | Bottom | Previous section | Next section ]

    class Fred {
    public:
      Fred(int i, int j);
      // ... assume there is no default constructor in class Fred ...
    };
    
    main()
    {
      Fred a[10];               // ERROR: Fred doesn't have a default constructor
      Fred* p = new Fred[10];   // ERROR: Fred doesn't have a default constructor
    }

However if you are creating an STL vector<Fred> rather than an array of Fred (which you probably should be doing anyway since arrays are evil), you don't have to have a default constructor in class Fred, since you can give the vector a Fred object to be used to initialize the elements:

    #include <vector>
    using namespace std;
    
    main()
    {
      vector<Fred> a(10, Fred(5,7));
      // The 10 Fred objects in vector a will be initialized with Fred(5,7).
      // ...
    }

[ Top | Bottom | Previous section | Next section ]

    class Point {
    public:
      Point(float x, float y);     // Rectangular coordinates
      Point(float r, float a);     // Polar coordinates (radius and angle)
      // ERROR: Overload is Ambiguous: Point::Point(float,float)
    };
    
    main()
    {
      Point p = Point(5.7, 1.2);   // Ambiguous: Which coordinate system?
    }

One way to solve this ambiguity is to use the Named Constructor Idiom:

    #include <math.h>              // To get sin() and cos()
    
    class Point {
    public:
      static Point rectangular(float x, float y);      // Rectangular coord's
      static Point polar(float radius, float angle);   // Polar coordinates
      // These static methods are the so-called "named constructors"
      // ...
    private:
      Point(float x, float y);     // Rectangular coordinates
      float x_, y_;
    };
    
    inline Point::Point(float x, float y)
    : x_(x), y_(y) { }
    
    inline Point Point::rectangular(float x, float y)
    { return Point(x, y); }
    
    inline Point Point::polar(float radius, float angle)
    { return Point(radius*cos(angle), radius*sin(angle)); }

Now the users of Point have a clear and unambiguous syntax for creating Points in either coordinate system:

    main()
    {
      Point p1 = Point::rectangular(5.7, 1.2);   // Obviously rectangular
      Point p2 = Point::polar(5.7, 1.2);         // Obviously polar
    }

Make sure your constructors are in the protected: section if you expect Fred to have derived classes.

The Named Constructor Idiom can also be used to make sure your objects are always created via new.

[ Top | Bottom | Previous section | Next section ]

    class Fred {
    public:
      Fred();
      // ...
    private:
      int i_;
      static int j_;
    };

Fred.cpp (or Fred.C or whatever):

    Fred::Fred()
      : i_(10)  // OK: you can (and should) initialize member data this way
        j_(42)  // Error: you cannot initialize static member data like this
    {
      // ...
    }
    
    // You must define static data members this way:
    int Fred::j_ = 42;

[ Top | Bottom | Previous section | Next section ]

    // Fred.h
    
    class Fred {
    public:
      // ...
    private:
      static int j_;   // Declares static data member Fred::j_
      // ...
    };

The linker will holler at you ("Fred::j_ is not defined") unless you define (as opposed to merely declare) Fred::j_ in (exactly) one of your source files:

    // Fred.cpp
    
    #include "Fred.h"
    
    int Fred::j_ = some_expression_evaluating_to_an_int;
    
    // Alternatively, if you wish to use the implicit 0 value for static ints:
    // int Fred::j_;

The usual place to define static data members of class Fred is file Fred.cpp (or Fred.C or whatever source file extension you use).

[ Top | Bottom | Previous section | Next section ]

[ C++ FAQ Lite | Table of contents | Subject index | About the author | © | Download your own copy ]
Revised Jan 1, 1997