Wieso lassen sich ref-Instanzen wie einfache Variablen deklarieren?

Swordfish

@martin-richter sagte in Wieso lassen sich ref-Instanzen wie einfache Variablen deklarieren?:

Nein. Kann man natürlich nicht.

using namespace System;

ref struct foo
{
	int bar;
	foo(int bar) : bar{ bar } {};
	void operator=(foo % f)
	{
		bar = f.bar;
	}
};

int main()
{
	foo f{ 42 };
	foo g{ 5 };

	Console::WriteLine(f.bar);
	Console::WriteLine(g.bar);

	f = g;

	Console::WriteLine(f.bar);
	Console::WriteLine(g.bar);
}

???

Lutex

@martin-richter
Doch, man kann einen Zuweisungsoperator implementieren. Hab's grad ausprobiert; folgendes läuft unter VS 2012:

public ref class TestPoint
{
public:
    int X, Y;
    TestPoint ^ operator = (const TestPoint % OtherPoint)
    {
        X = OtherPoint.X;
        Y = OtherPoint.Y;
        return this;
    }
};

int main (cli::array <System::String ^> ^ args)
{
    TestPoint A, B;
    A.X = 10;
    A.Y = 20;
    B.X = 30;
    B.Y = 40;
    B = A;
    System::Console::WriteLine ("A=({0};{1})  B=({2};{3})", A.X, A.Y, B.X, B.Y);
    System::Console::ReadKey();
}

Die Ausschrift lautet ohne die Zuweisung B=A:
A=(10;20) B=(30;40)
und mit der Zuweisung:
A=(10;20) B=(10;20)

Martin Richter

@lutex
Stimmt. Das geht allerdings nur über eine Tracking Refrenz. Nicht über ein Handle...

Martin Richter

@swordfish sagte in Wieso lassen sich ref-Instanzen wie einfache Variablen deklarieren?:

@martin-richter sagte in Wieso lassen sich ref-Instanzen wie einfache Variablen deklarieren?:

Nein. Kann man natürlich nicht.

???

Du hast einen ref struct also einen Value Type erzeugt. Der ist kopierbar. Aber eben nicht ein ref class!

class und struct sind in C++/CLI was ganz anderes. als in C++. Einmal eben ein Referenz-Typ und einmal eine Value-Type.

Martin Richter

@lutex sagte in Wieso lassen sich ref-Instanzen wie einfache Variablen deklarieren?:

TestPoint A, B;

Schon mit

TestPoint A, ^B;

Hast Du einen komplett anderen Syntax und musst den Ref Typ in eine Tracking Referenz umwandeln.

Martin Richter

Ehe wir jetzt endlos weiterdiskutieren:

SORRY ich habe mich zu ungenau ausgedrückt und die expliziten Unterschiede zwischen Tracking References und den Objekt Referenzen nicht korrekt erklärt. Auch was es hier mit den entsprechenden Copy Operatoren auf sich hat.

Und bei dem Wetter habe ich keinen Bock auf Haarspalterei...

BTW: Tracking References gibt es nur in C++/CLI und in keiner anderen .NET Sprache
Siehe SO

Swordfish

@martin-richter sagte in Wieso lassen sich ref-Instanzen wie einfache Variablen deklarieren?:

Du hast einen ref struct also einen Value Type erzeugt. Der ist kopierbar. Aber eben nicht ein ref class!

C++/CLI standard - Ecma International sagte:

12.1 Value types
[...] Value classes are declared with the value class or value struct keywords.

C++/CLI standard - Ecma International sagte:

21.1 Ref class definitions
A ref class is a class defined with the class-key ref class or ref struct.
A ref class definition and ref struct definition differ in the default accessibility of members; by default, the members of a ref class are private, while those of a ref struct are public.

using namespace System;

ref class foo
{
public:
	int bar;
	foo(int bar) : bar{ bar } {};
	void operator=(foo % f)
	{
		bar = f.bar;
	}
};

int main()
{
	foo f{ 42 };
	foo g{ 5 };

	Console::WriteLine(f.bar);
	Console::WriteLine(g.bar);

	f = g;

	Console::WriteLine(f.bar);
	Console::WriteLine(g.bar);
}

<°)))<> ??

[read: not sure if trolling or just in grandpa-mode.]

Martin Richter

@swordfish
Und recht hast Du, ehe ich noch mehr Schwachsinn von mir gebe schweige ich jetzt,..

Swordfish

Bitte Martin, geh in den Schatten, trink viel, streng Dich nicht an ... alte Leute sind ganz besonders anfällig für Hitzeschläge!! :face_with_stuck-out_tongue_winking_eye:

hustbaer

Naja die Unterschiede zwischen C# und C++/CLI sind manchmal schon etwas verwirrend. Also so Sachen wie struct vs. class (egal bei C++/CLI, wichtig bei C#) oder die Bedeutung von ~ClassName().

Da kann man sich schonmal vertun.

Wobei IMO beides bei C# 1.0 verbockt wurde -- auch wenn vielleicht nicht absehbar war dass es jemals sowas wie C++/CLI geben könnte.