cosmochaosmaker hat gesagt.:
OMG diese Definition aus der MSDN ist absoluter Schwachsinn.
Absolut Zielfremd.
Daraus geht kein bissel hervor
wo man
was benötigt.
Naaaja, absoluten Schwachsinn würde ich etwas anderes Bezeichnen, aber egal.
Wenn über ref und out gesprochen wird, sollte mal allen klar sein wie in .net Datentypen aufgeteilt sind und wie es jeweils mit der Übergabe an Methoden aussieht.
Arten: Referenztypen (Klassen), Werttypen (Strukturen, und damit alle primitiven Datentypen wie int etc. (Sind ja auch nur nur Strukturen))
Bei Referenztypen wird in der Variable nur eine Referenz auf ein Objekt gespeichert!
Werttypen enthalten direkt den Wert.
Wird bei Referenztypen zugewiesen wird immer eine Referenzkopie gemacht die auf das slebe Objekt zeigt. Bei Werttypen wird der Wert kopiert. Das spiegelt sich dann bei Methodenaufrufen wieder!
Methodenaufrufe sind normalerweise call-by-value. Von den Parametern werden Kopien erstellt und diese übergeben. Bei Referenztypen wird die Referenz kopiert, zeigt also noch immer aufs selbe Objekt (Siehe Referenzen in C++). Bei Werttypen ist das anders.
Dort sind die Werte in und ausserhalb der Aufgerufenen Methode getrennt. (Eben weil eine Kopie erzeugt wurde)
Die Schlüsselwörter ref und out beeinflussen diese Verhalten! Durch ref wird ein call-by-reference durchgeführt, es wird also keine Kopie erzeugt. Die übergebene Variable muss aber bereits erzeugt sein/einen Wert haben.
Mit out lassen sich Ausgangsparameter erzeugen. Die Übergabe ist wieder call-by-reference, aber die übergebene Variable muss noch keinen Wert haben.
Bei C++ ist das schön durch den Copy-Konstruktor zu sehen.
Die Ausgabe vom folgenden C++ Programm ist:
1: ctor_a
2: cctor_a
3: writeContent: huhu
4: writeContentRef: huhu
Die Nummerierungen oben hab ich unten als Kommentare drinnen.
Code:
#include <iostream>
#include <string>
using std::cout;
using std::cin;
using std::endl;
using std::string;
class A
{
private:
string content;
public:
A(string c);
A(A const ©);
string getContent() const;
};
void writeContent(A const a);
void writeContentRef(A const& a);
int main()
{
A otto("huhu"); // 1
writeContent(otto); // 2 (Kopie wird erstellt)
writeContentRef(otto);
return 0;
}
void writeContent(A const a)
{
cout << "writeContent: " << a.getContent() << endl; // 3, die Kopie
}
void writeContentRef(A const &a)
{
cout << "writeContentRef: " << a.getContent() << endl; // 4 - keine Kopie!
}
A::A(string c) : content(c)
{
cout << "ctor_a" << endl;
}
A::A(A const ©) : content(copy.getContent())
{
cout << "cctor_a" << endl;
}
string A::getContent() const
{
return content;
}
Das folgende C# Beispiel könnts euch ja auch ansehen.
Code:
using System;
namespace CopyTest
{
class Class1
{
[STAThread]
static unsafe void Main(string[] args)
{
Test t = new Test("initial wert");
Console.WriteLine("1: {0}", t.Text);
change2(t);
Console.WriteLine("2: {0}", t.Text);
change1(ref t);
Console.WriteLine("3: {0}", t.Text);
int test = 100;
c1(ref test);
Console.WriteLine("call c1, 1: {0}", test);
c2(test);
Console.WriteLine("call c2, 1: {0}", test);
c3(test);
Console.WriteLine("call c3, 1: {0}", test);
c2(test);
Console.WriteLine("call c2, 2: {0}", test);
c1(ref test);
Console.WriteLine("call c1, 2: {0}", test);
c3(test);
Console.WriteLine("call c3, 2: {0}", test);
Console.Read();
Console.Read();
}
private unsafe static void c1(ref int test)
{
test = test*2;
fixed (int* t = &test)
{
Console.WriteLine("Adresse: {0:x}", (int)t);
}
}
private unsafe static void c2(int test)
{
test = test*2;
int* t = &test;
Console.WriteLine("Adresse: {0:x}", (int)t);
}
private unsafe static void c3(int test)
{
test = test*2;
int* t = &test;
Console.WriteLine("Adresse: {0:x}", (int)t);
}
private unsafe static void change1(ref Test test)
{
test.Text = "REF";
Console.WriteLine("Changed to REF");
}
private unsafe static void change2(Test test)
{
test.Text = "NON REF";
Console.WriteLine("Changed to NON REF");
}
}
public class Test
{
private string text;
public string Text { get { return text;} set { text = value; } }
public Test (string text)
{
this.text = text;
Console.WriteLine("ctor_test");
}
}
}
