Porady: korzystanie z właściwości w języku C++/interfejsie wiersza polecenia
W tym artykule przedstawiono sposób użycia właściwości w C + +/ CLI.
Podstawowe właściwości
Dla podstawowych właściwości — te, które jedynie przypisać i pobrać element członkowski danych prywatnych — nie trzeba jawnie zdefiniować get i ustawić akcesory, ponieważ kompilator automatycznie zapewnia im j.m./ml tylko typ danych właściwości.Ten kod ilustruje podstawowe właściwości:
// 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);
}
Dane wyjściowe
Właściwości statyczne
Ten przykładowy kod ilustruje deklarować i używać właściwości statycznej.Właściwość statyczna dostęp tylko elementy statyczne w swojej klasie.
// 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);
}
Dane wyjściowe
Właściwości indeksowanych
Właściwość indeksowanych udostępnia zwykle strukturą danych, który jest dostępny za pomocą operatora indeksu dolnego.
Jeśli używasz domyślna właściwość indeksowane, struktura danych można uzyskać dostęp, po prostu odwołując się do nazwy klasy, ale jeśli używasz właściwości indeksowanych zdefiniowanych przez użytkownika, musisz określić nazwę właściwości, dostęp do struktury danych.
Aby uzyskać informacje dotyczące dostępu do indeksatora domyślne za pomocą this wskaźnik, zobacz Semantyka wskaźnika w typach wartości i odwołań.
Aby uzyskać informacje na temat zużyje indeksatorze, który został napisany w języku C#, zobacz Jak: zużywają indeksatora C# (C + +/ CLI).
Ten przykładowy kod przedstawiono sposób użycia domyślnych i właściwości indeksowanych zdefiniowanych przez użytkownika:
// 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("]");
}
Dane wyjściowe
Następny przykład pokazuje sposób wywoływania indeksatora domyślne za pomocą this wskaźnik.
// 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;
};
W przykładzie pokazano sposób użycia DefaultMemberAttribute do określenia indeksatora domyślne:
// 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;
}
}
};
Następny przykład zużywa metadanych, który jest tworzony w poprzednim przykładzie.
// consume_default_indexer.cpp
// compile with: /clr
#using "specify_default_indexer.dll"
int main() {
Squares ^ square = gcnew Squares();
System::Console::WriteLine("{0}", square[3]);
}
Dane wyjściowe
Właściwości wirtualnych
Ten przykładowy kod ilustruje deklarować i używać właściwości wirtualnych:
// 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);
}
Dane wyjściowe
Właściwości abstrakcyjny i zapieczętowany
Chociaż abstract (C++ Component Extensions) i sealed (C++ Component Extensions) słowa kluczowe są określone jako ważne ze ECMA C + +/ nie specyfikacji interfejsu wiersza polecenia, kompilator języka Visual C++ można określić je trivial właściwości ani od deklaracji właściwości właściwości nietrywialne.
Aby zadeklarować właściwości zamkniętych lub streszczenie, musi zdefiniować właściwość nietrywialne, a następnie określ abstract lub sealed słowa kluczowego w get i funkcje-Akcesory.
// 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);
}
Dane wyjściowe
Właściwości wielowymiarowych
Wielowymiarowe właściwości służy do zdefiniowania metody akcesor właściwości, które mają określoną liczbę niestandardowych parametrów.
// 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]);
}
Dane wyjściowe
Akcesory właściwości przeciążenia
Poniższy przykład pokazuje, jak do przeciążania właściwości indeksowanych.
// 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"]);
}
Dane wyjściowe