.CPP File Format – Classes

Declaration

class-specifier:
    class-head { [member-specification] }

class-head:
    class-key [attribute-specifier-seq] class-head-name [class-virt-specifier] [base-clause]
    class-key [attribute-specifier-seq] [base-clause]

class-key:  class | struct | union
class-virt-specifier:  final

struct and class are otherwise the same. A class declared final (C++11) cannot be a base class.

class Account {
public:
    explicit Account(int id) : id_(id) { }

    int balance() const { return balance_; }     // does not change the object
    void deposit(int amount);

    static int count();                          // no this pointer

private:
    int id_;
    int balance_ = 0;                            // default member initialiser (C++11)
    inline static int next_id_ = 1;              // inline static member (C++17)
};

void Account::deposit(int amount)                // defined outside the class
{
    balance_ += amount;
}

Members

class Box {
    std::string value_;
public:
    const std::string& get() const & { return value_; }
    std::string        get() &&      { return std::move(value_); }

    // C++23: one definition for every kind of object
    template<class Self>
    auto&& name(this Self&& self) { return std::forward<Self>(self).value_; }
};

Access control

Access is checked after name lookup and overload resolution [class.access], so a private overload can be chosen, and the call then fails. Access specifiers apply until the next one. Access applies to names, not to objects: a member function can use the private members of any object of the same class.

class Vec {
    int x_, y_;
    friend bool operator==(const Vec& a, const Vec& b)    // hidden friend
    {
        return a.x_ == b.x_ && a.y_ == b.y_;
    }
    friend class Serialiser;                              // a whole class
};

Special member functions

Six member functions are special, because the compiler can write them for you [special].

What you declare decides what the compiler declares for you. This table is for the usual cases; “deprecated” means the function is still generated, but relying on it is deprecated.

An implicit member is defined as deleted if it cannot be generated, for example when a member has no accessible copy constructor. A common guideline is the rule of zero: if a class’s members manage their own resources, declare none of these. The rule of five: if you declare any of the copy, move or destructor functions, declare all five.

= default asks for the compiler’s version, and = delete forbids a function and removes it from use [dcl.fct.def.default], [dcl.fct.def.delete]. Deleted functions still take part in overload resolution.

Constructors

ctor-initializer:   : mem-initializer-list
mem-initializer:    mem-initializer-id ( [expression-list] )
                    mem-initializer-id braced-init-list

A constructor has no return type and the same name as the class [class.ctor]. It cannot be virtual, static or const.

The order of initialisation is fixed [class.base.init], whatever order the member initialiser list uses:

1. Virtual base classes, in depth-first left-to-right order, and only by the most derived class.
2. Direct base classes, in the order of the base-clause.
3. Non-static data members, in declaration order.
4. The constructor body.

A member initialiser list takes priority over a default member initialiser for the same member.

class Buffer {
    std::size_t size_;
    char* data_;
public:
    explicit Buffer(std::size_t n)          // explicit: no implicit conversion
        : size_(n), data_(new char[n]) { }
    Buffer() : Buffer(1024) { }             // delegating constructor (C++11)

    Buffer(const Buffer& o)                 // copy
        : size_(o.size_), data_(new char[o.size_])
    { std::copy_n(o.data_, size_, data_); }

    Buffer(Buffer&& o) noexcept              // move: steals the pointer
        : size_(std::exchange(o.size_, 0)),
          data_(std::exchange(o.data_, nullptr)) { }

    ~Buffer() { delete[] data_; }
};

• A delegating constructor (C++11) names another constructor of the same class in its initialiser list, and has no other initialisers.
• using Base::Base; (C++11) inherits constructors [class.inhctor.init]. See Inheritance.
• A converting constructor takes one argument, and is usable for implicit conversion unless explicit [class.conv.ctor]. explicit(condition) (C++20) makes this conditional.
• A conversion function converts the other way: operator int() const; [class.conv.fct]. It can also be explicit.
• If a constructor throws, the fully built bases and members are destroyed; see Exceptions.

Widget make() { return Widget{}; }     // mandatory: no copy or move
Widget w = make();                     // constructs w directly

Widget named()
{
    Widget local;
    return local;                      // named return value: elision is allowed but optional
}

Destructors

A destructor has the form ~C(), takes no arguments and returns nothing [class.dtor]. It is implicitly noexcept unless declared otherwise or a base or member has a potentially-throwing destructor. Objects are destroyed in reverse order of construction: the body runs, then non-static data members in reverse order of declaration, then direct bases in reverse order, then virtual bases if this is the most derived class.

A destructor can be called explicitly: p->~C();. It is usually paired with placement new. Destroying a base class object through a base pointer needs a virtual destructor.

Operator overloading

An operator can be given a meaning for class or enumeration operands [over.oper]. It is defined as a function called operator followed by the symbol. The number of operands and the precedence are fixed.

• operator=, operator(), operator[] and operator-> must be non-static member functions, with exceptions in C++23 for operator() and operator[].
• Overloaded && and || evaluate both operands, so short-circuiting is lost [over.oper].
• operator++() is prefix; operator++(int) is postfix, and the int is a marker.
• operator[] takes any number of arguments since C++23: m[1, 2].
• operator() and operator[] may be static since C++23.
• operator new and operator delete can be overloaded as allocation functions; see Expressions.
• A literal operator is written operator""_suffix.

#include <compare>

struct Version {
    int major, minor, patch;
    auto operator<=>(const Version&) const = default;  // compares in member order
};

bool newer = Version{2, 1, 0} > Version{2, 0, 9};     // true