xtd 0.2.0
Loading...
Searching...
No Matches
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...
 
class  xtd::enum_object< enum_t >
 Provides the base class for enumerations. More...
 
class  xtd::enum_object< std::nullptr_t >
 Provides the base class for enumerations. 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::ulong = __ulong__
 Represents a 32-bit or 64-bit unsigned integer.
 

Variables

std::nullptr_t xtd::null
 Represents a null pointer value.
 

Native types

using xtd::bool_ = bool
 Represents a boolean.
 
using xtd::byte = uint_least8_t
 Represents a 8-bit unsigned integer.
 
using xtd::char_ = char
 Represents a character.
 
using xtd::char16 = char16_t
 Represents a 16-bit unicode character.
 
using xtd::char32 = char32_t
 Represents a 32-bit unicode character.
 
using xtd::decimal = long double
 Represents a decimal-precision floating-point number.
 
using xtd::double_ = double
 Represents a double-precision floating-point number.
 
using xtd::int16 = int_least16_t
 Represents a 16-bit signed integer.
 
using xtd::int32 = int_least32_t
 Represents a 32-bit signed integer.
 
using xtd::int64 = int_least64_t
 Represents a 64-bit signed integer.
 
using xtd::intptr = intmax_t
 Represent a pointer or a handle.
 
template<typename type_t >
using xtd::ptr = xtd::sptr< type_t >
 The xtd::ptr object is a shared pointer.
 
using xtd::ptrdiff = std::ptrdiff_t
 Represent the signed integer type of the result of subtracting two pointers.
 
using xtd::sbyte = int_least8_t
 Represents a 8-bit signed integer.
 
using xtd::single = float
 Represents a single-precision floating-point number.
 
using xtd::size = size_t
 Represents a size of any object in bytes.
 
using xtd::slong = __slong__
 Represents a 32-bit or 64-bit signed integer.
 
template<typename type_t >
using xtd::sptr = std::shared_ptr< type_t >
 The xtd::sptr object is a shared pointer.
 
using xtd::type = std::type_info
 Stores information about a type.
 
using xtd::uint16 = uint_least16_t
 Represents a 16-bit unsigned integer.
 
using xtd::uint32 = uint_least32_t
 Represents a 32-bit unsigned integer.
 
using xtd::uint64 = uint_least64_t
 Represents a 64-bit unsigned integer.
 
using xtd::uintptr = uintmax_t
 Represent a pointer or a handle.
 
template<typename type_t >
using xtd::uptr = std::unique_ptr< type_t >
 The xtd::uptr object is a unique pointer.
 
using xtd::wchar = wchar_t
 Represents a wide character.
 
template<typename type_t >
using xtd::wptr = std::weak_ptr< type_t >
 The xtd::uptr object is a weak pointer.
 

Boxed types

using xtd::byte_object = box_integer< xtd::byte >
 Represent a boxed byte.
 
using xtd::char16_object = box_char< char16 >
 Represent a boxed char16.
 
using xtd::char32_object = box_char< char32 >
 Represent a boxed char32.
 
using xtd::char_object = box_char< char >
 Represent a boxed char.
 
using xtd::decimal_object = box_floating_point< decimal >
 Represent a boxed decimal.
 
using xtd::double_object = box_floating_point< double >
 Represent a boxed double.
 
using xtd::int16_object = box_integer< int16 >
 Represent a boxed int16.
 
using xtd::int32_object = box_integer< int32 >
 Represent a boxed int32.
 
using xtd::int64_object = box_integer< int64 >
 Represent a boxed int64.
 
using xtd::intptr_object = box_integer< intptr >
 Represent a boxed intptr.
 
using xtd::ptrdiff_object = box_integer< ptrdiff >
 Represent a boxed intptr.
 
using xtd::sbyte_object = box_integer< sbyte >
 Represent a boxed sbyte.
 
using xtd::single_object = box_floating_point< float >
 Represent a boxed single.
 
using xtd::slong_object = box_integer< slong >
 Represent a boxed int16.
 
using xtd::tick = std::ratio< 1LL, 10000000LL >
 Represents a tick (1 tick = 100 nanoseconds).
 
