David Bednárek Jakub Yaghob Filip Zavoral

David Bednárek Jakub Yaghob Filip Zavoral http://data.ksi.ms.mff.cuni.cz/svn/NPRG051pub/html/nprg051.html



Samostatný jazyk standardizovaný ECMA ◦ snaha o maximální kompatibilitu s C++



CLI

Common Language Infrastructure

standard ECMA - virtual machine - framework (libraries)

CLR

Common Language Runtime

implementace VM

CIL

Common Intermediate Language

jazyk interpretovaný VM

MSIL

MSIL :-)

konkrétní MS implementace CIL

CTS

Common Type System

jednotný typový systém CLI

.Net Framework

MS implementace nadmnožiny CLI

Mono

multiplatformní implementace CLI http://www.mono-project.com

managed code

◦ spravovaný .Net frameworkem

 

přístup k CLI (.Net) knihovnám snadná interoperabilita 

C#, F#, VisualBasic,

... COBOL, Eiffel, Mercury ...

Source code Managed code

VB

C#

C++

Compiler

Compiler

Compiler

Assembly IL Code

Assembly IL Code

Assembly IL Code

Common Language Runtime JIT Compiler Native Code

Operating System Services

Unmanaged Component

System.Web Services Description Discovery Protocols Caching

Configuration

System.Windows.Forms

UI HtmlControls

Design

WebControls

ComponentModel

System.Drawing

Security

Drawing2D

SessionState

Imaging

System.Data OleDb

Common

Printing Text

System.Xml

SqlClient

XSLT

SQLTypes

XPath

Serialization

System Collections

IO

Security

Diagnostics

Reflection

Text

Configuration Globalization

Net

Resources

ServiceProcess Threading

Runtime InteropServices Remoting

Serialization

Type

Value Types

Reference Types

Built-In Value Types

Self Describing Types

Pointer Types

Interface Types

Enumerations User-Defined Value Types (structs)

Class Types

User-Defined Classes

Arrays

Boxed Value Types

Delegates



Ve skutečnosti dva nezávislé typové systémy ◦ native  original ISO C++ ◦ managed  fuj - manažovaný - řízený  CTS ◦ string vs. String, vector vs. array



Garbage collection

◦ pouze CTS ◦ managed heap ◦ handle  není to ukazatel  může se měnit ◦ nové operátory: gcnew ^ % ◦ reference vs. value type

native heap class Native {...}; ref class Managed {...}; { Native* n = new N; Managed^ m = gcnew Managed; delete n; }

handle

managed heap

Typy

hodnotové

referenční

data

primitivní typy, malé kolekce

složitější struktury

umístění

přímo v paměti (zásobník)

vždy na [managed] heapu

přístup

přímo

přes [tracking] handle

přiřazení, parametry

hodnotou

odkazem

dědičnost

ne

jednoduchá (více interfaces)

copy constr

ano

ne

default sémantika

stack heap s.: boxing

heap stack s.: autoalokace

value struct B { int x; }; int main() { B b; b.x = 0; }

ref class A { int f(); }; int main() { A^ a = gcnew A; a->f(); }



ref class, ref struct

◦ nesmí obsahovat nemanaged struktury ◦ nemají automatický copy constructor a operator = ◦ jednoduchá dědičnost, vícenásobná dědičnost interface



value class, value struct

◦ nepodporují dědičnost !



enum class

◦ rozšíření enumu o několik metod - ToString ◦ value type 

interface class

◦ abstract class bez dat ◦ možnost vícenásobné dědičnosti 

array

◦ typované vícerozměrné pole 

generic



Referenční typy

◦ proměnné ≈ reference na data ◦ neinicilizované: nullptr  přístup přes nullptr ⇒ NullReferenceException ◦ přiřazení ≈ kopírování referencí, nikoliv dat  není automaticky definován copy konstruktor ◦ konec existence poslední reference ⇒ někdy garbage collection ◦ možná i zásobníková sémantika  technicky ale stále heap, na konci platnosti destruktor ref class A { int f(); };

ra va

... { A^ ra = gcnew A; A va; ra->f(); va.f(); }

destruktor va

ra

ra

va

někdy možná GC a finalizer



Hodnotové typy ◦ ◦ ◦ ◦

proměnné ≈ vlastní data přiřazení ≈ kopírování dat nelze dědičnost boxing - alokace na heapu

value struct B { int x; }; fnc( B^ b) { b->x = 2; }

pozor na automatické konverze

rb

rb: 1

vb: 1

}

boxing vb

rb: 2

vb: 1 b

