//////////////////// // // Name: Array-Backed Properties // Author: Shadow // Version: 1.0.0 // Date: 02.09.2018 // Description: Applying the Composite pattern inside // a class. // Reference: Design Patterns in Modern C++ // ( Dmitri Nesteruk ) // //////////////////// // //////////PREPROCESSOR////////// // #include #include #include #include #include #include using ui = unsigned int; using std::cout; // //////////CLASSES////////// // /* * Say we want to create a simple class for cuboids * and calculations with them. Of course, the class * would contain its side lengths. * The class would probably look the following: */ class Cuboid { private: /* * unsigned int width; * unsigned int length; * unsigned int height; * * with corresponding getters and setters * * But what about the calculations? * For example, we want to know basic things such * as the volume, the diagonal, the average * side length, or the longest side. * Because the values are splitted into single * fields, we would do something like this: * * unsigned int getVolume() const { * return width * length * height; * } * * unsigned int getDiagonal() const { * return std::sqrt( std::pow(width, 2) + std::pow(length, 2) + std::pow(height, 2) ); * } * * unsigned int getAverageSideLength() const { * return (width + length + height) / 3.0; * } * * unsigned int getLongestSide() const { * return std::max(std::max(width, length), height); * } */ /* * Disadvantages: * - Forgetting a statistic/field is quite easy * - Use of a magic number (3.0) * - Pairs of std::max() calls, especially for * more properties * - Adding a new property results in lots of * refactoring */ /* * A suggestion to avoid this is by using * array-backed properties. First, we define an * enumeration for all the fields that we need. * Alternatively, an enum class can be used. */ enum SIDELENGTHS { Width, Height, Length, Count }; /* * Notice the additional member Count, which tells * us the number of elements in our enumeration. * We can use it to construct an array of the * appropriate size for our properties. */ std::array sidelengths; public: /* * We can now proceed with the usual constructors, * functions, etc. just as we usually do, only the * syntax changes a little. */ Cuboid(ui width, ui height, ui length) { setWidth(width); setHeight(height); setLength(length); } /* * The advantage: * Calculations become very easy because all that * is necessary is to iterate over an array. */ inline ui getVolume() const { return std::accumulate( sidelengths.begin(), sidelengths.end(), 1, std::multiplies() ); } inline double getDiagonal() const { return std::sqrt( static_cast ( std::accumulate( sidelengths.begin(), sidelengths.end(), 0, [](const ui x, const ui y) { return x + y * y; } ) ) ); } inline double getAverageSideLength() const { return std::accumulate( sidelengths.begin(), sidelengths.end(), 0 ) / static_cast( Count ); } inline ui getLongestSide() const { return *std::max_element( sidelengths.begin(), sidelengths.end() ); } /* * The getters and setters don't differ a lot from * how they would have been before: */ inline ui getWidth() const { return sidelengths[Width]; } inline void setWidth(const ui newWidth) { this->sidelengths[Width] = newWidth; } inline ui getHeight() const { return sidelengths[Height]; } inline void setHeight(const ui newHeight) { this->sidelengths[Height] = newHeight; } inline ui getLength() const { return sidelengths[Length]; } inline void setLength(const ui newLength) { this->sidelengths[Length] = newLength; } /* Other stuff (not implemented) */ /* * The second advantage: Flexibility. * The code is easier to maintain, and, moreover, * adding a new property is as simple as adding * a new enum member and a pair of getter and * setter, the calculations remain the same. */ }; // //////////MAIN FUNCTION////////// // int main() { /* * Now we can create an instance and test our new * class. */ Cuboid simpleBox(2, 3, 4); cout << "SimpleBox - Values"; cout << "\nWidth: " << simpleBox.getWidth(); cout << "\nHeight: " << simpleBox.getHeight(); cout << "\nLength: " << simpleBox.getLength(); cout << "\nVolume: " << simpleBox.getVolume(); cout << "\nDiagonal Length: " << simpleBox.getDiagonal(); cout << "\nAverage Side Length: " << simpleBox.getAverageSideLength(); cout << "\nLongest Side: " << simpleBox.getLongestSide(); /* * How useful is this? * Would you actually use it in your code? * Do you see other (dis-)advantages? * Feel free to leave a comment! */ return 0; }