using xtd::ticks = std::chrono::duration< int64, tick >
 Represents a tick duration.
 
using xtd::uint16_object = box_integer< uint16 >
 Represent a boxed uint16.
 
using xtd::uint32_object = box_integer< uint32 >
 Represent a boxed uint32.
 
using xtd::uint64_object = box_integer< uint64 >
 Represent a boxed uint64.
 
using xtd::uintptr_object = box_integer< uintptr >
 Represent a boxed uintptr.
 
using xtd::ulong_object = box_integer< ulong >
 Represent a boxed ulong.
 
using xtd::wchar_object = box_char< wchar >
 Represent a boxed wchar.
 

Typedef Documentation

◆ bool_

using xtd::bool_ = typedef bool

#include <xtd.core/include/xtd/bool.h>

Represents a boolean.

Header
#include <xtd/bool>
Namespace
xtd
Library
xtd.core
Remarks
For more information about types, see Native types, boxing and unboxing.

◆ byte

using xtd::byte = typedef uint_least8_t

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

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

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

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;
static void write_line()
Writes the current line terminator to the standard output stream using the specified format informati...
box_integer< xtd::byte > byte_object
Represent a boxed byte.
Definition byte_object.h:33
uint_least8_t byte
Represents a 8-bit unsigned integer.
Definition byte.h:23

◆ char16

using xtd::char16 = typedef char16_t

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

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

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

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;
char16_t char16
Represents a 16-bit unicode character.
Definition char16.h:26
box_char< char16 > char16_object
Represent a boxed char16.
Definition char16_object.h:33
@ u
The U key.

◆ char32

using xtd::char32 = typedef char32_t

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

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

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

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;
box_char< char32 > char32_object
Represent a boxed char32.
Definition char32_object.h:33
char32_t char32
Represents a 32-bit unicode character.
Definition char32.h:26

◆ char_

using xtd::char_ = typedef char

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

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.

◆ char_object

using xtd::char_object = typedef box_char<char>

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

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;
box_char< char > char_object
Represent a boxed char.
Definition char_object.h:33

◆ decimal

using xtd::decimal = typedef long double

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

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

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

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;
long double decimal
Represents a decimal-precision floating-point number.
Definition decimal.h:23
box_floating_point< decimal > decimal_object
Represent a boxed decimal.
Definition decimal_object.h:33

◆ double_

using xtd::double_ = typedef double

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

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 = typedef box_floating_point<double>

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

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;
box_floating_point< double > double_object
Represent a boxed double.
Definition double_object.h:33

◆ int16

using xtd::int16 = typedef int_least16_t

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

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

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

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;
int_least16_t int16
Represents a 16-bit signed integer.
Definition int16.h:23
box_integer< int16 > int16_object
Represent a boxed int16.
Definition int16_object.h:29

◆ int32

using xtd::int32 = typedef int_least32_t

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

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

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

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;
box_integer< int32 > int32_object
Represent a boxed int32.
Definition int32_object.h:29
int_least32_t int32
Represents a 32-bit signed integer.
Definition int32.h:23

◆ int64

using xtd::int64 = typedef int_least64_t

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

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

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

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;
int_least64_t int64
Represents a 64-bit signed integer.
Definition int64.h:23
box_integer< int64 > int64_object
Represent a boxed int64.
Definition int64_object.h:29

◆ intptr

using xtd::intptr = typedef intmax_t

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

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

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

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;
box_integer< intptr > intptr_object
Represent a boxed intptr.
Definition intptr_object.h:29
intmax_t intptr
Represent a pointer or a handle.
Definition intptr.h:23

◆ ptr

template<typename type_t >
using xtd::ptr = typedef xtd::sptr<type_t>

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

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);
delete_ptr(version); // Not mandatory.
Represents the version number of an assembly, operating system, or the xtd. This class cannot be inhe...
Definition version.h:110
xtd::ustring to_string() const noexcept override
Converts the value of the current xtd::version object to its equivalent xtd::ustring representation.
xtd::sptr< type_t > ptr
The xtd::ptr object is a shared pointer.
Definition ptr.h:27
void delete_ptr(sptr< type_t > &ptr)
xtd::delete_ptr operator delete a xtd::sptr or xtd::ptr object.
Definition delete_ptr.h:27

