types

Definition

Contains types definitions.

Classes
class	xtd::date_time
	Represents an instant in time, typically expressed as a date and time of day. More...
struct	xtd::enum_object< enum_t >
	Provides the base class for enumerations. More...
struct	xtd::formatter< type_t >
	Provides the base class to format any object. More...
class	xtd::reference_wrapper_object< type_t >
	The xtd::reference_wrapper_object is a reference wrapper as std::reference_wrapper. More...
class	xtd::type_object
	Represents type declarations: class types, interface types, array types, value types, enumeration types, type parameters, generic type definitions, and open or closed constructed generic types. More...

Typedefs
using	xtd::null_opt
	Represents the null_opt alias on std::nullopt_t.
using	xtd::null_ptr
	Represents the null_opt alias on std::nullptr_t.
template<class type_t>
using	xtd::optional
	Represents the null_opt alias on std::nullopt_t.

Variables
const intptr	xtd::invalid_handle
	Represents an invalid native operating system handle. This field is read-only.
null_ptr	xtd::null
	Represents a null pointer value.
constexpr null_opt	xtd::nullopt
	Represents a nullopt value. Used to indicate that an std::optional does not contain a value.

Native types
using	xtd::boolean
	Represents a boolean.
using	xtd::byte
	Represents a 8-bit unsigned integer.
using	xtd::char_
	Represents a character.
using	xtd::char16
	Represents a 16-bit unicode character.
using	xtd::char32
	Represents a 32-bit unicode character.
using	xtd::char8
	Represents a 8-bit unicode character.
using	xtd::decimal
	Represents a decimal-precision floating-point number.
using	xtd::double_
	Represents a double-precision floating-point number.
using	xtd::int16
	Represents a 16-bit signed integer.
using	xtd::int32
	Represents a 32-bit signed integer.
using	xtd::int64
	Represents a 64-bit signed integer.
using	xtd::intptr
	Represent a pointer or a handle.
template<class type_t>
using	xtd::ptr
	The xtd::ptr object is a shared pointer.
using	xtd::ptrdiff
	Represent the signed integer type of the result of subtracting two pointers.
template<class type_t>
using	xtd::ref
	The xtd::ref object is a reference wrapper.
using	xtd::sbyte
	Represents a 8-bit signed integer.
using	xtd::single
	Represents a single-precision floating-point number.
using	xtd::size
	Represents a size of any object in bytes.
using	xtd::slong
	Represents a 32-bit or 64-bit signed integer.
template<class type_t>
using	xtd::sptr
	The xtd::sptr object is a shared pointer.
using	xtd::type
	Stores information about a type.
using	xtd::uint16
	Represents a 16-bit unsigned integer.
using	xtd::uint32
	Represents a 32-bit unsigned integer.
using	xtd::uint64
	Represents a 64-bit unsigned integer.
using	xtd::uintptr
	Represent a pointer or a handle.
using	xtd::ulong
	Represents a 32-bit or 64-bit unsigned integer.
template<class type_t>
using	xtd::uptr
	The xtd::uptr object is a unique pointer.
using	xtd::wchar
	Represents a wide character.
template<class type_t>
using	xtd::wptr
	The xtd::uptr object is a weak pointer.
template<class type_t>
const reference_wrapper_object< type_t >	xtd::reference_wrapper_object< type_t >::empty

Boxed types
using	xtd::byte_object
	Represent a boxed byte.
using	xtd::char16_object
	Represent a boxed char16.
using	xtd::char32_object
	Represent a boxed char32.
using	xtd::char8_object
	Represent a boxed char8.
using	xtd::char_object
	Represent a boxed char.
using	xtd::decimal_object
	Represent a boxed decimal.
using	xtd::double_object
	Represent a boxed double.
using	xtd::int16_object
	Represent a boxed int16.
using	xtd::int32_object
	Represent a boxed int32.
using	xtd::int64_object
	Represent a boxed int64.
using	xtd::intptr_object
	Represent a boxed intptr.
using	xtd::ptrdiff_object
	Represent a boxed intptr.
using	xtd::sbyte_object
	Represent a boxed sbyte.
using	xtd::single_object
	Represent a boxed single.
using	xtd::slong_object
	Represent a boxed int16.
using	xtd::tick
	Represents a tick (1 tick = 100 nanoseconds).
using	xtd::ticks
	Represents a tick duration.
using	xtd::uint16_object
	Represent a boxed uint16.
using	xtd::uint32_object
	Represent a boxed uint32.
using	xtd::uint64_object
	Represent a boxed uint64.
