Закрытое наследование или Композиция

#ifndef DEFINE_LEX_STATE_MACHINE
#define DEFINE_LEX_STATE_MACHINE
 
#include <array>
 
namespace lex
{
    class StateMachine
    {
    protected:
        enum State
        {
            Start,  DigitDotExponent, DigitExponent, DigitOperation,
            DigitA, DigitB,           DigitAlpha,    Skip,
            Number, Name,             Operation,     Fail
        };
 
        State currentState_;
 
    private:
        class Event
        {
        public:
            enum Type
            {
                Digit,     Dot,   Exponent, PlusMinus,
                Separator, Alpha, NoMatch
            };
 
            Event(wchar_t);
 
            wchar_t GetSymbol() const;    
            bool operator==(Type) const;
 
            wchar_t symbol_;
            Type type_;
        };
 
        struct Transition
        {
            State from_;
            Event::Type event_;
            State to_;
 
            Transition(State, Event::Type, State);
        };
 
        std::array<Transition, 72> transitionTable;
 
    public:
        StateMachine();
        void PostSymbol(wchar_t);
    };
 
    inline StateMachine::Transition::Transition(
        State f, Event::Type e, State t) : from_{f}, event_{e}, to_{t} {}
 
    inline wchar_t StateMachine::Event::GetSymbol() const
    {
        return symbol_;
    }
 
    inline bool StateMachine::Event::operator==(Type t) const
    {
        return type_ == t;
    }
}
 
#endif // DEFINE_LEX_STATE_MACHINE

#ifndef DEFINE_LEX_EXPRESSION
#define DEFINE_LEX_EXPRESSION
 
#include <vector>
#include <string>
 
#include "StateMachine.h"
#include "Lexeme.h"
 
namespace lex
{
    class Expression : private StateMachine
    {
    private:
        using ExpressionT = std::vector<Lexeme>;
 
        ExpressionT expression;
        ExpressionT::size_type position{};
 
    public:
        Expression() = default;
        Expression(std::wstring);
 
        void Initialize(std::wstring);
 
        Lexeme & operator[](std::size_t);
        Lexeme const & operator[](std::size_t) const;
    };
}
 
#endif // DEFINE_LEX_EXPRESSION