Object Properties in C++

Many modern programming languages support the concept of a property -- a class member that combines characteristics of both a data member and a method.  These are sometimes called "smart fields" because you can add logic that is applied automatically each time the field/variable is used.  Alas, standard C++ does not directly support such a concept, but this article discusses some options you can use to implement properties in your C++ objects.

Properties are a first-class language element of C#, Visual Basic, Delphi, Python and other languages.  Over the years, proposals have been submitted to C++ standards committee to add the feature to our favorite programming language, but it's never quite made it into an official standard.

Why Properties?

What's the point?  Why use properties?  

The main idea is based on something that programmers have been struggling with probably ever since Lady Lovelace wrote the first computer algorithm -- data encapsulation.  You want to manage and limit direct access to data elements so that only those parts of the program that need it can get to it.  But the usefulness of properties goes well beyond that.  Here are some things you can do with properties and some examples:
 

Accessors: getters and putters

If you recognized any of the above scenarios (that is, if you have done much C++ coding), you have probably written your share of getXxxx() and putXxxx() member functions in your class objects.  And you have run into the problem:  Using accessor methods can be syntactically awkward:

oList.putElement( n, oList.getElement(n)+1 ); // thread-safe getter+putter
                      oAddr.putZIP( sZip );   // range-enforcement putter
                      oWin.putPosition( r );  // hidden-details putter

Select all Open in new window

...instead of simply:

oList[n]++;            // could use thread-locking logic 
                      oAddr.sZipCode= sZip;  // could enforce valid content (5 or 9 digits)
                      oWin.Position= r       // calls MoveWindow()

Select all Open in new window

In short, that's what this is all about:  Anything that you can do with a property can be done with a pair of get/put member functions, but the programming is not as convenient.  Why should VB and C# programmers have all of that heavenly convenience while we poor C++ programmers are damned to spend eternity in a get-and-put purgatory?

Well, we are not.  First, several popular C++ compilers provide non-standard support for properties.  But even lacking direct support, the C++ language boasts the ability to write operator overrides... and that means that it is possible to implement property semantics.

C++ Property Implementations

Several compilers provide non-standard extensions, and there are a number of ways to attack the problem using templates and/or macros.  Let's look at the options.

Non-Standard Extensions

For many of us, the first and most obvious place to look is in our compiler's documentation.  If it provides a non-standard extension with support for properties, then unless you intend to port the code to a different compiler, why not use it?

Microsoft's Visual C++ has supported such a non-standard extension since (at least) the 2003 release.  It works perfectly and is easy to use.  You just add...
 
      __declspec( property( get=YourGetFn, put=YourPutFn ) ) int yourPropVarName;

... in your class declaration.  Code up the YourGetFn and YourPutFn and add the private variable that they will access, and you are done.

// Range-check and "correct" a percentage value
                      //
                      class PollData {
                      private:
                          int mp_nPrivateValue;
                      public:
                          void putPct(int n) {              // enforces a specific range of values
                              mp_nPrivateValue= n;
                              if (n>100) mp_nPrivateValue= 100;
                              if (n<0)   mp_nPrivateValue= 0;
                          }
                          int getPct() {
                              return mp_nPrivateValue;
                          }
                          __declspec(property(get= getPct, put= putPct)) int nPct; // <<-- property name
                      };
                      void main() {
                          PollData rPD;
                          rPD.nPct= 200;  // pinned to 100
                          rPD.nPct= -10;  // pinned to 0
                          rPD.nPct++;     // internally calls getPct and putPct
                         // r.mp_nPrivateValue=50; // Compile error: "cannot access private member"
                      }

Select all Open in new window

That works whether you are programming native or using CLI (incidentally, the ECMA C++/CLI standard elevates property to first class status and you don't need to use the somewhat awkward _declspec syntax in the declaration when doing .NET progamming).

Note that the semantics are perfect -- property variables work transparently to the code that uses them.  For instance, you can use syntax like propVar++ and it will correctly do a get, add 1, and then do the put.

Borland's (now Embarcadero's) C++ Builder supports this using the __property keyword.  There is an example of use here (midway down the page).

For Apple programmers, Objective C++ provides non-standard support using the @property directive.  See an example here.

Support using only Standard C++

In researching this article, I found a number of "solutions" to the C++ property "problem."  I also found many vociferous opinions.  A lot of people think that C++ has no need to be more "VB-like," while others embrace the idea wholeheartedly.  Anyway, here are of few of the Standard C++ implementations that I found.
 

Conclusion

I mostly agree with Lois Goldwaite that the whole issue of properties amounts to "syntactic saccharine" -- a sugar coating over the underlying nougat.  I'd generally rather just add getXxxx and a putXxxx functions (and do all of the "hard work" of using them when I access certain fields) than apply a complex set of templates and macros.

However, I disagree that it should never be part of the C++ standard.  If property were elevated into a first class language keyword, I'd probably use it all of the time.   My advice is that if you don't mind stepping outside of the official C++ standard, and if your compiler supports the feature (even as a non-standard extension)... use it!

The usefulness of "smart fields" cannot be questioned.  Data validation, source transparency, true encapsulation, and the value of hiding (and being able to change) implementation details such as OS/GUI-related API calls --- all covered with a "syntactic sucralose" to make it easy to use... sounds sweeeeet to me!

=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
If you liked this article and want to see more from this author, please click the Yes button near the:
      Was this article helpful?
label that is just below and to the right of this text.   Thanks!
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=