using	xtd::uintptr_object
	Represent a boxed uintptr.
using	xtd::ulong_object
	Represent a boxed ulong.
using	xtd::wchar_object
	Represent a boxed wchar.

Typedef Documentation

boolean

using xtd::boolean

#include <xtd.core/include/xtd/boolean.hpp>

Represents a boolean.

Header

#include <xtd/boolean>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

byte

using xtd::byte

#include <xtd.core/include/xtd/byte.hpp>

Represents a 8-bit unsigned integer.

Header

#include <xtd/byte>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

byte_object

using xtd::byte_object

#include <xtd.core/include/xtd/byte_object.hpp>

Represent a boxed byte.

Header

#include <xtd/byte_object>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

Examples

The following example shows how to create and use xtd::byte_object.

auto stringer = [](const object& value) {return value.to_string();};
xtd::byte unboxed_object = 42;
byte_object boxed_object = unboxed_object;
auto result = stringer(boxed_object);
console::write_line("result = {}", result); // Display: result = 42;

char_

using xtd::char_

#include <xtd.core/include/xtd/char.hpp>

Represents a character.

Header

#include <xtd/char>

Namespace

xtd

Library

xtd.core

Remarks

Represents a 32-bit unicode character on Linux and many other non-Windows systems, but a 16-bit unicode character on Windows.

For more information about types, see Native types, boxing and unboxing.

char16

using xtd::char16

#include <xtd.core/include/xtd/char16.hpp>

Represents a 16-bit unicode character.

Header

#include <xtd/char16>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

char16_object

using xtd::char16_object

#include <xtd.core/include/xtd/char16_object.hpp>

Represent a boxed char16.

Header

#include <xtd/char16_object>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

Examples

The following example shows how to create and use xtd::char16_object.

auto stringer = [](const object& value) {return value.to_string();};
char16 unboxed_object = u'a';
char16_object boxed_object = unboxed_object;
auto result = stringer(boxed_object);
console::write_line("result = {}", result); // Display: result = a;

char32

using xtd::char32

#include <xtd.core/include/xtd/char32.hpp>

Represents a 32-bit unicode character.

Header

#include <xtd/char32>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

char32_object

using xtd::char32_object

#include <xtd.core/include/xtd/char32_object.hpp>

Represent a boxed char32.

Header

#include <xtd/char32_object>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

Examples

The following example shows how to create and use xtd::char32_object.

auto stringer = [](const object& value) {return value.to_string();};
char32 unboxed_object = U'a';
char32_object boxed_object = unboxed_object;
auto result = stringer(boxed_object);
console::write_line("result = {}", result); // Display: result = a;

char8

using xtd::char8

#include <xtd.core/include/xtd/char8.hpp>

Represents a 8-bit unicode character.

Header

#include <xtd/char8>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

char8_object

using xtd::char8_object

#include <xtd.core/include/xtd/char8_object.hpp>

Represent a boxed char8.

Header

#include <xtd/char8_object>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

Examples

The following example shows how to create and use xtd::char8_object.

auto stringer = [](const object& value) {return value.to_string();};
char8 unboxed_object = u8'a';
char8_object boxed_object = unboxed_object;
auto result = stringer(boxed_object);
console::write_line("result = {}", result); // Display: result = a;

char_object

using xtd::char_object

#include <xtd.core/include/xtd/char_object.hpp>

Represent a boxed char.

Header

#include <xtd/char_object>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

Examples

The following example shows how to create and use xtd::char_object.

auto stringer = [](const object& value) {return value.to_string();};
char unboxed_object = 'a';
char_object boxed_object = unboxed_object;
auto result = stringer(boxed_object);
console::write_line("result = {}", result); // Display: result = a;

decimal

using xtd::decimal

#include <xtd.core/include/xtd/decimal.hpp>

Represents a decimal-precision floating-point number.

Header

#include <xtd/decimal>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

decimal_object

using xtd::decimal_object

#include <xtd.core/include/xtd/decimal_object.hpp>

Represent a boxed decimal.

Header

#include <xtd/decimal_object>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

Examples

The following example shows how to create and use xtd::double_object.

auto stringer = [](const object& value) {return value.to_string();};
decimal unboxed_object = 3.14;
decimal_object boxed_object = unboxed_object;
auto result = stringer(boxed_object);
console::write_line("result = {}", result); // Display: result = 3.14;

double_

using xtd::double_

#include <xtd.core/include/xtd/double.hpp>

Represents a double-precision floating-point number.

Header

#include <xtd/double>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

double_object

using xtd::double_object

