Quick Reference (C++/CX)

  • Article

The Windows Runtime supports Universal Windows Platform (UWP) apps. These apps execute only in a trustworthy operating system environment, use authorized functions, data types, and devices, and are distributed through the Microsoft Store. The C++/CX simplify the writing of apps for the Windows Runtime. This article is a quick reference; for more complete documentation, see Type system.

When you build on the command line, use the /ZW compiler option to build a UWP app or Windows Runtime component. To access Windows Runtime declarations, which are defined in the Windows Runtime metadata (.winmd) files, specify the #using directive or the /FU compiler option. When you create a project for a UWP app, Visual Studio by default sets these options and adds references to all Windows Runtime libraries.

Quick reference

Concept Standard C++ C++/CX Remarks
Fundamental types C++ fundamental types. C++/CX fundamental types that implement fundamental types that are defined in the Windows Runtime. The default namespace contains C++/CX built-in, fundamental types. The compiler implicitly maps C++/CX fundamental types to standard C++ types.

The Platform family of namespaces contains types that implement fundamental Windows Runtime types.
bool bool An 8-bit Boolean value.
wchar_t, char16_t char16 A 16-bit nonnumeric value that represents a Unicode (UTF-16) code point.
short

unsigned short		 int16

uint16		 A 16-bit signed integer.

A 16-bit unsigned integer.
int

unsigned int		 int

uint32		 A 32-bit signed integer.

A 32-bit unsigned integer.
long long -or- __int64

unsigned long long		 int64

uint64		 A 64-bit signed integer.

A 64-bit unsigned integer.
float, double float32, float64 A 32-bit or 64-bit IEEE 754 floating-point number.
enum enum class

-or-

enum struct		 A 32-bit enumeration.
(Doesn't apply) Platform::Guid A 128-bit nonnumeric value (a GUID) in the Platform namespace.
std::time_get Windows::Foundation::DateTime A date-time structure.
(Doesn't apply) Windows::Foundation::TimeSpan A timespan structure.
(Doesn't apply) Platform::Object^ The reference-counted base object in the C++ view of the Windows Runtime type system.
std::wstring

L"..."		 Platform::String^ Platform::String^ is a reference-counted, immutable, sequence of Unicode characters that represent text.
Pointer Pointer to object (*):

std::shared_ptr		 Handle-to-object (^, pronounced "hat"):

T^ identifier		 All Windows Runtime classes are declared by using the handle-to-object modifier. Members of the object are accessed by using the arrow (->) class-member-access operator.

The hat modifier means "pointer to a Windows Runtime object that is automatically reference counted." More precisely, handle-to-object declares that the compiler should insert code to manage the object's reference count automatically, and delete the object if the reference count goes to zero
Reference Reference to an object (&):

T& identifier		 Tracking reference (%):

T% identifier		 Only Windows Runtime types can be declared by using the tracking reference modifier. Members of the object are accessed by using the dot (.) class-member-access operator.

The tracking reference means "a reference to a Windows Runtime object that is automatically reference counted." More precisely, a tracking reference declares that the compiler should insert code to manage the object's reference count automatically. The code deletes the object if the reference count goes to zero.
Dynamic type declaration new ref new Allocates a Windows Runtime object and then returns a handle to that object.
Object lifetime management delete identifier

delete[] identifier		 (Invokes the destructor.) Lifetime is determined by reference counting. A call to delete invokes the destructor but itself doesn't free memory.
Array declaration T identifier[]

std::array identifier		 Array<T^>^ identifier( size )

-or-

WriteOnlyArray<T^> identifier( size )		 Declares a one-dimensional modifiable or write-only array of type T^. The array itself is also a reference-counted object that must be declared by using the handle-to-object modifier.

(Array declarations use a template header class that is in the Platform namespace.)
Class declaration class identifier {}

struct identifier {}		 ref class identifier {}

ref struct identifier {}		 Declares a runtime class that has default private accessibility.

Declares a runtime class that has default public accessibility.
Structure declaration struct identifier {}

(that is, a Plain Old Data structure (POD))		 value class identifier {}

value struct identifier {}		 Declares a POD struct that has default private accessibility.

A value class can be represented in Windows metadata, but a standard C++ class can't be.

Declares a POD struct that has default public accessibility.

A value struct can be represented in Windows metadata, but a standard C++ struct can't be.
Interface declaration abstract class that contains only pure virtual functions. interface class identifier {}

interface struct identifier {}		 Declares an interface that has default private accessibility.

Declares an interface that has default public accessibility.
Delegate std::function public delegate return-type delegate-type-identifier ( [ parameters ] ); Declares an object that can be invoked like a function call.
Event (Doesn't apply) event delegate-type-identifier event-identifier;

delegate-type-identifier delegate-identifier = ref new delegate-type-identifier( this [, parameters] );

event-identifier += *delegate-identifier;

-or-

EventRegistrationToken token-identifier = object.event-identifier += delegate-identifier;

-or-

auto token-identifier = object.event-identifier::add( delegate-identifier );

object.event-identifier -= token-identifier;

-or-

object.event-identifier::remove( token-identifier );		 Declares an event object, which stores a collection of event handlers (delegates) that are called when an event occurs.

Creates an event handler.

Adds an event handler.

Adding an event handler returns an event token (token-identifier). If you intend to explicitly remove the event handler, you must save the event token for later use.

Removes an event handler.

To remove an event handler, you must specify the event token that you saved when the event handler was added.
Property (Doesn't apply) property T identifier;

property T identifier[ index ];

property T default[ index ];		 Declares that a class or object member function is accessed by using the same syntax that's used to access a data member or indexed array element.

Declares a property on a class or object member function.

Declares an indexed property on an object member function.

Declares an indexed property on a class member function.
Parameterized types templates generic <typename T> interface class identifier {}

generic <typename T > delegate [return-type] delegate-identifier() {}		 Declares a parameterized interface class.

Declares a parameterized delegate.
Nullable value types std::optional<T> Platform::IBox <T> Enables variables of scalar types and value structs to have a value of nullptr.

See also

C++/CX language reference