descargar - ¿Las propiedades similares a C#en C++ nativo?

c++ manual

Question

En C# / .NET puedes hacer algo como esto:

someThing.text = "blah";
String blah = someThing.text;

Sin embargo, el código anterior no interactúa con la cadena de texto de someThing directamente, usa una propiedad de obtener y establecer. Del mismo modo, se pueden utilizar propiedades de solo lectura.

¿Hay una manera de hacer algo similar en C++ nativo? (no C ++ .NET)

Answer 1

¿Por qué no usar el lenguaje C # en lugar de C ++ para el desarrollo nativo? ¿Para eso puede usar la utilidad IL2BC para generar código nativo de código fuente de C # y / o código de MSIL?

IL2BC se puede encontrar en este sitio

http://csnative.codeplex.com

Answer 2

En .NET, las propiedades son azúcar sintáctica para las funciones reales de get y set que se emiten detrás de escena (de hecho, son más que azúcar sintáctica porque las propiedades se emiten en la IL resultante y podrían usarse con Reflexión). Así que en C ++ necesitaría escribir explícitamente esas funciones ya que no existe una noción como propiedad.

Answer 3

La respuesta de Moo-Juice parece realmente genial, pero tiene un inconveniente: no puede usar estas propiedades como expresiones normales de tipo T , como puede hacerlo en C #.

Por ejemplo,

• a.text.c_str() no compilará ( ''class Property<std::basic_string<char> >'' has no member named ''c_str'' )
• std::cout << a.text tampoco se compilará ( template argument deduction/substitution failed )

Yo sugeriría la siguiente mejora a la template<typename T> class Property :

T& operator() ()
{
return _value;
}
T const& operator() () const
{
return _value;
}

Luego puede acceder a los miembros de la propiedad con () , como por ejemplo:

 char const *p = a.text().c_str();

Y puede usar la propiedad en expresiones donde se debe deducir el tipo:

std::cout << a.text();

Answer 4

No no hay. Solo crearías funciones de getter y setter:

someThing.setText("blah");
std::string blah = someThing.getText();

Answer 5

Probablemente, la mejor opción actualmente es usar el __declspec( property( get=get_func_name, put=put_func_name ) ) PropertyType PropertyName .

• también es apoyado por clang,
• se convierte en su getter / setter cuando se compila (no agregará ninguna nueva variable),
• en uso, es lo más cercano a una propiedad real (puede acceder a la propiedad de una propiedad ...).

Pero si estás usando otros compiladores, podrías usar macros:

#define PROPERTY_GEN(Class, Type, Name, GetMethod, SetMethod) /
class Property_##Name { /
public: /
Property_##Name(Class* parent) : _parent(parent) { } /
Type operator = (Type value) /
{ /
_parent->SetMethod(value); /
return _parent->GetMethod(); /
} /
operator Type() const /
{ /
return static_cast<const Class*>(_parent)->GetMethod(); /
} /
Property_##Name& operator =(const Property_##Name& other) /
{ /
operator=(other._parent->GetMethod()); return *this; /
}; /
Property_##Name(const Property_##Name& other) = delete; /
private: /
Class* _parent; /
} Name { this };
// PROPERTY - Declares a property with the default getter/setter method names.
#define PROPERTY(Class, Type, Name) /
PROPERTY_GEN(Class, Type, Name, get_##Name, set_##Name)

Entonces úsalos como:

class SomeClass
{
public:
PROPERTY(SomeClass, int, Value)
int get_Value() const { return _value; }
void set_Value(int value) { _value = value; }
private:
int _value = 0;
};
int main()
{
SomeClass s, c;
s.Value = 5;
c.Value = 3 * s.Value;
s.Value = c.Value;
}

También puede agregar otras variantes de macro para propiedades de solo lectura, de solo escritura y de no constantes de solo lectura. Para poder acceder a las sub-propiedades a través de ->, puede agregar operadores-> sobrecargas a la macro.

En comparación con __declspec (propiedad (...)) de microsoft, los métodos getter y setter pueden hacerse privados, pero esto no es una ventaja real, ya que el cliente puede necesitar la dirección de un getter / setter a veces. También hay una desventaja de tener una variable _parent adicional para cada propiedad, y tendría que definir explícitamente los constructores de copia para las clases primarias si se usan.

Answer 6

Sí, pero es específico del vendedor. Microsoft tiene declspec (propiedad). La implementación de C ++ Builder es un poco más avanzada (a través de la palabra clave __property específica del proveedor) en cuanto a que podría tener indexadores de acceso (que pueden ser de cualquier tipo que desee).

También revise esto (sin depender de palabras clave específicas del proveedor): http://www.codeproject.com/KB/cpp/cpp_property_indexer.aspx

Answer 7

Te advierto: no es C ++ nativo; es específico de Microsoft solamente . Pero puedes usar declspec(property) :

struct S {
int i;
void putprop(int j) {
i = j;
}
int getprop() {
return i;
}
__declspec(property(get = getprop, put = putprop)) int the_prop;
};
int main() {
S s;
s.the_prop = 5; // THERE YOU GO
return s.the_prop;
}

cf MSDN, declspec (propiedad) .

Answer 8

Una propiedad en .NET está asociada con una función de get y / o set un miembro, por lo que en realidad es solo azúcar sintáctica. Lo más cercano que puedes conseguir con C ++ es usar la sobrecarga para dar el mismo nombre al captador y al configurador:

const std::string &test() const { return text_; }
void test(const std::string &value) { text_ = value; }

Obviamente, todavía tendrá que proporcionar paréntesis para la llamada:

someThing.text("blah");
String blah = someThing.text();

Answer 9

ADVERTENCIA: ¡Esta es una respuesta irónica y es terrible!

Sí, es algo posible :)