{ B^ rb = gcnew B; B vb; rb->x = vb.x = 1; fnc( rb); fnc( vb);

rb

b: 2



handle

◦ T^ x = gcnew T; ◦ x->a, (*x).a

◦ unmanaged: * 

tracking reference ◦ T% y = *x; ◦ T% y = var; ◦ y.a

◦ unmanaged: & přímo nelze jen na objekty na zásobníku

value class T; T a; T^ b = gcnew T; T^ c = %a; T% d = a; T% e = *b; T* f = &a; // T* g = b; pin_ptr g = &*b; // T* h = &d; pin_ptr h = &d; T& i = a; // T& j = *b;

technicky: ukazatel dovnitř managed objektu

a b c

b a

d e f g h i

kopie do managed heapu !!



ISO C++

◦ volá se metoda aktuálně konstruovaného podobjektu



C++/CLI

◦ volá se metoda skutečného (vnějšího) objektu

class A { A() : x(0) { x = f(); } virtual int f() { return x + 1; } int x; }; class B : public A { public: B() { x = f(); } virtual int f() { return };

x + 2; }

A* b = new B;

ref class C { public: C() : x(0) { x = f(); } virtual int f() { return int x; };

x + 1; }

ref class D : C { public: D() { x = f(); } virtual int f() override { return x + 2; } }; C^ d = gcnew D;

A() { A::f() }, B() { B::f() } x=3

C() { D::f() }, D() { D::f() } x=4

rozhraní interface class IA { int f(); }; ref class A abstract : IA { public: A8() { x_ = 1; } virtual int f() abstract; ~A8() { cout << "~"; } !A8() { cout << "!"; } private: initonly int x_; };

vícenásobná dědičnost rozhraní destruktor deterministicky finalizer - při GC nedeterministicky přiřazení pouze při inicializaci jen jednoduchá dědičnost tříd

ref class B8 sealed : A8 { public: virtual int f() override sealed {...} };

nepodporovány - default parametry - const metody

ref class C { const int f(int x=1,int y=2); };

ref class A { public: property int a; property int b { int get() { return x_; } void set( int x) { x_ = x; } } property int c[int] { int get( int i) { return (x_>>i)&1; } void set( int i, int x) { x_ ^= (x&1)<a = a->b; a->c[1] = a[2];

trivial property standard property indexed property default indexed property



dědičnost

◦ virtual property



read/write-only

◦ lze nadefinovat jen get/set



static property

◦ přístup jen k statickým prvkům



Delegate

◦ ukazatel na funkci nebo metodu konkrétního objektu



Event

◦ událost: zpráva odesílatel ⇉ příjem ci

typ delegáta

ref class MyEventArgs {}; delegate void MyDelegate( Object^ sender, MyEventArgs^ e); ref class WakeMeUp { void MyHandler( Object^ sender, MyEventArgs^ e) {} static void StaticHandler( Object^ sender, MyEventArgs^ e) {} };

handlery příjemce

deklarace eventu

ref class EventSender { zavolání všech funkcí event MyDelegate^ Alarm; void OnAlarm( void) { Alarm( this, gcnew MyEventArgs); } };

inicializace delegáta objektem a metodou

WakeMeUp^ w = gcnew WakeMeUp(); EventSender^ sender = gcnew EventSender(); sender->Alarm += gcnew MyDelegate( w, &WakeMeUp::MyHandler); sender->Alarm += gcnew MyDelegate( &WakeMeUp::StaticHandler); sender->OnAlarm(); sender->Alarm -= gcnew MyDelegate( &WakeMeUp::StaticHandler); sender->OnAlarm();

statická metoda odebrání

     

pole built-in povinně referenční typ, vždy na heapu typované, pevně vícerozměrné, 0-based vícerozměrné indexy [i,j,k] iterace možná i přes iteratory, interior ptr a for each přiřazení ≈ reference, Array::Copy kopie array< String^>^ as array< int, 2>^ a2d array< int, 2>^ a2d array< int, 2>^ a2d array< int, 2>^ a2d int x = a2d[1,2];

= = = = =

gcnew array<String^>(10); gcnew array(2,3); gcnew array(2,3) {{1,2,3},{4,5,6}}; gcnew array {{1,2,3},{4,5,6}}; {{1,2,3},{4,5,6}};

interior_ptr<String^> is; for( is=&as[0]; is<=&as[9]; ++is) ... *is ...

for each( String^ s in as) ... s ... IEnumerator^ es = as->GetEnumerator(); while( es->MoveNext()) ... es->Current ...



parametry

◦ součástí typu je typ prvků a dimenze, ne rozměry ◦ variabilní počet parametrů  bezpečnější než va_arg



kovariance

◦ pokud existuje konverze z A na B ◦ array aa; array bb; bb = aa;



nepravidelné pole

array<array ^> ^jagged = gcnew array<array ^>(4); for each (array ^% ar in jagged) { int i = 5; ar = gcnew array(++i); }

void f( array^ a) {...}

vždy array^

proměnný počet argumentů

int sum( ... array^ va) { int sum = 0; for each( int a in va) sum += a; return sum; } int x = sum( 1, 2, 3, 4);

 

mnoho metod řada z nich přetížených AsReadOnly BinarySearch Clear Clone ConstrainedCopy ConvertAll<TIn,TOut> Copy CopyTo CreateInstance Equals Exists Find FindAll FindIndex FindLast FindLastIndex ForEach

GetEnumerator GetHashCode GetLength GetLowerBound GetType GetUpperBound GetValue IndexOf Initialize LastIndexOf MemberwiseClone Resize Reverse SetValue Sort ToString TrueForAll



gumová pole

◦ ArrayList - polymorfní (Object^)  absence typové kontroly  pomalejší  obecnější ◦ List - generic  obrácené vlastnosti ◦ další CLI kontejnery

using namespace System::Collections; ArrayList^ al = gcnew ArrayList(); al->Add( 1); al->Add( "hrusky"); al->Add( 3.141); for each( Object^ o in al) Console::WriteLine( o);

using namespace System::Collections::Generic; List<String^>^ sl = gcnew List<String^>; sl->Add( "hrusky"); sl->Add( "jine hrusky"); for each( String^ s in sl) Console::WriteLine( s);

 

String (CLI) != string (STD) imutabilní

◦ jakákoliv operace vytváří novou instanci ◦ mutabilní StringBuilder

 

všechny řetězce Unicode (≡ wchar_t) přiřazení

◦ = přiřazení referencí (mělká kopie) ◦ Copy - vytvoření kopie (hluboká kopie)



porovnávání

◦ == (Equals) - porovnání hodnot ◦ ReferenceEquals - porovnání referencí



konverze

≡ s = gcnew String( "Text");

String^ s = "Text"; s->Chars[1] s = t + ".";

String^ s = "123"; int x = Int32::Parse( s); int y = Convert::Parse( s); s = x.ToString();

string is = "isostring"; String^ ms = gcnew String( is.c_str()); is = (char*) Runtime::InteropServices::Marshal:: StringToHGlobalAnsi( ms).ToPointer(); pin_ptr ptr = PtrToStringChars( ms); is = static_cast(ptr);



Šablony Templates

◦ řeší kompilátor ◦ výstup - varianty kódu pro různé typy ◦ kompilace jen použitých kombinací konstrukcí a typů



Generika Generics

◦ řeší runtime ◦ výstup - jeden společný kód ◦ kompletní kompilace

co je tu zajímavého?

generic ref class List { T Add( T t) { ... } ... }; List intl; intl.Add( 1);

Šablony

Generika

Klíčové slovo

template

generic

Kód

pro každý použitý typ samostatný

společný

Vyhodnocování

při kompilaci normální typy

runtime (JIT kompilace)

Kompatibilita

STL

.Net, CTS, C#, VB

Použití netypových parametrů

ano

ne

Instance lišící se pouze typovým parametrem

různé typy

stejný typ

Typové parametry

cokoli

normální typy nebo generika, nelze šablony

Defaultní typový parameter

ano

ne

Parciální a explicitní specializace

ano

ne

Šablonové třídy jako typový parametr

ano

ne

kontrola argumentů

ne (zatím)

constraints

volání metod argumentů

ano (kontrola při použití)

odpovídající constraints

template class T2>



omezení množiny argumentů generik

◦ implementuje rozhraní / odvozená od jiné třídy ◦ gcnew constraint (default constr) ◦ value / reference type constraint



kontrola při kompilaci interface class I { int f(); };

interface constraint implementuje interface

generic where T : I, gcnew(), ref class ref class A { T t; int g() { return t.f(); } };

reference constraint musí být referenční typ

ref class B : I {}; // A ai; A ab;

gcnew constraint musí mít default constr kontrola při překladu

System::Collections ArrayList BitArray DictionaryBase Hashtable SortedList Stack

System::Collections::Generic Dictionary HashSet LinkedList List Queue SortedDictionary SortedList SortedSet Stack SynchronizedCollection SynchronizedKeyedCollection SynchronizedReadOnlyCollection

polymorfní

generické



metadata popisující vnější vlastnosti

◦ na mnoho konstrukcí - assembly, třídy, metody, parametry, ... ◦ častá vazba na prostředí (.Net) metadata assembly [assembly:AssemblyTitleAttribute("myproject")] [assembly:SecurityPermission( SecurityAction::RequestMinimum, UnmanagedCode=true)]

hlášení kompilátoru

[Serializable] ref class A { T t; [Obsolete("Do not use")] int g(); void f([Out] String^% s); };

serializovatelnost do XML serializer->serialize(a)

výstupní parametr není nutná inicializace (interoperabilita s C#)



Třída odvozená od System::Attribute ◦ přístup k datům pomocí reflexe

definice vlastního atributu použití atributu přístup k hodnotám

aplikovatelnost

[AttributeUsageAttribute(AttributeTargets::Class)] public ref class OwnerAttribute : Attribute { property String^ Developer; }; [Owner(Developer="Ja Mocny")] ref class MyClass { ... } OwnerAttribute^ a = Attribute::GetCustomAttribute( MyClass::typeid, OwnerAttribute::typeid); ... a->Developer ...



alternativa RTTI

◦ podpora .Net ◦ jméno typu, vztahy dědičnosti, metody a properties, atributy, ... using namespace System::Reflection;

Type přístup k typovým informacím

Assembly^ ass = Assembly::LoadFrom("myass.dll"); array^ types = ass->GetTypes(); for each( Type^ t in types) { WriteLine( t->ToString()); array<MethodInfo^>^ methods = t->GetMethods(); for each( MethodInfo^ m in methods) { WriteLine( "{1} {0}", m->Name, m->ReturnType->ToString()); array<ParameterInfo^>^ params = t->GetParameters(); ... } }

Type^ t = String::typeid; t = obj->GetType(); t = Type::GetType("System::DateType");



aktivní operace

◦ vytváření typů z dll ◦ instanciace objektů ◦ vyvolávání metod

Dynamické vytvoření typu a instance objektu Dynamické vyvolání metody

Assembly^ ass = Assembly::LoadFrom("myass.dll"); Type^ t = ass->GetType("nejakytyp"); MethodInfo^ method = t->GetMethod("metoda"); Object^ obj = Activator::CreateInstance( t); array^ paramList = .....; method->Invoke( obj, paramList);

neshoda parametrů ↝ výjimka



.Net / C# like Console::WriteLine( "Hodnota {0} je {1}", "jedna", 1); Console::WriteLine( "Hex {0:x8}", 0x123456); String^ s; try { while(( s = Console::ReadLine())) != nullptr) { int i = Int32::Parse( s); } } catch( FormatException^ e) { ... }

StreamWriter^ sw = gcnew StreamWriter( "file.txt"); sw->WriteLine( "whatever"); sw->Close();



C++/CLI  C++

◦ jak spojovat moduly a volat metody   ◦ jak sdílet managed a native data   nedělejte to - striktní rozhraní  když už - speciální šablony



C++/CLI  C#, ...

◦ jak spojovat moduly   class library / add reference (.dll) ◦ jak volat metody   class library ◦ jak sdílet data   CTS

ref class A { int x_; }; A^ a = gcnew A; // int* y = &a->x_; pin_ptr = &a->x_; *y = 99; interior_ptr = &a->x_; *y = 99;

ref class A { int x_; }; class C { // A^ a; gcroot a; auto_gcroot b; int x() { return a->x_; } }; { C c; }

připíchnutý ptr objekt se nehýbe vnitřní ptr do managed struktury hýbe se automaticky s objektem umožní vkládat managed třídy do nativních nevolá ~A volá ~A při destrukci objektu

Project: C++ CLR Class Library namespace clilib { public ref class A { public: A() : x_(0) {} int f() {...}; }; }

clilib.dll

Project: C# Console App namespace App { class Program { static void Main(string[] args) { clilib.A a = new clilib.A(); int x = c.f(); } } }

Add Reference: clilib.dll



 Klady

◦ interoperabilita - .Net, C#, CTS ◦ téměř plná kompatibilita s C++ ◦ managed code



 Zápory

◦ dva jazyky v jednom ◦ odlišné typové systémy ◦ podivná syntaxe a hlavně sémantika  mnoho divných variant definovaných výčtem



 Use cases

◦ velký C++ projekt, .Net služby (WPF)  úzké rozhraní ◦ interoperabilita s C#, VB, F#, *# ◦ ? first-choice language ?  zároveň požadavek na výkonnost a těsná integrace s GUI



Gordon Hogenson:

◦ C++/CLI - The Visual C++ Language for .Net



Marcus Heege:

◦ Expert C++/CLI - .Net for Visual C++ Programmers



Nishant Shivakumar: ◦ C++/CLI in Action

◦ umět ke zkoušce ◦ zhruba se orientovat v problému