blocks|key|871655|text|在.NET中，属性是在幕后发出的实际get和set函数的语法糖(实际上，它们不仅仅是语法糖，因为属性是在生成的IL中发出的，并且可以与反射一起使用)。因此，在C%2B%2B中，您需要显式地编写这些函数，因为没有属性这样的概念。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|871656|entityMap^0|I|3|M|3|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

In .NET properties are syntactic sugar for the real <code>get</code> and <code>set</code> functions which are emitted behind the scenes (in fact they are more than syntactic sugar because properties are emitted in the resulting IL and could be used with Reflection). So in C++ you would need to explicitly write those functions as there's no such notion as property.

blocks|key|1086540|text|.NET中的属性与get和/或set成员函数相关联，因此它实际上只是语法糖。使用C%2B%2B最接近的方法是使用重载来赋予getter和setter相同的名称：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1086541|const+std::string+&test()+const+{+return+text_;+}
void+test(const+std::string+&value)+{+text_+=+value;+}|code-block|syntax|javascript|1086542|显然，您仍然需要为调用提供括号：|1086543|someThing.text("blah");
String+blah+=+someThing.text();|1086544|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/.NET_Framework^0|9|3|F|3|0|4|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@$9|11|A|12|1|13]]|E|$]]|$1|F|3|G|5|H|7|14|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|15|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|16|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

A property in <a href="http://en.wikipedia.org/wiki/.NET_Framework" rel="nofollow">.NET</a> is associated with a <code>get</code> and/or a <code>set</code> member function, so it's really just syntactic sugar. The closest you can get with C++ is to use overloading to give the getter and setter the same name:

<pre><code>const std::string &amp;test() const { return text_; }
void test(const std::string &amp;value) { text_ = value; }
</code></pre>

Obviously, you will still have to provide parenthesis for the call:

<pre><code>someThing.text("blah");
String blah = someThing.text();
</code></pre>

blocks|key|871848|text|是的，但这是特定于供应商的。微软有declspec(属性)。C%2B%2BBuilder的实现更高级一些(通过特定于供应商的__property关键字)，因为您可以有索引访问器(可以是您希望的任何类型)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|871849|还要检查一下(不依赖于特定于供应商的关键字)：http://www.codeproject.com/KB/cpp/cpp_property_indexer.aspx|offset|length|871850|entityMap|0|LINK|mutability|MUTABLE|url|http://www.codeproject.com/KB/cpp/cpp_property_indexer.aspx^0|0|N|1N|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

Yes but it's vendor specific. Microsoft has declspec(property).
C++Builder's implementation is a bit more advanced (via vendor specific __property keyword) in that you could have indexed accessors (which can be of any types you wish).

Also check this out (without relying on vendor specific keywords): <a href="http://www.codeproject.com/KB/cpp/cpp_property_indexer.aspx" rel="nofollow">http://www.codeproject.com/KB/cpp/cpp_property_indexer.aspx</a>

blocks|key|1086627|text|#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;
}

//+------------------------------------------------------------------|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1086628|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>#include &lt;iostream&gt;
#include &lt;string&gt;

using namespace std;

// ------------------------------------------------------------------

#define PROPERTY_GET_SET(CLASS, NAME, TYPE) GetSetProperty&lt;CLASS, TYPE&gt; NAME() { return GetSetProperty&lt;CLASS, TYPE&gt;(this, &amp;CLASS::get_##NAME, &amp;CLASS::set_##NAME); }
#define PROPERTY_GET(CLASS, NAME, TYPE) GetProperty&lt;CLASS, TYPE&gt; NAME() { return GetProperty&lt;CLASS, TYPE&gt;(this, &amp;CLASS::get_##NAME); }
#define PROPERTY_SET(CLASS, NAME, TYPE) SetProperty&lt;CLASS, TYPE&gt; NAME() { return SetProperty&lt;CLASS, TYPE&gt;(this, &amp;CLASS::set_##NAME); }