#include <xtd.core/include/xtd/double_object.hpp>

Represent a boxed double.

Header

#include <xtd/double_object>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

Examples

The following example shows how to create and use xtd::double_object.

auto stringer = [](const object& value) {return value.to_string();};
double unboxed_object = 3.14;
double_object boxed_object = unboxed_object;
auto result = stringer(boxed_object);
console::write_line("result = {}", result); // Display: result = 3.14;

int16

using xtd::int16

#include <xtd.core/include/xtd/int16.hpp>

Represents a 16-bit signed integer.

Header

#include <xtd/int16>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

int16_object

using xtd::int16_object

#include <xtd.core/include/xtd/int16_object.hpp>

Represent a boxed int16.

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

Examples

The following example shows how to create and use xtd::int16_object.

auto stringer = [](const object& value) {return value.to_string();};
int16 unboxed_object = 42;
int16_object boxed_object = unboxed_object;
auto result = stringer(boxed_object);
console::write_line("result = {}", result); // Display: result = 42;

int32

using xtd::int32

#include <xtd.core/include/xtd/int32.hpp>

Represents a 32-bit signed integer.

Header

#include <xtd/int32>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

int32_object

using xtd::int32_object

#include <xtd.core/include/xtd/int32_object.hpp>

Represent a boxed int32.

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

Examples

The following example shows how to create and use xtd::int32_object.

auto stringer = [](const object& value) {return value.to_string();};
int32 unboxed_object = 42;
int32_object boxed_object = unboxed_object;
auto result = stringer(boxed_object);
console::write_line("result = {}", result); // Display: result = 42;

int64

using xtd::int64

#include <xtd.core/include/xtd/int64.hpp>

Represents a 64-bit signed integer.

Header

#include <xtd/int64>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

int64_object

using xtd::int64_object

#include <xtd.core/include/xtd/int64_object.hpp>

Represent a boxed int64.

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

Examples

The following example shows how to create and use xtd::int64_object.

auto stringer = [](const object& value) {return value.to_string();};
int64 unboxed_object = 42;
int64_object boxed_object = unboxed_object;
auto result = stringer(boxed_object);
console::write_line("result = {}", result); // Display: result = 42;

intptr

using xtd::intptr

#include <xtd.core/include/xtd/intptr.hpp>

Represent a pointer or a handle.

Header

#include <xtd/intptr>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

intptr_object

using xtd::intptr_object

#include <xtd.core/include/xtd/intptr_object.hpp>

Represent a boxed intptr.

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

Examples

The following example shows how to create and use xtd::intptr_object.

auto stringer = [](const object& value) {return value.to_string();};
intptr unboxed_object = 42;
intptr_object boxed_object = unboxed_object;
auto result = stringer(boxed_object);
console::write_line("result = {}", result); // Display: result = 42;

null_opt

using xtd::null_opt

#include <xtd.core/include/xtd/null_opt.hpp>

Represents the null_opt alias on std::nullopt_t.

Header

#include <xtd/null_opt>

Namespace

xtd

Library

xtd.core

null_ptr

using xtd::null_ptr

#include <xtd.core/include/xtd/null_ptr.hpp>

Represents the null_opt alias on std::nullptr_t.

Header

#include <xtd/null_opt>

Namespace

xtd

Library

xtd.core

optional

template<class type_t>

using xtd::optional

#include <xtd.core/include/xtd/optional.hpp>

Represents the null_opt alias on std::nullopt_t.

Header

#include <xtd/null_opt>

Namespace

xtd

Library

xtd.core

ptr

template<class type_t>

using xtd::ptr

#include <xtd.core/include/xtd/ptr.hpp>

The xtd::ptr object is a shared pointer.

Library

xtd.core

Examples

this is example shows to use xtd::new_ with xtd::version class

ptr<xtd::version> version = new_ptr<xtd::version>(1, 2, 3);
 
console::write_line("version = {}", version->to_string());
delete_ptr(version); // Not mandatory.

ptrdiff

using xtd::ptrdiff

#include <xtd.core/include/xtd/ptrdiff.hpp>

Represent the signed integer type of the result of subtracting two pointers.

Header

#include <xtd/ptrdiff>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

ptrdiff_object

using xtd::ptrdiff_object

#include <xtd.core/include/xtd/ptrdiff_object.hpp>

Represent a boxed intptr.

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

Examples

The following example shows how to create and use xtd::intptr_object.

auto stringer = [](const object& value) {return value.to_string();};
intptr unboxed_object = 42;
intptr_object boxed_object = unboxed_object;
auto result = stringer(boxed_object);
console::write_line("result = {}", result); // Display: result = 42;

