Útmutató: Tulajdonságok használata a C++/CLI-ben

Ez a cikk bemutatja, hogyan használhatja a tulajdonságokat a C++/CLI-ben.

Alapvető tulajdonságok

Az alaptulajdonságok esetében – amelyek csak egy privát adattagot rendelnek hozzá és kérnek le – nem kell explicit módon meghatároznia a beolvasási és beállítási függvényeket, mert a fordító automatikusan biztosítja őket, ha csak a tulajdonság adattípusát adja meg. Ez a kód egy alaptulajdonságot mutat be:

// 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

Statikus tulajdonságok

Ez a kódminta bemutatja, hogyan deklarálhat és használhat statikus tulajdonságot. A statikus tulajdonságok csak az osztály statikus tagjaihoz férhetnek hozzá.

// 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

Indexelt tulajdonságok

Az indexelt tulajdonság általában egy alsó index operátorral elért adatstruktúrát tesz elérhetővé.

Ha alapértelmezett indexelt tulajdonságot használ, csak az osztálynévre hivatkozva érheti el az adatstruktúrát, de ha felhasználó által definiált indexelt tulajdonságot használ, meg kell adnia a tulajdonság nevét az adatstruktúra eléréséhez.

A C#-ban írt indexelők használatáról további információt a Hogyan: C# indexelő használata (C++/CLI) című témakörben talál.

Ez a kódminta bemutatja, hogyan használható az alapértelmezett és a felhasználó által definiált indexelt tulajdonságok:

// 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 ]

A következő minta bemutatja, hogyan hívhatja meg az alapértelmezett indexelőt az this egérmutató használatával.

// 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;
};

Ez a példa bemutatja, hogyan használható a DefaultMemberAttribute az alapértelmezett indexelő megadásához.

// 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;
      }
   }
};

A következő minta az előző példában létrehozott metaadatokat használja fel.

// consume_default_indexer.cpp
// compile with: /clr
#using "specify_default_indexer.dll"
int main() {
   Squares ^ square = gcnew Squares();
   System::Console::WriteLine("{0}", square[3]);
}

Virtuális tulajdonságok

Ez a kódminta bemutatja, hogyan deklarálhatja és használhatja a virtuális tulajdonságokat:

// 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

Absztrakt és lezárt tulajdonságok

Bár az absztrakt és a lezárt kulcsszavak érvényesként vannak megadva az ECMA C++/CLI specifikációjában, a Microsoft C++ fordító esetében nem adhatja meg őket a triviális tulajdonságokon, sem a nem triviális tulajdonság tulajdonságdeklarációján.

Lezárt vagy absztrakt tulajdonság deklarálásához először meg kell határoznia egy nem triviális tulajdonságot, majd a abstract vagy sealed kulcsszót kell használnia a get és set hozzáférési függvényeken.

// 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

Többdimenziós tulajdonságok

Többdimenziós tulajdonságok használatával definiálhat olyan tulajdonságkiegészítési metódusokat, amelyek nem szabványos számú paramétert vesznek igénybe.

// 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

Tulajdonság hozzáférésvezérlők túlterhelése

Az alábbi példa bemutatja, hogyan lehet túlterhelni az indexelt tulajdonságokat.

// 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

Lásd még

ingatlan

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-11-07