template<typename T>
class Property
{
private:
T& _value;
public:
Property(T& value) : _value(value)
{
} // eo ctor
Property<T>& operator = (const T& val)
{
_value = val;
return *this;
}; // eo operator =
operator const T&() const
{
return _value;
}; // eo operator ()
};

Luego declara tu clase, declarando propiedades para tus miembros:

class Test
{
private:
std::string _label;
int _width;
public:
Test() : Label(_label)
, Width(_width)
{
};
Property<std::string> Label;
Property<int> Width;
};

¡Y llame al estilo C #!

Test a;
a.Label = "blah";
a.Width = 5;
std::string label = a.Label;
int width = a.Width;

Answer 10

#include <iostream>
#include <string>
using namespace std;
// ------------------------------------------------------------------
#define PROPERTY_GET_SET(CLASS, NAME, TYPE) GetSetProperty<CLASS, TYPE> NAME() { return GetSetProperty<CLASS, TYPE>(this, &CLASS::get_##NAME, &CLASS::set_##NAME); }
#define PROPERTY_GET(CLASS, NAME, TYPE) GetProperty<CLASS, TYPE> NAME() { return GetProperty<CLASS, TYPE>(this, &CLASS::get_##NAME); }
#define PROPERTY_SET(CLASS, NAME, TYPE) SetProperty<CLASS, TYPE> NAME() { return SetProperty<CLASS, TYPE>(this, &CLASS::set_##NAME); }
template <typename CLASS, typename TYPE>
struct GetSetProperty {
typedef TYPE (CLASS::*Getter_t)() const;
typedef void (CLASS::*Setter_t)(TYPE);
GetSetProperty(CLASS* instance, Getter_t getter, Setter_t setter) : m_instance(instance), m_getter(getter), m_setter(setter) {}
operator TYPE() const { return (this->m_instance->*this->m_getter)(); }
GetSetProperty<CLASS, TYPE>& operator=(TYPE value) { (this->m_instance->*this->m_setter)(value); return *this; }
CLASS* const m_instance;
const Getter_t m_getter;
const Setter_t m_setter;
};
template <typename CLASS, typename TYPE>
struct GetProperty {
typedef TYPE (CLASS::*Getter_t)() const;
GetProperty(CLASS* instance, Getter_t getter) : m_instance(instance), m_getter(getter) {}
operator TYPE() const { return (this->m_instance->*this->m_getter)(); }
CLASS* const m_instance;
const Getter_t m_getter;
};
template <typename CLASS, typename TYPE>
struct SetProperty {
typedef void (CLASS::*Setter_t)(TYPE);
SetProperty(CLASS* instance, Setter_t setter) : m_instance(instance), m_setter(setter) {}
SetProperty<CLASS, TYPE>& operator=(TYPE value) { (this->m_instance->*this->m_setter)(value); return *this; }
CLASS* const m_instance;
const Setter_t m_setter;
};
template <typename CLASS, typename TYPE>
ostream& operator<<(ostream& ostr, const GetSetProperty<CLASS, TYPE>& p) { ostr << (p.m_instance->*p.m_getter)(); return ostr; }
template <typename CLASS, typename TYPE>
ostream& operator<<(ostream& ostr, const GetProperty<CLASS, TYPE>& p) { ostr << (p.m_instance->*p.m_getter)(); return ostr; }
// ------------------------------------------------------------------
class Dummy
{
public:
Dummy() : m_value1(42) {}
PROPERTY_GET_SET(Dummy, Value1, int);
PROPERTY_GET_SET(Dummy, Value2, const string&);
protected:
virtual int get_Value1() const { return this->m_value1; }
virtual void set_Value1(int value) { this->m_value1 = value; }
virtual const string& get_Value2() const { return this->m_value2; }
virtual void set_Value2(const string& value) { this->m_value2 = value; }
private:
int m_value1;
string m_value2;
};
int main(int argc, char* argv[]) {
Dummy d;
cout << d.Value1() << endl;
d.Value1() = 3;
cout << d.Value1() << endl;
cout << d.Value2() << endl;
d.Value2() = "test";
cout << d.Value2() << endl;
return 0;
}
// ------------------------------------------------------------------