View source for C++/CLI

{{Short description|Programming language}}
{{lead too short|date=March 2015}}
{{Infobox programming language
| name = C++/CLI
| logo =
| paradigm = [[Structured programming|Structured]], [[Imperative programming|imperative]], [[Object-oriented programming|object-oriented]]
| family = [[List of C-family programming languages|C]]
| year = {{Start date and age|2005}}
| designer = [[Microsoft]]
| developer = Microsoft
| latest release version = 
| latest release date = 
| typing =
| implementations =
| dialects =
| influenced_by = [[C++]], [[Managed Extensions for C++]], [[C Sharp (programming language)|C#]]
| influenced =
| platform = [[Common Language Infrastructure]]
| license =
| file_ext =
| website = {{URL|https://docs.microsoft.com/en-us/cpp/dotnet/dotnet-programming-with-cpp-cli-visual-cpp}}
| wikibooks =
| versions =
}}
'''C++/CLI''' is a variant of the [[C++]] [[programming language]], modified for [[Common Language Infrastructure]].  It has been part of [[Visual Studio]] 2005 and later, and provides interoperability with other [[.NET]] languages such as [[C Sharp (programming language)|C#]]. Microsoft created C++/CLI to supersede [[Managed Extensions for C++]]. In December 2005, [[Ecma International]] published C++/CLI specifications as the '''ECMA-372''' standard.<ref>{{cite web |title=ECMA-372 |url=https://www.ecma-international.org/publications-and-standards/standards/ecma-372/ |website=ecma-international.org |publisher=[[Ecma International]] |archive-url=https://web.archive.org/web/20080810165757/http://www.ecma-international.org/publications/standards/Ecma-372.htm |archive-date=10 August 2008 |date=December 2005}}</ref>

==Syntax changes==
C++/CLI should be thought of as a language of its own (with a new set of keywords, for example), instead of the C++ superset-oriented [[Managed Extensions for C++|Managed C++]] (MC++) (whose non-standard keywords were styled like {{Cpp|__gc}} or {{Cpp| __value}}). Because of this, there are some major syntactic changes, especially related to the elimination of ambiguous identifiers and the addition of .NET-specific features.

Many conflicting syntaxes, such as the multiple versions of operator {{Cpp|new()}} in MC++, have been split: in C++/CLI, .NET reference types are created with the new keyword {{Cpp|gcnew}} (i.e. [[Garbage collection (computer science)|garbage collected]] new()). Also, C++/CLI has introduced the concept of generics from .NET (similar, for the most common purposes, to standard C++ templates, but quite different in their implementation).

===Handles===
In MC++, there were two different types of [[pointer (computer programming)|pointer]]s: {{Cpp|__nogc}} pointers were normal C++ pointers, while {{Cpp|__gc}} pointers worked on .NET reference types. In C++/CLI, however, the only type of pointer is the normal C++ pointer, while the .NET reference types are accessed through a "handle", with the new syntax {{Cpp|ClassName^}} (instead of {{Cpp|ClassName*}}). This new construct is especially helpful when managed and standard C++ code is mixed; it clarifies which objects are under .NET automatic garbage collection and which objects the programmer must remember to explicitly destroy.

===Tracking references===
A '''tracking reference''' in C++/CLI is a handle of a passed-by-reference variable. It is similar in concept to using {{Cpp|*&}} (reference to a pointer) in standard C++, and (in function declarations) corresponds to the {{Cpp|ref}} keyword applied to types in C#, or {{Cpp|ByRef}} in [[Visual Basic .NET]]. C++/CLI uses a {{Cpp|^%}} syntax to indicate a tracking reference to a handle.

The following code shows an example of the use of tracking references. Replacing the tracking reference with a regular handle variable would leave the resulting string array with 10 uninitialized string handles, as only copies of the string handles in the array would be set, due to them being passed by value rather than by reference.
<syntaxhighlight lang=Cpp>
int main()
{
    array<String^> ^arr = gcnew array<String^>(10);
    int i = 0;

    for each(String^% s in arr) {
        s = i++.ToString();
    }

    return 0;
}
</syntaxhighlight>

===Finalizers and automatic variables===
Another change in C++/CLI is the introduction of the [[finalizer]] syntax {{Cpp|!ClassName()}}, a special type of nondeterministic destructor that is run as a part of the [[Garbage collection (computer science)|garbage collection routine]]. The C++ destructor syntax {{Cpp|~ClassName()}} also exists for managed objects, and better reflects the "traditional" C++ semantics of deterministic destruction (that is, destructors that can be called by user code with {{Cpp|delete}}).

In the raw .NET paradigm, the nondeterministic destruction model overrides the protected {{Cpp|Finalize}} method of the root {{Cpp|Object}} class, while the deterministic model is implemented through the {{Cpp|IDisposable}} [[Interface (computer science)|interface]] method {{Cpp|Dispose}} (which the C++/CLI compiler turns the destructor into). Objects from C# or VB.NET code that override the Dispose method can be disposed of manually in C++/CLI with {{Cpp|delete}} just as .NET classes in C++/CLI can.

<syntaxhighlight lang=Cpp>
// C++/CLI
ref class MyClass
{
public:
    MyClass();  // constructor
    ~MyClass(); // (deterministic) destructor (implemented as IDisposable.Dispose())
protected:
    !MyClass(); // finalizer (non-deterministic destructor) (implemented as Finalize())

public:
    static void Test()
    {
        MyClass automatic; // Not a handle, no initialization: compiler calls constructor here
 
        MyClass ^user = gcnew MyClass();
        delete user;

        // Compiler calls automatic's destructor when automatic goes out of scope
    }
};
</syntaxhighlight>

==Operator overloading==
[[Operator overloading]] works analogously to standard C++. Every * becomes a ^, every & becomes an %, but the rest of the syntax is unchanged, except for an important addition: for .NET classes, operator overloading is possible not only for classes themselves, but also for references to those classes. This feature is necessary to give a ref class the semantics for operator overloading expected from .NET ref classes. (In reverse, this also means that for .NET framework ref classes, reference operator overloading often is implicitly implemented in C++/CLI.)

For example, comparing two distinct String references (String^) via the operator == will give true whenever the two strings are equal. The operator overloading is static, however. Thus, casting to Object^ will remove the overloading semantics.

<syntaxhighlight lang=Cpp>
//effects of reference operator overloading
String ^s1 = "abc";
String ^s2 = "ab" + "c";
Object ^o1 = s1;
Object ^o2 = s2;
s1 == s2; // true
o1 == o2; // false
</syntaxhighlight>

==Interoperability==
C++/CLI allows C++ programs to consume C# programs in C# DLLs.<ref>[https://docs.microsoft.com/en-us/cpp/dotnet/using-cpp-interop-implicit-pinvoke?view=vs-2019 Using C++ Interop (Implicit PInvoke)]</ref>  Here the #using keyword shows the compiler where the DLL is located for its compilation metadata.  This simple example requires no data [[Marshalling (computer science)|marshalling]].
<syntaxhighlight lang=Cpp>
#include "stdafx.h"
using namespace System;
#using "...MyCS.dll"

int main(array<System::String ^> ^args) {
    double x = MyCS::Class1::add(40.1, 1.9);
    return 0;
}
</syntaxhighlight>
The C# source code content of MyCS.dll.
<syntaxhighlight lang="csharp">
namespace MyCS;

public class Class1 {
    public static double add(double a, double b) {
        return a + b;
    }
}
</syntaxhighlight>
This examples shows how strings are marshalled from C++ strings to strings callable from C# then back to C++ strings.  String marshalling copies the string contents to forms usable in the different environments.
<syntaxhighlight lang=Cpp>
#include <string>
#include <iostream>
#include <msclr\marshal_cppstd.h>
#include "stdafx.h"
using namespace System;
#using "..MyCS.dll"

int main() {
	std::string s = "I am cat";
	System::String^ clrString = msclr::interop::marshal_as<System::String^>(s); // string usable from C#
	System::String^ t = MyCS::Class1::process(clrString); // call C# function
	std::string cppString = msclr::interop::marshal_as<std::string>(t); // string usable from C++
	std::cout << "Hello, C++/C# Interop!" << std::endl;
	std::cout << cppString << std::endl;
	return 0;
}
</syntaxhighlight>
The C# code is not in any way C++-aware.
<syntaxhighlight lang="csharp">
namespace MyCS;

public class Class1 {
    public static string process(string a) {
        return a.Replace("cat", "dog") + " with a tail";
    }
}
</syntaxhighlight>
C++/C# interoperability allows C++ simplified access to the entire world of .NET features.

==C++/CX==
[[C++/CX]] targeting [[WinRT]], although it produces entirely unmanaged code, borrows the ref and ^ syntax for the reference-counted components of WinRT, which are similar to [[Component Object Model|COM]] "objects".<ref>[https://devblogs.microsoft.com/cppblog/inside-the-ccx-design/ Inside the C++/CX Design - Visual C++ Team Blog - Site Home - MSDN Blogs]</ref>

==References==
{{Reflist}}

==Further reading==
{{refbegin}}
* {{Cite web |first1=Herb |last1=Sutter |author-link1=Herb Sutter |url=https://docs.microsoft.com/en-us/archive/blogs/hsutter/ccli-keywords-under-the-hood |title=C++/CLI keywords: Under the hood |website=Herb Sutter's Blog |publisher=[[Microsoft]] |date=23 November 2003 |archive-url=https://web.archive.org/web/20071109130154/http://blogs.msdn.com/hsutter/archive/2003/11/23/53519.aspx |archive-date=9 November 2007}}
* {{Cite web |first1=Herb |last1=Sutter |author-link1=Herb Sutter |url=http://www.gotw.ca/publications/C++CLIRationale.pdf |format=PDF |title=A Design Rationale for C++/CLI |publisher=[[WP:SPS|Self-published]] |date=24 February 2006}}
* {{Cite web |first1=Bjarne |last1=Stroustrup |author-link1=Bjarne Stroustrup |url=https://www.stroustrup.com/bs_faq.html#CppCLI |title=What do you think of C++/CLI? |work=Bjarne Stroustrup's FAQ |publisher=[[WP:SPS|Self-published]] |date=23 July 2021}}
* {{Cite journal |first1=Stanley |last1=Lippman |author-link1=Stanley B. Lippman |title=Pure C++: Hello, C++/CLI |journal=[[MSDN Magazine]] |volume=21 |number=3 |publisher=[[Microsoft]] |archive-url=https://web.archive.org/web/20080205003004/http://msdn.microsoft.com/msdnmag/issues/06/00/PureC/default.aspx |archive-date=5 February 2008 |url=https://docs.microsoft.com/en-us/archive/msdn-magazine/2006/vs-2005-guided-tour/pure-c-hello-c-cli}}
* {{Cite web |first1=Stanley |last1=Lippman |author-link1=Stanley B. Lippman |title=Why C++/CLI Supports both Templates for CLI Types and the CLI Generic Mechanism |website=Stan Lippman's BLog |publisher=[[Microsoft]] |date=5 August 2004 |archive-url=https://web.archive.org/web/20071007030053/http://blogs.msdn.com/slippman/archive/2004/08/05/209606.aspx |archive-date=7 October 2007 |url=https://docs.microsoft.com/en-us/archive/blogs/slippman/why-c-supports-both-class-and-typename-for-type-parameters}}
{{refend}}

==External links==
* {{Official website|https://docs.microsoft.com/en-us/cpp/dotnet/dotnet-programming-with-cpp-cli-visual-cpp}}
* [https://patents.google.com/patent/US7496889B2/en Patent regarding whitespace in keywords]

{{Common Language Infrastructure}}
{{Ecma International Standards}}
{{C++ programming language}}
{{Authority control}}

{{DEFAULTSORT:C++ CLI}}
[[Category:.NET programming languages]]
[[Category:C++ programming language family]]
[[Category:Ecma standards]]
[[Category:Microsoft Visual Studio]]