◆ ptrdiff

using xtd::ptrdiff = typedef std::ptrdiff_t

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

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

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

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;

◆ sbyte

using xtd::sbyte = typedef int_least8_t

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

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

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

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;
int_least8_t sbyte
Represents a 8-bit signed integer.
Definition sbyte.h:23
box_integer< sbyte > sbyte_object
Represent a boxed sbyte.
Definition sbyte_object.h:29

◆ single

using xtd::single = typedef float

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

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 = typedef box_floating_point<float>

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

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;
box_floating_point< float > single_object
Represent a boxed single.
Definition single_object.h:29

◆ size

using xtd::size = typedef size_t

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

Represents a size of any object in bytes.

Header
#include <xtd/size>
Namespace
xtd
Library
xtd.core
Remarks
For more information about types, see Native types, boxing and unboxing.

◆ slong

using xtd::slong = typedef __slong__

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

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

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

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;
box_integer< slong > slong_object
Represent a boxed int16.
Definition slong_object.h:29
__slong__ slong
Represents a 32-bit or 64-bit signed integer.
Definition slong.h:27

◆ sptr

template<typename type_t >
using xtd::sptr = typedef std::shared_ptr<type_t>

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

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);
delete_ptr(version); // Not mandatory.
std::shared_ptr< type_t > sptr
The xtd::sptr object is a shared pointer.
Definition sptr.h:25

◆ tick

using xtd::tick = typedef std::ratio<1LL, 10000000LL>

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

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 = typedef std::chrono::duration<int64, tick>

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

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 = typedef std::type_info

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

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 = typedef uint_least16_t

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

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

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

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;
box_integer< uint16 > uint16_object
Represent a boxed uint16.
Definition uint16_object.h:29
uint_least16_t uint16
Represents a 16-bit unsigned integer.
Definition uint16.h:23

◆ uint32

using xtd::uint32 = typedef uint_least32_t

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

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

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

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;
box_integer< uint32 > uint32_object
Represent a boxed uint32.
Definition uint32_object.h:29
uint_least32_t uint32
Represents a 32-bit unsigned integer.
Definition uint32.h:23

◆ uint64

using xtd::uint64 = typedef uint_least64_t

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

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

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

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;
box_integer< uint64 > uint64_object
Represent a boxed uint64.
Definition uint64_object.h:29
uint_least64_t uint64
Represents a 64-bit unsigned integer.
Definition uint64.h:23

◆ uintptr

using xtd::uintptr = typedef uintmax_t

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

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

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

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;
uintmax_t uintptr
Represent a pointer or a handle.
Definition uintptr.h:23
box_integer< uintptr > uintptr_object
Represent a boxed uintptr.
Definition uintptr_object.h:29

◆ ulong

using xtd::ulong = typedef __ulong__

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

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

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

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;
__ulong__ ulong
Represents a 32-bit or 64-bit unsigned integer.
Definition ulong.h:24
box_integer< ulong > ulong_object
Represent a boxed ulong.
Definition ulong_object.h:29

◆ uptr

template<typename type_t >
using xtd::uptr = typedef std::unique_ptr<type_t>

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

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);
delete_ptr(version); // Not mandatory.
std::unique_ptr< type_t > uptr
The xtd::uptr object is a unique pointer.
Definition uptr.h:25

◆ wchar

using xtd::wchar = typedef wchar_t

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

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 = typedef box_char<wchar>

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

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;
wchar_t wchar
Represents a wide character.
Definition wchar.h:24
box_char< wchar > wchar_object
Represent a boxed wchar.
Definition wchar_object.h:33

◆ wptr

template<typename type_t >
using xtd::wptr = typedef std::weak_ptr<type_t>

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

The xtd::uptr object is a weak pointer.

Library
xtd.core

Variable Documentation

◆ null

std::nullptr_t xtd::null
extern

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

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.
std::nullptr_t null
Represents a null pointer value.