How to do Object Properties in C++

ericflee — Fri, 18 Apr 2008 01:03:00 GMT

One of the many useful features of modern languages like C# are object properties, as they provide a higher level of encapsulation than public fields. The field-like syntax is far easier to read and write than traditional C++ GetXXX and SetXXX functions.

It’s surprising how many people don’t know that Visual C++ has properties too. Microsoft added property fields into C++ as a language extension back in the days when COM programming was all the rage. As with most C++ language extensions, the syntax is a bit clumsy; this one uses a Microsoft specific __declspec compiler directive. The syntax is:

__declspec ( property ( get=nameOfGetFunction, put=nameOfSetFunction ) ) typeExpressing propertyName

When the compiler sees a data member declared with this attribute on the right of a member-selection operator ("." or "->"), it converts the operation to a get or put function, depending on whether such an expression is an l-value or an r-value. In more complicated contexts, such as "+=", a rewrite is performed by doing both get and put. A property can also be declared read-only or write-only by specifying only the get or put function respectively.

To make life a little easier, I introduce a header file “C++ Properties.h” with the following macros:

#define PROPERTY(TYPE, NAME) __declspec(property(get=Get##NAME,put=Set##NAME)) TYPE NAME
#define READONLY_PROPERTY(TYPE, NAME) __declspec(property(get=Get##NAME)) TYPE NAME
#define WRITEONLY_PROPERTY(TYPE, NAME) __declspec(property(put=Set##NAME)) TYPE NAME

Notice that these macros use preprocessor token pasting so that the get and put functions always map to GetXXX and SetXXX, where XXX is the name of the property. This allows us to declare classes with properties in a very readable form; for example:

class GamePad
{
public:
        . . .
        READONLY_PROPERTY(bool, IsConnected);
        bool GetIsConnected() const;
        . . .
};

While not quite as elegant as the built in property syntax in C#, it’s not a bad substitute.

You can declare virtual C++ properties simply by making the getter and/or setter methods virtual. Similarly, abstract properties can be defined by using pure virtual getter and/or setter methods. For example:

class GamePad
{
public:
        . . .
        READONLY_PROPERTY(bool, IsConnected); // virtual property
        virtual bool GetIsConnected() const;

        READONLY_PROPERTY(float, PollingRate); // abstract property
        virtual float GetPollingRate() const = 0;
        . . .
};

Note that the const semantics for the property are determined by the getter or setter method.

Array semantics are also supported. The syntax is basically the same, but with an added “[]”, as follows:

__declspec ( property ( get=nameOfGetFunction, put=nameOfSetFunction ) ) typeExpressing propertyName[]

The accessor function simply needs to take an index argument. Although we can use our existing macros for arrays, as follows

class GamePad
{
public:
        . . .
        READONLY_PROPERTY(ButtonState, Buttons)[];
        ButtonState GetButtons(size_t buttonIndex);
        . . .
};

// And used like:
GamePad gamePad;
. . .
ButtonState buttonState = gamepad.Buttons[3];

I find it somewhat less confusing to have additional macros in “C++ Properties.h”

#define ARRAY_PROPERTY(TYPE, NAME) __declspec(property(get=Get##NAME,put=Set##NAME)) TYPE NAME[]
#define READONLY_ARRAY_PROPERTY(TYPE, NAME) __declspec(property(get=Get##NAME)) TYPE NAME[]
#define WRITEONLY_ARRAY_PROPERTY(TYPE, NAME) __declspec(property(put=Set##NAME)) TYPE NAME[]

Changing the above class into:

class GamePad
{
public:
        . . .
        READONLY_ARRAY_PROPERTY(ButtonState, Buttons);
        ButtonState GetButtons(size_t buttonIndex);
        . . .
};

The array access functions can also be multidimensional:

class Picture
{
public:
        . . .
        READONLY_ARRAY_PROPERTY(Color, Pixels);
        Color GetPixels(unsigned int x, unsigned int y);
        . . .
};

// And used like:
Picture picture;
. . .
Color colorAt = picture.Pixels[x][y];

Because Properties provide a higher level of encapsulation than public fields, I often find myself exposing private fields through const properties.

class GamePad
{
public:
        . . .
        READONLY_PROPERTY(bool, IsConnected);
        bool GetIsConnected() const { return isConnected_; }
        . . .
private:
        bool isConnected_;
};

Just like traditional accessor functions, this enables internal members to change the isConnected_ state while exposing the state to the public scope as a const property. This pattern is so very common that I introduce an explicit property macro for it:

#define READONLY_PROPERTY_RVALUE(TYPE, NAME, RVALUE_EXPR) \
__declspec(property(get=Get##NAME)) TYPE NAME; \
TYPE Get##NAME() const { return RVALUE_EXPR; }

For symmetry I also add the following two macros, though admittedly they’re rarely used (and many of my colleagues hate them).

#define PROPERTY_VALUE(TYPE, NAME, RVALUE_EXPR, LVALUE_EXPR) \
__declspec(property(get=Get##NAME,put=Set##NAME)) TYPE NAME; \
TYPE Get##NAME() const { return RVALUE_EXPR; } \
void Set##NAME(TYPE newValue) { LVALUE_EXPR = newValue; }

#define WRITEONLY_PROPERTY_LVALUE(TYPE, NAME, LVALUE_EXPR) \
__declspec(property(put=Set##NAME)) TYPE NAME; \
void Set##NAME(TYPE newValue) { LVALUE_EXPR = newValue; }

Although it would preferable for C++ properties to have a cleaner built-in syntax, these macros provide enough of an abstraction to enable use of properties without sacrificing readability.

#pragma once

ericflee — Fri, 18 Apr 2008 01:02:00 GMT

Most C++ compilers now support the non-standard #pragma once compiler directive. This directive instructs the compiler to #include the file only once in a single compiland, and replaces the old C-style header sentinels (often called #include guards).

The central problem with preprocessor based header sentinels is that they require the user to create a unique symbol to identify each and every header file that might be #included by a single compiland. On very large projects, this burden becomes somewhat painful. Consider also the distinct possibility that two libraries might contain public header files with the exact same name; using the typical __FILENAME_H__ convention, its very possible to run into name collision between the two libraries. Some project teams attempt to avoid this problem by imposing a strict sentinel naming standard, usually including a file's path as part its sentinel name. I'm not fond of this solution because if a header file needs to be moved, as occurs when refactoring a library, it requires that the header file be edited to conform to its new location. The #pragma once directive avoids all this nonsense entirely.

A secondary problem is one of efficiency. The #pragma once directive allows the compiler to avoid opening and preprocessing a header file after its been seen once. Although it is technically possible for a compiler to implement a similar mechanism when it encounters the header sentinel pattern (GCC can do this for instance), the mechanism is a bit fragile because it depends on a user following an exact coding pattern for the optimization to work correctly. I’ve encountered code patterns in library header files that appear to be the header-sentinel pattern, but are in fact not. Moreover, the compiler must account for the fact that preprocessor symbols can be explicitly #undef’d. I much prefer the explicit directive because it states exactly the intention of the programmer -- "include this header only once".

Unfortunately for users of GCC, this compiler directive has been deprecated (although it’s still supported last time I checked). It’s my personal opinion that this is yet another case of Gnu’s pervasive NIH syndrome (they got it bad), however the official reason is that the construct is not portable (which I admit is technically true). I do not understand why the standards committee hasn’t adopted it into the ISO standard. It’s a trivial compiler feature to implement. Although its not an official language feature, most C/C++ compilers support it.

Eric Fleegal's WebLog : C++ Programming

How to do Object Properties in C++

#pragma once