The rule of three (also known as the Law of The Big Three or The Big Three) is a rule of thumb in C++ that claims that if a class defines one of the following it should probably explicitly define all three: Copy constructor, Copy assignment operator, Destructor
2. Example
class CDummy
{
public:
CDummy()
{m_intCount++; cout << "create" << endl;}
~CDummy()
{m_intCount--; cout << "destroy" << endl;}
static int m_intCount;
};
int CDummy::m_intCount = 0;
void foo(CDummy object)
{ /* Argument passed by value */ }
int main(void) Result:
{
CDummy obj; Create
cout << "Count = " << obj.m_intCount << endl; cnt = 1
foo(obj); destroy
cout << "Count = " << obj.m_intCount << endl; cnt = 0
foo(obj); destroy
cout << "Count = " << obj.m_intCount << endl; cnt = -1
return 0; destroy
}
08.02.2010 The Big Three 2
3. Special member functions
Special member functions in C++ are functions which the compiler will
automatically generate if they are used, but not declared explicitly by the
programmer. The special member functions are:
Default constructor (if no other constructor is explicitly declared)
Copy constructor
Copy assignment operator
Destructor
The rule of three (also known as the Law of The Big Three or The Big Three) is a
rule of thumb in C++ that claims that if a class defines one of the following it
should probably explicitly define all three:
Copy constructor
Copy assignment operator
Destructor
class CDefault
{
public:
CDefault(); // default constructor
CDefault(const CDefault& object); // copy constructor
virtual ~CDefault(); // default destructor
Cdefault& operator = (const CDefault& object); // copy assignment operator
};
08.02.2010 The Big Three 3
4. Overloaded member function
class CDummy
{
public:
CDummy(int p) : m_intValue(p) { cout << "create" << m_intValue << endl; }
virtual ~CDummy() { cout << "destroy" << endl; }
CDummy(const CDummy& object) {m_intValue = object.m_intValue;}
// polymorphic functions (different data types)
void overloaded(void) { cout << "overload " << ++m_intValue << endl; }
void overloaded(void) const { cout << "overload const " << m_intValue << endl; }
int m_intValue;
};
int main(void)
{
CDummy const dd(2);
dd.overloaded();
CDummy bb(3);
bb.overloaded();
Cdummy const obj(bb); // copy constructor can be without const
Cdummy cobj(obj); // copy constructor must be with const
}
08.02.2010 The Big Three 4
5. Default class declaration
class CDefault
{
public:
// default constructor
CDefault();
// copy constructor
CDefault(const CDefault& object);
// default destructor
~CDefault();
// copy assignment operator
CDefault& operator = (const CDefault& object);
// Optional
// Note: overloaded operator should be overloaded with const also
CDefault& operator*();
CDefault const& operator*() const;
CDefault* operator->();
CDefault const* operator->() const;
};
08.02.2010 The Big Three 5
6. References
Special member functions
Assignment operator in C++
Type polymorphism
08.02.2010 The Big Three 6