• Home
• Syllabus
• Schedule
• Checkin
• Homework
  • HW0
  • HW1
  • HW2
  • HW3
  • HW4
  • HW5
  • HW6
  • HW7
  • HW8
• Examples
• Piazza
• Slides
• Other Info

See this page as a slide show

CS253 Constructors

Big Picture

• Every class has:
  • a default (zero-argument) ctor
  • a copy ctor
  • an assignment operator (not a ctor)
• If you don’t write those, the compiler writes default versions that do member-wise (not bit-wise) copy for you.
• However, if you write any ctor, then the compiler will not provide any other ctors.

(The compiler also provides a move ctor, a move assignment operator, and a dtor, but we’re not ready to talk about those.)

Member Initialization

• Member variables often require initialization.
• There are several ways to do it.

The Old Way

class Name {
    string first, last;
  public:
    Name() { first="John"; last="Doe"; }
    Name(string f) { first=f; last="Doe"; }
    Name(string f, string l) { first=f; last=l; }
    string full() const { return first + " " + last; }
};

Name a, b("Beyoncé"), c("Barack", "Obama");
cout << a.full() << '\n' << b.full() << '\n'
     << c.full() << '\n';

John Doe
Beyoncé Doe
Barack Obama

• Just horrible: repetitious and inefficient.
• b.first gets initialized to "", and then assigned "Beyoncé".

Member Initialization

Member initialization:

class Name {
    string first, last;
  public:
    Name() : first("John"), last("Doe") { }
    Name(string f) : first(f), last("Doe") { }
    Name(string f, string l) : first(f), last(l) { }
    string full() const { return first + " " + last; }
};

Name a, b("Beyoncé"), c("Barack", "Obama");
cout << a.full() << '\n' << b.full() << '\n'
     << c.full() << '\n';

John Doe
Beyoncé Doe
Barack Obama

• This is better, but we’re still repeating ourselves. DRY!
• The ctors should invoke each other.

Constructor Delegation

BAD!

class Name {
    string first, last;
  public:
    Name() { Name("John"); } // ☠ ☠ ☠
    Name(string f) { Name(f, "Doe"); } // ☠ ☠ ☠
    Name(string f, string l) : first(f), last(l) { }
    string full() const { return first + " " + last; }
};

Name a, b("Beyoncé"), c("Barack", "Obama");
cout << a.full() << '\n' << b.full() << '\n'
     << c.full() << '\n';

 
 
Barack Obama

Delegation

Good:

class Name {
    string first, last;
  public:
    Name() : Name("John") { }
    Name(string f) : Name(f, "Doe") {}
    Name(string f, string l) : first(f), last(l) { }
    string full() const { return first + " " + last; }
};

Name a, b("Beyoncé"), c("Barack", "Obama");
cout << a.full() << '\n' << b.full() << '\n'
     << c.full() << '\n';

John Doe
Beyoncé Doe
Barack Obama

Holy smokes—it’s the same syntax as member initialization!

Details

• When should you use member initialization?
  • When you have a non-default initial value for your variable.
  • When you want to emphasize the default initial value.
  • When the member variable is expensive to construct, and you have a non-default initial value to put in it.
• When must you use member initialization?
  • When the member variable is only initializable, and not assignable:
    • a const variable
    • a reference variable
    • an object without a default constructor
    • initializing a base class
• Member variables are constructed in declaration order, not member initialization list order.

Default member initialization

Sometimes, this is the best technique:

class Name {
    string first = "John", last = "Doe";
  public:
    Name() { }
    Name(string f) : first(f) {}
    Name(string f, string l) : first(f), last(l) { }
    string full() const { return first + " " + last; }
};

Name a, b("Beyoncé"), c("Barack", "Obama");
cout << a.full() << '\n' << b.full() << '\n'
     << c.full() << '\n';

John Doe
Beyoncé Doe
Barack Obama

There are no assignments here—it’s all initialization. b.first does not start as "John" and then get overwritten to "Beyoncé". And we didn’t repeat ourselves.

Loud.h

% cat ~cs253/Examples/Loud.h
// A “Loud” class.  It announces whenever its methods are called.
#ifndef LOUD_H_INCLUDED
#define LOUD_H_INCLUDED

#include <iostream>

class Loud {
    char c;
    void hi(const char *s) const {
	std::cout << "Loud::" << s;
	if (c) std::cout << " [c='" << c << "']";
	std::cout << std::endl;  // flush debug output
    }
  public:
    Loud(char ch = '\0') : c(ch) { hi("Loud()"); }
    ~Loud() { hi("~Loud()"); }
    Loud(const Loud &l) : c(l.c) { hi("Loud(const Loud &)"); }
    Loud(Loud &&l) : c(l.c) { hi("Loud(Loud &&)"); }
    Loud& operator=(const Loud &l) { c=l.c; hi("operator=(const Loud &)"); return *this; }
    Loud& operator=(Loud &&l) { c=l.c; hi("operator=(Loud &&)"); return *this; }
    Loud& operator=(char ch) { c = ch; hi("operator=(char)"); return *this; }
    Loud& operator++() { ++c; hi("operator++()"); return *this; }
    Loud operator++(int) { hi("operator++(int)"); const auto save = *this; ++*this; return save; }
    Loud operator+(const Loud &l) const { hi("operator+(const Loud &)"); return Loud(c+l.c); }
};

#endif /* LOUD_H_INCLUDED */

Example

#include "Loud.h"

int main() {
    Loud a('x');
    Loud b(a);
    Loud c=a;
    Loud d();
    c = ++b;
}

Loud::Loud() [c='x']
Loud::Loud(const Loud &) [c='x']
Loud::Loud(const Loud &) [c='x']
Loud::operator++() [c='y']
Loud::operator=(const Loud &) [c='y']
Loud::~Loud() [c='y']
Loud::~Loud() [c='y']
Loud::~Loud() [c='x']

Questions & Answers

• Why did Loud c=a call the copy ctor instead of the assignment operator?
  • Because it’s a ctor. It’s creating a Loud.
  • Yes, the syntax uses a =, but it’s a ctor.
    • Note that, if the ctor is explicit, then only the () form can be used. vector<int> v(3), not vector<int> v=3;.
• Why did Loud d() not do anything?
  • Because it’s a function declaration. It declares a function named d that takes no arguments, and returns a Loud.
  • If you want to create a Loud with no ctor arguments, just do this: Loud d;

User: Guest