Mastering C++ Class Design: Best Practices and Common Pitfalls

Introduction

Designing a robust C++ class requires a set of disciplined practices that improve readability, safety, and performance. The following sections illustrate these practices using a simple complex class and a more involved String class.

Header Guard

Wrap the header file with an include guard to prevent multiple inclusion:

#ifndef __COMPLEX__
#define __COMPLEX__

class complex {
    // class definition
};

#endif

Encapsulate Data and Provide Accessors

Declare data members as private and expose read‑only access through public member functions:

#ifndef __COMPLEX__
#define __COMPLEX__

class complex {
public:
    double real() const { return re; }
    double imag() const { return im; }
private:
    double re, im;
};

#endif

Const‑Correctness

Mark member functions that do not modify the object as const. This lets the compiler enforce immutability and signals intent to readers.

Constructor Initializer List

Initialize members directly in the constructor’s initializer list; this performs true initialization rather than assignment inside the body:

class complex {
public:
    complex(double r = 0, double i = 0) : re(r), im(i) {}
private:
    double re, im;
};

Reference‑to‑Const Parameters

Pass objects by const reference to avoid unnecessary copying while guaranteeing the argument will not be modified:

complex& operator+=(const complex& rhs) {
    re += rhs.re;
    im += rhs.im;
    return *this;
}

Even for built‑in types, using a reference is acceptable for consistency, though passing a char by value is usually cheaper.

Operator Overloading

Implement operator+= to return a reference, enabling chained assignments like c3 += c2 += c1;. For operator+, return a new temporary object because the result does not exist beforehand:

inline complex& operator+=(const complex& r) {
    re += r.re;
    im += r.im;
    return *this;
}

inline complex operator+(const complex& x, const complex& y) {
    return complex(x.re + y.re, x.im + y.im);
}

Multiple Overloads

Provide overloads to support operations with both another complex and a scalar:

inline complex operator+(const complex& x, const complex& y) { /* ... */ }
inline complex operator+(const complex& x, double y) { return complex(x.re + y, x.im); }
inline complex operator+(double x, const complex& y) { return complex(x + y.re, y.im); }

Interface Placement

Place the public interface at the top of the class declaration so users can see the API immediately.

Static Members

Use static for data that is shared across all instances (e.g., a bank interest rate). Static member functions lack a this pointer and can only access static data.

class Bank {
public:
    static double getInterestRate();
private:
    static double interestRate; // definition outside the class
};

double Bank::interestRate = 0.05;

The Big Three (Copy Control)

When a class owns a pointer, explicitly define a destructor, copy constructor, and copy‑assignment operator to manage deep copies and avoid memory leaks.

Destructor

inline String::~String() {
    delete[] m_data;
}

Copy‑Assignment Operator

inline String& String::operator=(const String& str) {
    if (this == &str) return *this; // self‑assignment guard
    delete[] m_data;
    m_data = new char[strlen(str.m_data) + 1];
    strcpy(m_data, str.m_data);
    return *this;
}

Copy Constructor

inline String::String(const String& str) {
    m_data = new char[strlen(str.m_data) + 1];
    strcpy(m_data, str.m_data);
}

These implementations perform a deep copy of the underlying character buffer, preventing dangling pointers after the source object is destroyed.

Singleton Patterns

Two classic singleton implementations are shown:

Eager ("hungry") singleton : a static instance is created at program start.

Lazy singleton : the static instance is created on first call to getInstance().

// Eager singleton
class A {
public:
    static A& getInstance();
private:
    static A a; // defined outside the class
};

// Lazy singleton
class A {
public:
    static A& getInstance();
private:
    A();
};

A& A::getInstance() {
    static A a; // created on first call
    return a;
}

Conclusion

Applying these guidelines—header guards, encapsulation, const‑correctness, initializer lists, reference parameters, thoughtful operator overloading, proper static usage, and explicit copy control—leads to C++ classes that are safe, efficient, and easy to maintain.