1 UCPP-Doc Example

Any included entity can be referenced, like this example::print

Method ref to class member: x.method().method()

1.1 Example code-blocks

Extracted from second_example.hpp

// Let:
example::My_type & x = ...;

example::My_type* rt = &x.method<43>();
rt->method<43>().method<43>()
        .method<43>();
auto y = example::MyEnum::a;
return rt;

1.2 Complete files:

#include <example.hpp>

MY_MACRO(x)

#define MY_MACRO(x) (x*x)

some macro

int MY_global_func(const char* xy)

Attributes

• C-Linkage

• DLL-Exported

brief description

another paragraph with multiple lines

Parameters:

xy – The documentation for ARG xy

Precondition:

Some precondition

struct MY_c_style_struct

Attributes

• POD

• Semi-Regular

• Typedef-Struct

public:

int x

comment

float y

union [anonymous] u

public:

int a

float b

using MY_opaque_handle = struct MY_opaque_handle

Attributes

• Opaque-Handle

• Typedef-Struct

void MY_global_func_2(MY_c_style_struct*)

Attributes

• C-Linkage

namespace example

template<typename T>
concept Addable

Requirements

• std::regular<T>

Let

T a

An lvalue

Requirements

• add(a, a), evaluates to a T&

• a.count(), evaluates to an integer type

An example concept

template<Addable T>
void concept_f1(T)

Requirements

• Addable<T>

template<typename T>
void concept_f(T)

template<typename T>
void concept_f(T)
requires is_meowable<T>

template<Meowable T>
void concept_f(T)
requires (sizeof(T) < 16)

Requirements

• Addable<T> [1]

• is_meowable<T> [2]

• Meowable<T> [3]

• sizeof(T) < 16 [3]

template<class T>
bool is_meowable = true

Attributes

• Constexpr

template<typename T>
concept Meowable

Requirements

• is_meowable<T>

template<typename T, typename U>
struct My_template

Attributes

• Hashable

• POD

• Semi-Regular

Requirements

• sizeof(T) < 8

using my_typedef = char

using

using my_typedef_2 = char

typedef

void trailing_comment_test()

trailing comment

int test_auto()

auto

int& test_auto_ref(int& i)

auto&

int test_auto_decltype(int& i)

decltype(auto)

int test_trailing_return(int i)

trailing return type

Meowable auto cat()

template<typename T>
using my_typedef_3 = const T

template-alias

enum MyEnumA

Deprecated

Long reason why one should not use MyEnumA

enumerator foo

enumerator bar

enum class MyEnum : int

enumerator a = 42

enumerator b

comment about b

enumerator c = 3

enumerator d

enumerator e

using MyEnumAlias = MyEnum

int f1() noexcept

int f1(float x) noexcept

int f1(const std::string& x) noexcept(sizeof(int) > 2)

int f1(float x, int y)

Attributes

• Constexpr [1,2]

Doc-String about f1 overload-set

with multiple

lines

2. Comment about the float-overload, specifically.

3. Additional text specific to string overload.

   Which can consist of multiple lines…

   • and also

   • other

   • lists

4. two parameters

   Multi-Part std-reference: std::partial_ordering::unordered

Parameters:

• x – X_DESCR [2,3,4]

• y – Y_DESCR [4]

Returns:

RET_DESCR [2,3,4]

Throws:

• B – only from f1(float) [2]

• C – thrown by all overloads [2,3,4]

• std::exception – only from f1(const std::string&) [3]

void f2(int)

void f2(float)

Overload with single comment

void f3(int)

void f3(float)

Overload with single comment

1. And some specific part on the first

template<typename ...Ts>
auto print(Ts&&... ts)

some std::printf()-like template

Template Parameters:

Ts – template parameter

Parameters:

ts – value parameter

Returns:

return value

TODO

something that still needs doing

another normal paragraph

with a large line break

indentation test

References to external projects: glfwInit(), std::string.

Inline non-C++ code #~~>x

Danger

Danger Danger Danger

This line should also be part of the previous command!

Danger

And this is a new one

#include <iostream>

int main() {
	std::cout << "Example\n";
	print(42.f);
}

See also

My_type, My_other_type, f3

class My_other_type

Attributes

• POD

• Regular

public:

friend bool operator==(const My_other_type& lhs, const My_other_type& rhs)

friend bool operator==(const My_other_type& lhs, int rhs)

Attributes

• Hidden-Friend

hidden friend (should be included in My_other_type)

1. hidden friend (should be included in My_other_type)

class My_type

Attributes

• Abstract

• Copyable

• Polymorphic

a class

method ref: x.method()

public:

My_type(int)

template<int N>
My_type& method()

Requirements

• N > 42

friend bool operator==(const My_type& lhs, const My_type& rhs)

Attributes

• Hidden-Friend

hidden friend (should be included in My_type)

protected:

virtual int foo() = 0

template<typename T>
class Class_template

Attributes

• Semi-Regular

• Standard-Layout

public:

Class_template() = default

~Class_template() noexcept(false)

template<typename U>
operator U()

Requirements

• sizeof(U) == sizeof(T)

void requires_test()

Requirements

• is_meowable<T>

class Moveonly

Attributes

• Move-only

• Standard-Layout

public:

Moveonly(const Moveonly&) = delete

Moveonly(Moveonly&&) = default

Attributes

• Constexpr [2]

Moveonly& operator=(const Moveonly&) = delete

Moveonly& operator=(Moveonly&&) = default

class Moveonly_sub : public Moveonly

Attributes

• Move-only

• Standard-Layout

struct S

Attributes

• Aggregate

• Hashable

• Regular

• Ordered (strong)

• Standard-Layout

struct example

public:

int x = 42

std::strong_ordering operator<=>(const S&) const = default

Attributes

• Constexpr

1.3 Functions (with all overloads)

void example::test(const int*)

void example::test(int*const)

void example::test(const int***)

void example::test(const int*const**)

Deprecated

reason [4]

1.4 Types

class example::My_sub_class final : public example::My_type

Attributes

• Copyable

• Polymorphic

1.5 Variables

template<auto X>
auto square = X * X

Attributes

• Constexpr

static_assert(square<0> == 0);
static_assert(square<1> == 1);
static_assert(square<2> == 4);
static_assert(square<3> == 9);

1.6 Macros

MACRO_CONSTANT

#define MACRO_CONSTANT 42

a simple macro constant

MORE_COMPLEX_MACRO(x, ...)

a more complex macro function