Programs written in C are very very fast. Those written in C++ can be slower due to the fact that copying object is not alway easy as copying an array of numbers. One have to call the copy constructor maybe with side effects like allocate some space. <\/p>\n
The language C++ is full backwards compatible to C. So what must we do to use classes and objects with the copy speed of C?<\/p>\n
First of all, in C there exist so called POD (plan old data) types like integers, floating point numbers as well as structs und unions. The C language have no class keyword. But classes in C++ can be POD too under certain circumstances. What exactly we need to get a class POD can be read in the C++11 Standard or under [1].
\nThe great benefit of POD types is that it can be copied by simply moving bytes in RAM from one location to another. No call to constructors is needed. That speed up copying enormously.<\/p>\n
Enough theory, lets build our own object oriented POD class!
\nLet's start with a simple class Point that represent a point in 2D. We want to construct a Point object by passing its x and y coordinate. We also want some getter and setter for the coordinates to make the member variables private.<\/p>\n
Here is our first implementation:<\/p>\n
\r\n#include < iostream >\r\n#include < type_traits >\r\n\r\nclass Point {\r\npublic:\r\n Point() : x(0), y(0) {}\r\n Point(double x, double y) : x(x), y(y) {}\r\n\r\n void setX(double x) { this->x = x; }\r\n void setY(double y) { this->y = y; }\r\n double getX() const { return x; }\r\n double getY() const { return y; }\r\n\r\nprivate:\r\n double x, y;\r\n};\r\n\r\nint main() {\r\n Point p(1,2);\r\n Point p2;\r\n\r\n std::cout << p.getX() << \" \" << p.getY() << std::endl;\r\n\r\n return 0;\r\n}\r\n<\/code><\/pre>\nPretty straight forward, right? Save it under point.cpp and compile it with:<\/p>\n
\r\n$ g++-4.7 -Wall -Wextra -std=c++11 point.cpp \r\n$ .\/a.out \r\n1 2\r\n<\/pre>\nI use as compiler gnu g++ version 4.7 to test backwards compatibility. Current is 4.9.2 and 5.0 will be released soon. But you can use any compiler as long it supports c++11. Except for g++ 4.6 thats too old.<\/p>\n
To test of a type id POD c++11 provides a simple test [2] which is defined in header file \"type_traits\". Add this line to our main() function, recompile and run again<\/p>\n
\r\nstd::cout << std::boolalpha;\r\nstd::cout << \"Point is POD \" << std::is_pod::value << \"\\n\";\r\n<\/code><\/pre>\n\r\n$ g++-4.7 -Wall -Wextra -std=c++11 point.cpp \r\n$ .\/a.out\r\n1 2\r\nPoint is POD false\r\n<\/pre>\nThis shouldn't be too much surprising. As mentioned earlier there are strict rules for when a type is POD. For example the class must be a TrivialType [3]. We can test with is_trivial().<\/p>\n
\r\nstd::cout << \"Point is TrivialType \" << std::is_trivial::value << \"\\n\";\r\n<\/code><\/pre>\n\r\n$ g++-4.7 -Wall -Wextra -std=c++11 point.cpp \r\n$ .\/a.out\r\n1 2\r\nPoint is POD false\r\nPoint is trivial false\r\n<\/pre>\nA TrivialType in turn must be TriviallyCopyable [4] and must have Trivial default constructor [5]. Lets test these:<\/p>\n
\r\nstd::cout << \"Point is TriviallyCopyable \" << std::is_trivially_copyable::value << \"\\n\";\r\nstd::cout << \"Point is trivially default-constructible \" << std::is_trivially_default_constructible::value << \"\\n\";\r\n<\/code><\/pre>\n...<\/p>\n
Unfortunately g++ 4.9 does not implement these tests. So we have to wait for version 5.
\nInstead we can have a closer look about what a \"Trivial default constructor\" is. <\/p>\n
\nThe default constructor for class T is trivial (i.e. performs no action) if all of the following is true:<\/p>\n
The constructor is not user-provided (that is, implicitly-defined or defaulted)<\/li>\n T has no virtual member functions<\/li>\n T has no virtual base classes <\/li>\n T has no non-static members with brace-or-equal initializers<\/li>\n Every direct base of T has a trivial default constructor<\/li>\n Every non-static member of class type has a trivial default constructor<\/li>\n<\/blockquote>\nRight the first condition does not hold. We provide a user default constructor which simply set x and y to zero. Lets remove this constructor and see whats happen:<\/p>\n
\r\n$ g++-4.7 -Wall -Wextra -std=c++11 point.cpp \r\npoint.cpp: In function \u2018int main()\u2019:\r\npoint.cpp:20:9: error: no matching function for call to \u2018Point::Point()\u2019\r\npoint.cpp:20:9: note: candidates are:\r\npoint.cpp:7:3: note: Point::Point(double, double)\r\npoint.cpp:7:3: note: candidate expects 2 arguments, 0 provided\r\npoint.cpp:4:7: note: constexpr Point::Point(const Point&)\r\npoint.cpp:4:7: note: candidate expects 1 argument, 0 provided\r\npoint.cpp:4:7: note: constexpr Point::Point(Point&&)\r\npoint.cpp:4:7: note: candidate expects 1 argument, 0 provided\r\n<\/pre>\nIt seems we don't have any default constructor anymore. Only the explicit user defined with two arguments and the implicit copy constructor. Thats right. That c++ standard say, that when a explicit user constructor is provided, the compiler don't have to create default constructors. <\/p>\n
With the new 2011 standard we can explicit request a implicit default constructor!
\nReplace this line with the following:<\/p>\n
\r\nPoint() : x(0), y(0) {}\r\nPoint() = default;\r\n<\/code><\/pre>\n\r\n$ g++-4.7 -Wall -Wextra -std=c++11 point.cpp \r\n$ .\/a.out \r\n1 2\r\nPoint is POD true\r\nPoint is TrivialType true\r\n<\/pre>\nCongratulations! We have a object oriented class that is as fast as old C style stuff.<\/p>\n
One important note: Variables in C are not automatic initialized! So our class Point is also not default initialized! See [6] for details. You have to call a constructor explicit e.g.
\nPoint p = Point();<\/code><\/p>\nHere is some nice code to make sure your types are POD. If something goes wrong and the
\ntype is not POD, it gave an compiler error<\/p>\n
\r\n#if __cplusplus >= 201103L\r\nstatic_assert(!std::is_polymorphic::value, \"Please do not add virtual functions to class Point!\");\r\nstatic_assert(std::is_pod::value, \"Class Point is not POD!\");\r\n#endif\r\n<\/code><\/pre>\nThe #if __cplusplus stuff is to check if the compiler has enabled c++11 standard.
\nDid you know that gnu g++ has set __cplusplus simply to 1 and this bug was know over 10 years?! The reason is very simple: If they fix it, they broke solaris 8. See [7]. Stupid non standard compliant solaris 8 code!<\/p>\n