Dieser Browser wird nicht mehr unterstützt.
Führen Sie ein Upgrade auf Microsoft Edge durch, um die neuesten Features, Sicherheitsupdates und den technischen Support zu nutzen.
In diesem Artikel wird die Verwendung von Eigenschaften in C++/CLI erläutert.
Für grundlegende Eigenschaften , die lediglich ein privates Datenmememm zuweisen und abrufen, müssen Sie die Accessorfunktionen zum Abrufen und Festlegen nicht explizit definieren, da der Compiler diese automatisch bereitstellt, wenn nur der Datentyp der Eigenschaft angegeben wird. Dieser Code veranschaulicht eine grundlegende Eigenschaft:
// SimpleProperties.cpp
// compile with: /clr
using namespace System;
ref class C {
public:
property int Size;
};
int main() {
C^ c = gcnew C;
c->Size = 111;
Console::WriteLine("c->Size = {0}", c->Size);
}
c->Size = 111
In diesem Codebeispiel wird gezeigt, wie eine statische Eigenschaft deklariert und verwendet wird. Eine statische Eigenschaft kann nur auf statische Member ihrer Klasse zugreifen.
// mcppv2_property_3.cpp
// compile with: /clr
using namespace System;
ref class StaticProperties {
static int MyInt;
static int MyInt2;
public:
static property int Static_Data_Member_Property;
static property int Static_Block_Property {
int get() {
return MyInt;
}
void set(int value) {
MyInt = value;
}
}
};
int main() {
StaticProperties::Static_Data_Member_Property = 96;
Console::WriteLine(StaticProperties::Static_Data_Member_Property);
StaticProperties::Static_Block_Property = 47;
Console::WriteLine(StaticProperties::Static_Block_Property);
}
96
47
Eine indizierte Eigenschaft macht in der Regel eine Datenstruktur verfügbar, auf die mithilfe eines tiefgestellten Operators zugegriffen wird.
Wenn Sie eine indizierte Standardeigenschaft verwenden, können Sie nur auf die Datenstruktur zugreifen, indem Sie auf den Klassennamen verweisen. Wenn Sie jedoch eine benutzerdefinierte indizierte Eigenschaft verwenden, müssen Sie den Eigenschaftennamen angeben, um auf die Datenstruktur zuzugreifen.
Informationen zum Verwenden eines in C# geschriebenen Indexers finden Sie unter How to: Consume a C# Indexer (C++/CLI).
In diesem Codebeispiel wird gezeigt, wie Standard- und benutzerdefinierte indizierte Eigenschaften verwendet werden:
// mcppv2_property_2.cpp
// compile with: /clr
using namespace System;
public ref class C {
array<int>^ MyArr;
public:
C() {
MyArr = gcnew array<int>(5);
}
// default indexer
property int default[int] {
int get(int index) {
return MyArr[index];
}
void set(int index, int value) {
MyArr[index] = value;
}
}
// user-defined indexer
property int indexer1[int] {
int get(int index) {
return MyArr[index];
}
void set(int index, int value) {
MyArr[index] = value;
}
}
};
int main() {
C ^ MyC = gcnew C();
// use the default indexer
Console::Write("[ ");
for (int i = 0 ; i < 5 ; i++) {
MyC[i] = i;
Console::Write("{0} ", MyC[i]);
}
Console::WriteLine("]");
// use the user-defined indexer
Console::Write("[ ");
for (int i = 0 ; i < 5 ; i++) {
MyC->indexer1[i] = i * 2;
Console::Write("{0} ", MyC->indexer1[i]);
}
Console::WriteLine("]");
}
[ 0 1 2 3 4 ]
[ 0 2 4 6 8 ]
Das nächste Beispiel zeigt, wie Sie den Standardindexer mithilfe des this Zeigers aufrufen.
// call_default_indexer_through_this_pointer.cpp
// compile with: /clr /c
value class Position {
public:
Position(int x, int y) : position(gcnew array<int, 2>(100, 100)) {
this->default[x, y] = 1;
}
property int default[int, int] {
int get(int x, int y) {
return position[x, y];
}
void set(int x, int y, int value) {}
}
private:
array<int, 2> ^ position;
};
In diesem Beispiel wird gezeigt, wie DefaultMemberAttribute Sie den Standardindexer angeben:
// specify_default_indexer.cpp
// compile with: /LD /clr
using namespace System;
[Reflection::DefaultMember("XXX")]
public ref struct Squares {
property Double XXX[Double] {
Double get(Double data) {
return data*data;
}
}
};
Im nächsten Beispiel werden die Metadaten verwendet, die im vorherigen Beispiel erstellt wurden.
// consume_default_indexer.cpp
// compile with: /clr
#using "specify_default_indexer.dll"
int main() {
Squares ^ square = gcnew Squares();
System::Console::WriteLine("{0}", square[3]);
}
9
In diesem Codebeispiel wird gezeigt, wie virtuelle Eigenschaften deklariert und verwendet werden:
// mcppv2_property_4.cpp
// compile with: /clr
using namespace System;
interface struct IEFace {
public:
property int VirtualProperty1;
property int VirtualProperty2 {
int get();
void set(int i);
}
};
// implement virtual events
ref class PropImpl : public IEFace {
int MyInt;
public:
virtual property int VirtualProperty1;
virtual property int VirtualProperty2 {
int get() {
return MyInt;
}
void set(int i) {
MyInt = i;
}
}
};
int main() {
PropImpl ^ MyPI = gcnew PropImpl();
MyPI->VirtualProperty1 = 93;
Console::WriteLine(MyPI->VirtualProperty1);
MyPI->VirtualProperty2 = 43;
Console::WriteLine(MyPI->VirtualProperty2);
}
93
43
Obwohl die abstrakten und versiegelten Schlüsselwörter in der ECMA-C++/CLI-Spezifikation angegeben sind, können Sie sie für den Microsoft C++-Compiler weder für triviale Eigenschaften noch für die Eigenschaftsdeklaration einer nicht trivialen Eigenschaft angeben.
Um eine versiegelte oder abstrakte Eigenschaft zu deklarieren, müssen Sie eine nicht triviale Eigenschaft definieren und dann das abstract Schlüsselwort sealed für die Get- und Set-Accessorfunktionen angeben.
// properties_abstract_sealed.cpp
// compile with: /clr
ref struct A {
protected:
int m_i;
public:
A() { m_i = 87; }
// define abstract property
property int Prop_1 {
virtual int get() abstract;
virtual void set(int i) abstract;
}
};
ref struct B : A {
private:
int m_i;
public:
B() { m_i = 86; }
// implement abstract property
property int Prop_1 {
virtual int get() override { return m_i; }
virtual void set(int i) override { m_i = i; }
}
};
ref struct C {
private:
int m_i;
public:
C() { m_i = 87; }
// define sealed property
property int Prop_2 {
virtual int get() sealed { return m_i; }
virtual void set(int i) sealed { m_i = i; };
}
};
int main() {
B b1;
// call implementation of abstract property
System::Console::WriteLine(b1.Prop_1);
C c1;
// call sealed property
System::Console::WriteLine(c1.Prop_2);
}
86
87
Sie können multidimensionale Eigenschaften verwenden, um Eigenschaftsaccessormethoden zu definieren, die eine nicht standardmäßige Anzahl von Parametern verwenden.
// mcppv2_property_5.cpp
// compile with: /clr
ref class X {
double d;
public:
X() : d(0) {}
property double MultiDimProp[int, int, int] {
double get(int, int, int) {
return d;
}
void set(int i, int j, int k, double l) {
// do something with those ints
d = l;
}
}
property double MultiDimProp2[int] {
double get(int) {
return d;
}
void set(int i, double l) {
// do something with those ints
d = l;
}
}
};
int main() {
X ^ MyX = gcnew X();
MyX->MultiDimProp[0,0,0] = 1.1;
System::Console::WriteLine(MyX->MultiDimProp[0, 0, 0]);
}
1.1
Das folgende Beispiel zeigt, wie indizierte Eigenschaften überladen werden.
// mcppv2_property_6.cpp
// compile with: /clr
ref class X {
double d;
public:
X() : d(0.0) {}
property double MyProp[int] {
double get(int i) {
return d;
}
double get(System::String ^ i) {
return 2*d;
}
void set(int i, double l) {
d = i * l;
}
} // end MyProp definition
};
int main() {
X ^ MyX = gcnew X();
MyX->MyProp[2] = 1.7;
System::Console::WriteLine(MyX->MyProp[1]);
System::Console::WriteLine(MyX->MyProp["test"]);
}
3.4
6.8
Training
Modul
Implementieren von Klasseneigenschaften und -methoden - Training
Erfahren Sie, wie Sie Schreib-, Schreib- und Schreibschutzklasseneigenschaften mithilfe von Eigenschaftenaccessoren und Zugriffsmodifizierern implementieren und methoden und Erweiterungsmethoden für eine Klasse implementieren.