Class class_example

test_files/classes.cpp:22–145

@brief an example class that demonstrates what Hyde documents. @hyde-owner fosterbrereton

/// @brief an example class that demonstrates what Hyde documents.
/// @hyde-owner fosterbrereton
class class_example {
public:
    /// Note that nested classes will not inherit their ownership from
    /// the class that contains them, so thus need their own `hyde-owner`.
    /// @brief an example enumeration within the class.
    /// @hyde-owner sean-parent
    enum class color {
        /// this is an example description for the `red` value.
        red,
        /// this is an example description for the `green` value.
        green = 42,
        /// this is an example description for the `blue` value.
        blue
    };

    /// Note that nested classes will not inherit their ownership from
    /// the class that contains them, so thus need their own `hyde-owner`.
    /// @brief a class definition contained within `example_class`.
    /// @hyde-owner sean-parent
    struct nested_class_example {
        /// member field `_x` within the nested class example.
        int _x{0};

        /// member field `_y` within the nested class example.
        int _y;
    };


    /// a nested `typedef` expression.
    typedef std::string typedef_example;

    /// a nested `using` expression.
    using using_example = std::string;


    /// default constructor.
    class_example() = default;

    /// an explicit constructor that takes a single `int`.
    /// @param x The one integer parameter this routine takes
    explicit class_example(int x) : _x(x) {}


    /// member function with a trailing return type.
    /// @return "`_x`"
    auto member_function_trailing_return_type() const -> int { return _x; }

    /// example member function.
    /// @return double the value of `_x`.
    auto member_function() { return _x *= 2; }


    /// an overloaded member function that takes one parameter.
    /// @brief A series of overloaded functions.
    /// @param first the first parameter of the first overload.
    void overloaded(const std::string& first);

    /// an overloaded member function that takes two parameters.