template &lt;typename CLASS, typename TYPE&gt;
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-&gt;m_instance-&gt;*this-&gt;m_getter)(); }
 GetSetProperty&lt;CLASS, TYPE&gt;&amp; operator=(TYPE value) { (this-&gt;m_instance-&gt;*this-&gt;m_setter)(value); return *this; }
 CLASS* const m_instance;
 const Getter_t m_getter;
 const Setter_t m_setter;
};

template &lt;typename CLASS, typename TYPE&gt;
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-&gt;m_instance-&gt;*this-&gt;m_getter)(); }
 CLASS* const m_instance;
 const Getter_t m_getter;
};

template &lt;typename CLASS, typename TYPE&gt;
struct SetProperty {
 typedef void (CLASS::*Setter_t)(TYPE);
 SetProperty(CLASS* instance, Setter_t setter) : m_instance(instance), m_setter(setter) {}
 SetProperty&lt;CLASS, TYPE&gt;&amp; operator=(TYPE value) { (this-&gt;m_instance-&gt;*this-&gt;m_setter)(value); return *this; }
 CLASS* const m_instance;
 const Setter_t m_setter;
};

template &lt;typename CLASS, typename TYPE&gt;
ostream&amp; operator&lt;&lt;(ostream&amp; ostr, const GetSetProperty&lt;CLASS, TYPE&gt;&amp; p) { ostr &lt;&lt; (p.m_instance-&gt;*p.m_getter)(); return ostr; }

template &lt;typename CLASS, typename TYPE&gt;
ostream&amp; operator&lt;&lt;(ostream&amp; ostr, const GetProperty&lt;CLASS, TYPE&gt;&amp; p) { ostr &lt;&lt; (p.m_instance-&gt;*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&amp;);

protected:

 virtual int get_Value1() const { return this-&gt;m_value1; }
 virtual void set_Value1(int value) { this-&gt;m_value1 = value; }

 virtual const string&amp; get_Value2() const { return this-&gt;m_value2; }
 virtual void set_Value2(const string&amp; value) { this-&gt;m_value2 = value; }

private:

 int m_value1;
 string m_value2;
};


int main(int argc, char* argv[]) {

 Dummy d;

 cout &lt;&lt; d.Value1() &lt;&lt; endl;
 d.Value1() = 3;
 cout &lt;&lt; d.Value1() &lt;&lt; endl;

 cout &lt;&lt; d.Value2() &lt;&lt; endl;
 d.Value2() = "test";
 cout &lt;&lt; d.Value2() &lt;&lt; endl;

 return 0;
}

// ------------------------------------------------------------------
</code></pre>

blocks|key|1086717|text|通过使用std::function，您可以非常接近。在功能方面，所有的东西都在这里。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1086718|首先创建模板化的属性类：|1086719|#include+<functional>

template<class+T>
class+Property
{
++++std::function<T+(void)>+_get;
++++std::function<void(const+T&)>+_set;
public:
++++Property(
++++++++std::function<T+(void)>+get,
++++++++std::function<void(const+T&)>+set)
++++++++:+_get(get),
++++++++++_set(set)
++++{+}

++++Property(
++++++++std::function<T(void)>+get)
++++++++:+_get(get),
++++++++++_set([](const+unsigned+int&){})
++++{+}

++++operator+T+()+const+{+return+_get();+}
++++void+operator+=+(const+T&+t)+{+_set(t);+}
};|code-block|syntax|javascript|1086720|通过创建与do+C#中类似的get和set方法，在类中使用该属性：|1086721|class+Test
{
private:
++++std::string++_label;

public:
++++Property<std::string>+Label+=+Property<std::string>
++++(
++++++++[this]()->std::string
++++++++{
++++++++++++return+this->_label;
++++++++},
++++++++[this](const+std::string&+value)
++++++++{
++++++++++++this->_label+=+value;
++++++++}
++++);
++++Property<unsigned+int>+LabelSize+=+Property<unsigned+int>
++++(
++++++++[this]()->unsigned+int
++++++++{
++++++++++++return+this->_label.size();
++++++++}
++++);
};|1086722|测试以下代码：|1086723|Test+test;
test.Label+=+"std+functional";