ref

template<class type_t>

using xtd::ref

#include <xtd.core/include/xtd/ref.hpp>

The xtd::ref object is a reference wrapper.

Library

xtd.core

Examples

This example shows to use xtd::ref with xtd::version class

version ver = version {1, 2, 3};
ref<version> ver_ref = create_ref(ver);
 
console::write_line("version = {}", ver_ref.to_string());

sbyte

using xtd::sbyte

#include <xtd.core/include/xtd/sbyte.hpp>

Represents a 8-bit signed integer.

Header

#include <xtd/sbyte>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

sbyte_object

using xtd::sbyte_object

#include <xtd.core/include/xtd/sbyte_object.hpp>

Represent a boxed sbyte.

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

Examples

The following example shows how to create and use xtd::sbyte_object.

auto stringer = [](const object& value) {return value.to_string();};
sbyte unboxed_object = 42;
sbyte_object boxed_object = unboxed_object;
auto result = stringer(boxed_object);
console::write_line("result = {}", result); // Display: result = 42;

single

using xtd::single

#include <xtd.core/include/xtd/single.hpp>

Represents a single-precision floating-point number.

Header

#include <xtd/single>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

single_object

using xtd::single_object

#include <xtd.core/include/xtd/single_object.hpp>

Represent a boxed single.

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

Examples

The following example shows how to create and use xtd::single_object.

auto stringer = [](const object& value) {return value.to_string();};
float unboxed_object = 3.14f;
single_object boxed_object = unboxed_object;
auto result = stringer(boxed_object);
console::write_line("result = {}", result); // Display: result = 3.14;

size

size_type xtd::size

constexprnoexcept

#include <xtd.core/include/xtd/size.hpp>

Represents a size of any object in bytes.

Returns the number of elements.

Header

#include <xtd/size>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

Returns

The number of elements in the read_only_span.

Examples

any.cpp, and any_info.cpp.

slong

using xtd::slong

#include <xtd.core/include/xtd/slong.hpp>

Represents a 32-bit or 64-bit signed integer.

Header

#include <xtd/slong>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

slong_object

using xtd::slong_object

#include <xtd.core/include/xtd/slong_object.hpp>

Represent a boxed int16.

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

Examples

The following example shows how to create and use xtd:slong_object.

auto stringer = [](const object& value) {return value.to_string();};
slong unboxed_object = 42;
slong_object boxed_object = unboxed_object;
auto result = stringer(boxed_object);
console::write_line("result = {}", result); // Display: result = 42;

sptr

template<class type_t>

using xtd::sptr

#include <xtd.core/include/xtd/sptr.hpp>

The xtd::sptr object is a shared pointer.

Library

xtd.core

Examples

This example shows to use xtd::sptr with xtd::version class

sptr<xtd::version> version = new_sptr<xtd::version>(1, 2, 3);
 
console::write_line("version = {}", version->to_string());
delete_ptr(version); // Not mandatory.

tick

using xtd::tick

#include <xtd.core/include/xtd/tick.hpp>

Represents a tick (1 tick = 100 nanoseconds).

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

ticks

using xtd::ticks

#include <xtd.core/include/xtd/ticks.hpp>

Represents a tick duration.

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

type

using xtd::type

#include <xtd.core/include/xtd/type.hpp>

Stores information about a type.

Header

#include <xtd/type>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

uint16

using xtd::uint16

#include <xtd.core/include/xtd/uint16.hpp>

Represents a 16-bit unsigned integer.

Header

#include <xtd/uint16>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

uint16_object

using xtd::uint16_object

#include <xtd.core/include/xtd/uint16_object.hpp>

Represent a boxed uint16.

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

Examples

The following example shows how to create and use xtd::uint16_object.

auto stringer = [](const object& value) {return value.to_string();};
uint16 unboxed_object = 42;
uint16_object boxed_object = unboxed_object;
auto result = stringer(boxed_object);
console::write_line("result = {}", result); // Display: result = 42;

uint32

using xtd::uint32

#include <xtd.core/include/xtd/uint32.hpp>

Represents a 32-bit unsigned integer.

Header

#include <xtd/uint32>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

uint32_object

using xtd::uint32_object

#include <xtd.core/include/xtd/uint32_object.hpp>

Represent a boxed uint32.

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

Examples

The following example shows how to create and use xtd::uint32_object.

auto stringer = [](const object& value) {return value.to_string();};
uint32 unboxed_object = 42;
uint32_object boxed_object = unboxed_object;
auto result = stringer(boxed_object);
console::write_line("result = {}", result); // Display: result = 42;

