1 UCPP-Doc Example

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

1.1 Example code-blocks

Extracted from second_example.hpp

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

example::my_typedef rt = x.method<43>();
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

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

int test_auto()

auto

int& test_auto_ref(int& i)

auto&

int test_auto_decltype(int& i)

decltype(auto)

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(float x) noexcept

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

int f1(float x, int y)

Attributes

• Constexpr [1]

Doc-String about f1 overload-set

with multiple

lines

1. Comment about the float-overload, specifically.

3. two parameters

Parameters:

• x – X_DESCR

• y – Y_DESCR [3]

Returns:

RET_DESCR

Throws:

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

• C – thrown by all overloads

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

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

some template

Template Parameters:

Ts – template parameter

Parameters:

ts – value parameter

Returns:

return value

TODO

something that still needs doing

another normal paragraph

indentation test

A reference to an external project glfwInit()

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

class My_type

Attributes

• Abstract

• Copyable

• Polymorphic

a class

public:

My_type(int)

template<int N>
my_typedef method()

Requirements

• N > 42

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

• Aggregate

• 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

• Polymorphic

• Semi-Regular

protected:

int foo() override

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