std::cout+<<+"label++++++=+"+<<+std::string(test.Label)+<<+std::endl
++++++++++<<+"label+size+=+"+<<+int(test.LabelSize)+<<+std::endl;|1086724|将输出|1086725|label++++++=+std+functional
label+size+=+14|1086726|我认为这是你在c%2B%2B中能得到的语法糖衣:)|1086727|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|15|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|U|3|V|5|6|7|17|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

By using std::function you can get pretty close. Featurewise everything is here.

First create the templated Property class:

<pre><code>#include &lt;functional&gt;

template&lt;class T&gt;
class Property
{
 std::function&lt;T (void)&gt; _get;
 std::function&lt;void(const T&amp;)&gt; _set;
public:
 Property(
 std::function&lt;T (void)&gt; get,
 std::function&lt;void(const T&amp;)&gt; set)
 : _get(get),
 _set(set)
 { }

 Property(
 std::function&lt;T(void)&gt; get)
 : _get(get),
 _set([](const unsigned int&amp;){})
 { }

 operator T () const { return _get(); }
 void operator = (const T&amp; t) { _set(t); }
};
</code></pre>

Use the Property in a class by creating a get and a set method similar to what you would in do C#:

<pre><code>class Test
{
private:
 std::string _label;

public:
 Property&lt;std::string&gt; Label = Property&lt;std::string&gt;
 (
 [this]()-&gt;std::string
 {
 return this-&gt;_label;
 },
 [this](const std::string&amp; value)
 {
 this-&gt;_label = value;
 }
 );
 Property&lt;unsigned int&gt; LabelSize = Property&lt;unsigned int&gt;
 (
 [this]()-&gt;unsigned int
 {
 return this-&gt;_label.size();
 }
 );
};
</code></pre>

Testing this code:

<pre><code>Test test;
test.Label = "std functional";

std::cout &lt;&lt; "label = " &lt;&lt; std::string(test.Label) &lt;&lt; std::endl
 &lt;&lt; "label size = " &lt;&lt; int(test.LabelSize) &lt;&lt; std::endl;
</code></pre>

will output

<pre><code>label = std functional
label size = 14
</code></pre>

I think this is as syntactic-sugar-coated as you can get it in c++ :)

blocks|key|871716|text|不，没有。您只需创建getter和setter函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|871717|someThing.setText("blah");
std::string+blah+=+someThing.getText();|code-block|syntax|javascript|871718|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

No, there is not. You would just create getter and setter functions:

<pre><code>someThing.setText("blah");
std::string blah = someThing.getText();
</code></pre>

In <a href="http://en.wikipedia.org/wiki/C_Sharp_%28programming_language%29">C#</a> / <a href="http://en.wikipedia.org/wiki/.NET_Framework">.NET</a> you can do something like this:

<pre><code>someThing.text = "blah";
String blah = someThing.text;
</code></pre>

However, the above code does not actually interact with the someThing's text String directly, it uses a get and set property. Similarly, read-only properties can be used.

Is there a way to do something similar in native <a href="https://en.wikipedia.org/wiki/C++">C++</a>? (not C++ .NET)

C#-like properties in native C++?

在 / 中，你可以这样做：someThing.text = "blah";String blah = someThing.text;然而，上面的代码实际上并不直接与某物的文本字符串交互，它使用了一个get和set属性。同样，也可以使用只读属性。有没有办法在原生中做类似的事情？(不是C++ .NET)

问原生C++中类似C#的属性？
EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问原生C++中类似C#的属性？EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问原生C++中类似C#的属性？
EN