Comment : utiliser des propriétés dans C++/CLI
Cet article explique comment utiliser les propriétés dans C++/CLI.
Propriétés de base
Pour les propriété ces de base qui simplement assigner et extraient des données privées membre vous ne devez pas définir explicitement le get et set fonctionne parce que le compilateur les fournit automatiquement une fois donné que le type de données de la propriété.Ce code montre une propriété de base :
// 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);
}
Sortie
Propriétés statiques
Cet exemple de code montre comment déclarer et utiliser une propriété statique.Une propriété statique peut accéder uniquement aux membres statiques de la classe.
// 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);
}
Sortie
Propriétés indexées
Une propriété indexée expose généralement une structure de données qui est accessible à l'aide d'un opérateur souscrit.
Si vous utilisez une propriété indexée par défaut, vous pouvez accéder à la structure de données tout en vous référant au nom de la classe, mais si vous utilisez une propriété indexée définie par l'utilisateur, vous devez spécifier le nom de la propriété pour accéder à la structure de données.
Pour plus d'informations sur l'accès à un indexeur par défaut à l'aide de le pointeur d' this, consultez Sémantiques de ce pointeur dans les types valeur et référence.
Pour plus d'informations sur la façon d'utiliser un indexeur qui est écrite en c, consultez Comment : consommer un indexeur C# (C++/CLI).
Cet exemple de code montre comment utiliser la valeur par défaut et les propriétés indexées définies par l'utilisateur :
// 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("]");
}
Sortie
L'exemple montre comment appeler l'indexeur par défaut à l'aide de le pointeur d' this .
// 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;
};
Cet exemple montre comment utiliser DefaultMemberAttribute pour spécifier l'indexeur par défaut :
// 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;
}
}
};
L'exemple utilise les métadonnées qui est créé dans l'exemple précédent.
// consume_default_indexer.cpp
// compile with: /clr
#using "specify_default_indexer.dll"
int main() {
Squares ^ square = gcnew Squares();
System::Console::WriteLine("{0}", square[3]);
}
Sortie
Propriétés virtuelles
Cet exemple de code montre comment déclarer et utiliser les propriétés virtuelles :
// 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);
}
Sortie
Propriétés abstraites et sealed
Bien que les mots clés d' abstract (extensions du composant C++) et de sealed (extensions du composant C++) sont spécifiés comme valide dans la norme ECMA C++/CLI, pour le compilateur Visual C++, vous ne pouvez pas de spécifier des propriétés ordinaires, ni dans la déclaration de propriété d'une propriété non triviale.
Pour déclarer une propriété abstraite sealed ou, vous devez définir une propriété non triviale et spécifier le mot clé d' abstract ou d' sealed sur le get et set s'exécute.
// 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);
}
Sortie
Propriétés multidimensionnelles
Vous pouvez utiliser les propriétés multidimensionnelles pour définir les méthodes d'accesseur de propriété qui prennent un nombre non standard de paramètres.
// 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]);
}
Sortie
Accesseurs de propriété de surcharge
L'exemple suivant montre comment surcharger des propriétés indexées.
// 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"]);
}
Sortie