uint64

using xtd::uint64

#include <xtd.core/include/xtd/uint64.hpp>

Represents a 64-bit unsigned integer.

Header

#include <xtd/uint64>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

uint64_object

using xtd::uint64_object

#include <xtd.core/include/xtd/uint64_object.hpp>

Represent a boxed uint64.

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

Examples

The following example shows how to create and use xtd::uint64_object.

auto stringer = [](const object& value) {return value.to_string();};
uint64 unboxed_object = 42;
uint64_object boxed_object = unboxed_object;
auto result = stringer(boxed_object);
console::write_line("result = {}", result); // Display: result = 42;

uintptr

using xtd::uintptr

#include <xtd.core/include/xtd/uintptr.hpp>

Represent a pointer or a handle.

Header

#include <xtd/uintptr>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

uintptr_object

using xtd::uintptr_object

#include <xtd.core/include/xtd/uintptr_object.hpp>

Represent a boxed uintptr.

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

Examples

The following example shows how to create and use xtd::uintptr_object.

auto stringer = [](const object& value) {return value.to_string();};
uintptr unboxed_object = 42;
uintptr_object boxed_object = unboxed_object;
auto result = stringer(boxed_object);
console::write_line("result = {}", result); // Display: result = 42;

ulong

using xtd::ulong

#include <xtd.core/include/xtd/ulong.hpp>

Represents a 32-bit or 64-bit unsigned integer.

Header

#include <xtd/ulong>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

ulong_object

using xtd::ulong_object

#include <xtd.core/include/xtd/ulong_object.hpp>

Represent a boxed ulong.

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

Examples

The following example shows how to create and use xtd::ulong_object.

auto stringer = [](const object& value) {return value.to_string();};
ulong unboxed_object = 42;
ulong_object boxed_object = unboxed_object;
auto result = stringer(boxed_object);
console::write_line("result = {}", result); // Display: result = 42;

uptr

template<class type_t>

using xtd::uptr

#include <xtd.core/include/xtd/uptr.hpp>

The xtd::uptr object is a unique pointer.

Library

xtd.core

Examples

This example shows to use xtd::uptr with xtd::version class

uptr<xtd::version> version = newu_uptr<xtd::version>(1, 2, 3);
 
console::write_line("version = {}", version->to_string());
delete_ptr(version); // Not mandatory.

wchar

using xtd::wchar

#include <xtd.core/include/xtd/wchar.hpp>

Represents a wide character.

Header

#include <xtd/wchar>

Namespace

xtd

Library

xtd.core

Remarks

Represents a 32-bit unicode character on Linux and many other non-Windows systems, but a 16-bit unicode character on Windows.

For more information about types, see Native types, boxing and unboxing.

wchar_object

using xtd::wchar_object

#include <xtd.core/include/xtd/wchar_object.hpp>

Represent a boxed wchar.

Header

#include <xtd/wchar_object>

Namespace

xtd

Library

xtd.core

Remarks

For more information about types, see Native types, boxing and unboxing.

Examples

The following example shows how to create and use xtd::wchar_object.

auto stringer = [](const object& value) {return value.to_string();};
wchar unboxed_object = L'a';
wchar_object boxed_object = unboxed_object;
auto result = stringer(boxed_object);
console::write_line("result = {}", result); // Display: result = a;

wptr

template<class type_t>

using xtd::wptr

#include <xtd.core/include/xtd/wptr.hpp>

The xtd::uptr object is a weak pointer.

Library

xtd.core

Variable Documentation

invalid_handle

const intptr xtd::invalid_handle

extern

#include <xtd.core/include/xtd/invalid_handle.hpp>

Represents an invalid native operating system handle. This field is read-only.

Header

#include <xtd/invalid_handle>

Namespace

xtd

Library

xtd.core

null

null_ptr xtd::null

extern

#include <xtd.core/include/xtd/null.hpp>

Represents a null pointer value.

Header

#include <xtd/null>

Namespace

xtd

Library

xtd.core

Examples

xtd::uptr<foo_class> foo = xtd::new_uptr<foo_class>();
...
foo = null; // release the unique pointer.

nullopt

null_opt xtd::nullopt

constexpr

#include <xtd.core/include/xtd/nullopt.hpp>

Represents a nullopt value. Used to indicate that an std::optional does not contain a value.

Header

#include <xtd/nullopt>

Namespace

xtd

Library

xtd.core

Examples

std::optional<foo_class> foo = foo_class {};
...
foo = nullopt; // reset the optional foo variable.