Information
The topic you requested is included in another documentation set. For convenience, it's displayed below. Choose Switch to see the topic in its original location.

Component Extensions for Runtime Platforms

Visual C++ provides language extensions to help you program against runtime platforms. By using Visual C++ component extensions (C++/CX), you can program Windows Store apps and components that compile to native code. Although you can create Windows Store apps by programming directly against the Windows Runtime COM interfaces, by using C++/CX, you can work with constructors, exceptions, and other modern C++ programming idioms. To enable C++ programming in a managed execution environment on the .NET platform, you can use C++/CLI.

Two runtimes, one set of extensions

C++/CX is a subset of C++/CLI. For extensions that are common to C++/CX and C++/CLI, the semantics depend on whether you are targeting the common language runtime (CLR) or the Windows Runtime. To compile your app to run on the Windows Runtime, specify the /ZW compiler option. To compile it to run on the CLR, specify the /clr compiler option. These switches are set automatically when you use Visual Studio to create a project.

For more information about how to create Windows Store apps in C++, see Roadmap for Windows Store apps using C++.

C++/CLI extends the ISO/ANSI C++ standard, and is defined under the Ecma C++/CLI Standard. For more information, see .NET Programming in Visual C++.

The language extensions include aggregate keywords, which are keywords that consist of two tokens separated by white space. The tokens might have one meaning when they are used separately, and another meaning when they are used together. For example, the word "ref" is an ordinary identifier, and the word "class" is a keyword that declares a native class. But when these words are combined to form ref class, the resulting aggregate keyword declares an entity that is known as a runtime class.

The extensions also include context-sensitive keywords. A keyword is treated as context-sensitive depending on the kind of statement that contains it, and its placement in that statement. For example, the token "property" can be an identifier, or it can declare a special kind of public class member.

The following table lists keywords in the C++ language extension.

Keyword

Context sensitive

Purpose

Reference

ref class

ref struct

No

Declares a class.

Classes and Structs (C++ Component Extensions)

value class

value struct

No

Declares a value class.

Classes and Structs (C++ Component Extensions)

interface class

interface struct

No

Declares an interface.

interface class (C++ Component Extensions)

enum class

enum struct

No

Declares an enumeration.

enum class (C++ Component Extensions)

property

Yes

Declares a property.

property (C++ Component Extensions)

delegate

Yes

Declares a delegate.

delegate (C++ Component Extensions)

event

Yes

Declares an event.

event (C++ Component Extensions)

You can use the following keywords to qualify override behavior for derivation. Although the new keyword is not an extension of C++, it is listed here because it can be used in an additional context. Some specifiers are also valid for native programming. For more information, see How to: Declare Override Specifiers in Native Compilations (C++/CLI).

Keyword

Context Sensitive

Purpose

Reference

abstract

Yes

Indicates that functions or classes are abstract.

abstract (C++ Component Extensions)

new

No

Indicates that a function is not an override of a base class version.

new (new slot in vtable) (C++ Component Extensions)

override

Yes

Indicates that a method must be an override of a base-class version.

override (C++ Component Extensions)

sealed

Yes

Prevents classes from being used as base classes.

sealed (C++ Component Extensions)

The following keywords have been added to support generic types. For more information, see Generics (C++ Component Extensions).

Keyword

Context sensitive

Purpose

generic

No

Declares a generic type.

where

Yes

Specifies the constraints that are applied to a generic type parameter.

The following keywords have been added to the C++ extensions.

Keyword

Context sensitive

Purpose

Reference

finally

Yes

Indicates default exception handlings behavior.

Exception Handling (C++ Component Extensions)

for each, in

No

Enumerates elements of a collection.

for each, in

gcnew

No

Allocates types on the garbage-collected heap. Use instead of new and delete.

ref new, gcnew (C++ Component Extensions)

ref new

Yes

Allocates a Windows Runtime type. Use instead of new and delete.

ref new, gcnew (C++ Component Extensions)

initonly

Yes

Indicates that a member can only be initialized at declaration or in a static constructor.

initonly (C++/CLI)

literal

Yes

Creates a literal variable.

literal (C++ Component Extensions)

nullptr

No

Indicates that a handle or pointer does not point at an object.

nullptr (C++ Component Extensions)

The following language constructs are implemented as templates, instead of as keywords. If you specify the /ZW compiler option, they are defined in the lang namespace. If you specify the /clr compiler option, they are defined in the cli namespace.

Keyword

Purpose

Reference

array

Declares an array.

Arrays (C++ Component Extensions)

interior_ptr

(CLR only) Points to data in a reference type.

interior_ptr (C++/CLI)

pin_ptr

(CLR only) Points to CLR reference types to temporarily suppress the garbage-collection system.

pin_ptr (C++/CLI)

safe_cast

Determines and executes the optimal casting method for a runtime type.

safe_cast (C++ Component Extensions)

typeid

(CLR only) Retrieves a System.Type object that describes the given type or object.

typeid (C++ Component Extensions)

The following type declarators instruct the runtime to automatically manage the lifetime and deletion of allocated objects.

Operator

Purpose

Reference

^

Declares a handle to an object; that is, a pointer to a Windows Runtime or CLR object that is automatically deleted when it is no longer usable.

Handle to Object Operator (^) (C++ Component Extensions)

%

Declares a tracking reference; that is, a reference to a Windows Runtime or CLR object that is automatically deleted when it is no longer usable.

Tracking Reference Operator (C++ Component Extensions)

This section lists additional programming constructs, and topics that pertain to the CLR.

Topic

Description

__identifier (C++/CLI)

(Windows Runtime and CLR) Enables the use of keywords as identifiers.

Variable Argument Lists (...) (C++/CLI)

(Windows Runtime and CLR) Enables a function to take a variable number of arguments.

.NET Framework Equivalents to C++ Native Types (C++/CLI)

Lists the CLR types that are used in place of C++ integral types.

appdomain __declspec modifier

__declspec modifier that mandates that static and global variables exist per appdomain.

C-Style Casts with /clr (C++/CLI)

Describes how C-style casts are interpreted.

__clrcall calling convention

Indicates the CLR-compliant calling convention.

__cplusplus_cli

Predefined Macros

Custom Attributes (C++)

Describes how to define your own CLR attributes.

Exception Handling (C++ Component Extensions)

Provides an overview of exception handling.

Explicit Overrides (C++ Component Extensions)

Demonstrates how member functions can override arbitrary members.

Friend Assemblies (C++)

Discusses how a client assembly can access all types in an assembly component.

Boxing (C++ Component Extensions)

Demonstrates the conditions in which values types are boxed.

Compiler Support for Type Traits (C++ Component Extensions)

Discusses how to detect characteristics of types at compile time.

managed, unmanaged pragmas

Demonstrates how managed and unmanaged functions can co-exist in the same module.

process __declspec modifier

__declspec modifier that mandates that static and global variables exist per process.

Reflection (C++/CLI)

Demonstrates the CLR version of run-time type information.

String (C++ Component Extensions)

Discusses compiler conversion of string literals to String.

Type Forwarding (C++/CLI)

Enables the movement of a type in a shipping assembly to another assembly so that client code does not have to be recompiled.

User-Defined Attributes (C++ Component Extensions)

Demonstrates user-defined attributes.

#using Directive (C++)

Imports external assemblies.

XML Documentation (Visual C++)

Explains XML-based code documentation by using /doc (Process Documentation Comments) (C/C++)

Show:
© 2014 Microsoft