PROGRAMMING TECHNIQUES Based on “Modern C++ Design” BY ALEXANDRESCU BOGDAN PENKOVSKY 2010

PROGRAMMING TECHNIQUES WHAT’S ALL THIS STAFF ABOUT?

PROGRAMMING TECHNIQUES WHAT’S ALL THIS STAFF ABOUT? Through all the “Modern C++ design” some essential techniques are stretched. Bold knowledge of them will help to understand main ideas and… create powerful idioms. So, we’re going to review and discuss main PROGRAMMING TECHNIQUES

PROGRAMMING TECHNIQUES TECHNIQUES Compile-Time Assertions Partial Template Specialization Local Classes Mapping Integral Constants to Types Type-to-Type Mapping

PROGRAMMING TECHNIQUES TECHNIQUES Type Selection Detecting Convertibility and Inheritance at Compile Time A Wrapper Around type_info NullType and EmptyType Type Traits

PROGRAMMING TECHNIQUES The need for better static checking (and more customizable error messages) template To safe_reinterpret_cast(From from) { assert (sizeof(From) <= sizeof(To)); return reinterpret_cast(from); } int i=…; char*p=safe_reinterpret_cast (i);

PROGRAMMING TECHNIQUES Safe_reinterpret_cast function Problem: Runtime detecting. Detecting on compilation would be better. Reason: Porting the application to a new compiler might leave the bug dormant until it crashes the program in front of your customer.

PROGRAMMING TECHNIQUES Compile time assertion #define STATIC_CHECK(expr) { char unnamed[( expr)? :1 : 0]; } template To safe_reinterpret_cast(From from) { STATIC_CHECK(sizeof(From) <= sizeof(To)); return reinterpret_cast (from); } void* somePointer=…; char c=safe_reinterpret_cast (somePointer);

PROGRAMMING TECHNIQUES Static_check Non zero-length array approach Problem: Not terribly informative: "Cannot create array of size zero" does not suggest "Type char is too narrow to hold a pointer."

PROGRAMMING TECHNIQUES What we can improve? A better solution is to rely on a template with an informative name; the compiler will mention the name of that template in the error message

PROGRAMMING TECHNIQUES Template CompileTimeChecker template struct CompileTimeChecker; { CompileTimeChecker(…); }; template<> struct CompileTimeChecker {}; #define STATIC_CHECK(expr, msg) \ {\ class ERROR_##msg {}; \ (void)sizeof(CompileTimeChecker ((ERROR_##msg())));\ }

PROGRAMMING TECHNIQUES Let’s test Assume that sizeof(char) < sizeof(void*) (not guaranteed) template To safe_reinterpret_cast(From from) { STATIC_CHECK(sizeof(From) <= sizeof(To), Destination_Type_Too_Narrow); return reinterpret_cast (from); }... void* somePointer =...; char c = safe_reinterpret_cast (somePointer);

PROGRAMMING TECHNIQUES After macro preprocessing template To safe_reinterpret_cast(From from) {  { class ERROR_Destination_Type_Too_Narrow {}; (void)sizeof( CompileTimeChecker ( ERROR_Destination_Type_Too_Narrow ()));  } return reinterpret_cast (from); }

PROGRAMMING TECHNIQUES Template CompileTimeChecker Now here is a trick! The CompileTimeChecker specialization has a constructor that accepts anything. This means that if the expression checked evaluates to true, the resulting program is valid. If the comparison between sizes evaluates to false we can see a message: "Error: Cannot convert ERROR_Destination_Type_Too_Narrow to CompileTimeChecker."

PROGRAMMING TECHNIQUES NOT BAD? LET’S MOVE FORWARD!

PROGRAMMING TECHNIQUES ONLY ABOUT 50 SLIDES LEFT!

PROGRAMMING TECHNIQUES Partial Template Specialization template class Widget {.. Generic implementation... }; And explicit specialization: template <> class Widget {... Specialized implementation... };

PROGRAMMING TECHNIQUES Partial Template Specialization It allows to specialize a class template for subsets of that template's possible instantiations set. Typically, in a partial specialization of a class template, it is specified only some of the template arguments and the other ones are left generic.

PROGRAMMING TECHNIQUES Capabilities When you instantiate a template, the compiler does a pattern matching of existing partial and total specializations to find the best candidate This gives an enormous flexibility.

PROGRAMMING TECHNIQUES Partial Template Flexibility template class Widget, MyController> {... further specialized implementation... };

PROGRAMMING TECHNIQUES Limitations Although you can totally specialize member functions of a class template, you cannot partially specialize member functions. You cannot partially specialize namespace-level (nonmember) template functions. The only closest is overloading. So you have fine-grained specialization abilities only for the function parameters That is because “bad” compiler writers make their lives easier.

PROGRAMMING TECHNIQUES Partial Function Templates template T Fun(U obj); // primary template template void Fun (U obj); // illegal partial // specialization template T Fun (Window obj); //legal (overloading)

PROGRAMMING TECHNIQUES LOCAL CLASSES void Fun() { class Local {... methods... };... code used by local class... }

PROGRAMMING TECHNIQUES Limitations There’s no way to define static member variables No way to access nonstatic local variables Any idiom that uses a local class can be implemented using a template class outside the function

PROGRAMMING TECHNIQUES Advantages Local classes defined inside template functions can use the template parameters of the enclosing function Unique feature: local classes are final. Without them, you'd have to add an unnamed namespace in a separate translation unit.

PROGRAMMING TECHNIQUES LOCAL CLASSES INSIDE TEMPLATE FUNCTIONS (idiom) class Interface { public: virtual void Fun() =0; … };

PROGRAMMING TECHNIQUES INSIDE TEMPLATE FUNCTIONS template Interface* MakeAdapter(const T& obj, const P& arg) { class Local : public Interface { public: Local(const T& obj, const P& arg): obj_(obj), arg_(arg) {} virtual void Fun() { obj_.Call(arg_); } private: T obj_; P arg_; }; return new Local(obj, arg); }

PROGRAMMING TECHNIQUES Mapping Integral Constants to Types template struct lnt2Type { enum { value = v }; };

PROGRAMMING TECHNIQUES Mapping Integral Constants to Types Int2Type generates a distinct type for each distinct constant integral value passed. Can be used whenever there’s need to "typify" an integral constant quickly Achieves dispatching on a constant integral value.

PROGRAMMING TECHNIQUES Int2Type Typical use: You need to call one of several different functions, depending on a compile-time constant. You need to do this dispatch at compile time. Differently from else-if statement, Int2Type doesn’t require compilation of both code branches. I.E.:

PROGRAMMING TECHNIQUES NiftyContainer template class NiftyContainer { void DoSomething() { T* pSomeObj =...; if (isPolymorphic) { T* pNewObj = pSomeObj->clone();... polymorphic algorithm … } else { T* pNewObj = new T(*pSomeObj);... nonpolymorphic algorithm... } };

PROGRAMMING TECHNIQUES NiftyContainer The problem is that the compiler won't let you get away with this code. The compiler diligently tries to compile both branches, even if the optimizer will later eliminate the dead code. How to avoid: you can use Int2Type with simple overloading

PROGRAMMING TECHNIQUES NiftyContainer template class NiftyContainer { private: void DoSomething(T* pObj, Int2Type ) { T* pNewObj = pObj->Clone();... polymorphic algorithm... } …

PROGRAMMING TECHNIQUES NiftyContainer … void DoSomething(T* pObj, lnt2Type ) { T* pNewObj = new T(*pObj);... nonpolymorphic algorithm... } public: void DoSomething(T* pObj) { DoSomething(pObj, lnt2Type ()) ; } };

PROGRAMMING TECHNIQUES Type-to-Type Mapping Consider: template T* Create(const U& arg, T /* dummy */ ) { return new T(arg); } Now say there is Objects of type Widget that must take two arguments upon construction

PROGRAMMING TECHNIQUES Obvious solution template Widget* Create (const U& arg) { return new Widget(arg, -1); }

PROGRAMMING TECHNIQUES Obvious solution template Widget* Create (const U& arg) { return new Widget(arg, -1); } FAILS TO COMPILE!

PROGRAMMING TECHNIQUES Type-to-Type Mapping //Overloading only template T* Create(const U& arg, T /* dummy */) { return new T(arg); } template Widget* Create(const U& arg, Widget /* dummy */) { return new Widget(arg, -1); }

PROGRAMMING TECHNIQUES Type-to-Type Mapping Such a solution would incur the overhead of constructing an arbitrarily complex object that remains unused. We need a light vehicle for transporting the type information about T to Create. So let’s look forward:

PROGRAMMING TECHNIQUES Type-to-Type Mapping template struct Type2Type { typedef T OriginalType; }; Type2Type is devoid of any value, but distinct types lead to distinct Type2Type instantiations, which is what we need.

PROGRAMMING TECHNIQUES Create based on overloading & Type2Type template //better implementation T* Create(const U& arg, Type2Type ) { return new T(arg); } template Widget* Create(const U& arg, Type2Type ) { return new Widget(arg, -1); } String* pStr = Create("Hello", Type2Type ()); Widget* pW = Create(100, Type2Type ());

PROGRAMMING TECHNIQUES Type Selection Sometimes generic code needs to select one type or another, depending on a Boolean constant. template struct NiftyContainervalueTraits { typedef T* ValueType; };

PROGRAMMING TECHNIQUES Type Selection template struct NiftyContainervalueTraits { typedef T* ValueType; }; template class NiftyContainer { typedef NiftyContainerValueTraits Traits; typedef typename Traits::ValueType ValueType; };

PROGRAMMING TECHNIQUES Type Selection This way of doing things is unnecessarily clumsy. It doesn't scale: for each type selection, you must define a new traits class template. The library class template Select provided by Loki makes type selection available right on the spot. Its definition uses partial template specialization.

PROGRAMMING TECHNIQUES Template Select template struct Select { typedef T Result; }; Template struct Select { typedef U Result; };

PROGRAMMING TECHNIQUES Template Select How it works: If flag evaluates to true, the compiler uses the first (generic) definition, therefore Result evaluates to T. If flag is false, then the specialization enters into action and Result evaluates to U.

PROGRAMMING TECHNIQUES Moving on…

PROGRAMMING TECHNIQUES Detecting Convertibility and Inheritance at Compile Time Given two arbitrary types T and U that you know nothing about, how can you detect whether or not U inherits from T? How can you detect whether an arbitrary type T supports automatic conversion to an arbitrary type U?

PROGRAMMING TECHNIQUES Detecting Convertibility and Inheritance at Compile Time Solution relies on sizeof: it could be applied to any expression, no matter how complex, getting its size without actually evaluating that expression at runtime

PROGRAMMING TECHNIQUES Detecting Convertibility and Inheritance at Compile Time template class Conversion { typedef char Small; class Big { char dummy[2]; }; static Small Test(U); static Big Test(...); ….

PROGRAMMING TECHNIQUES Detecting Convertibility and Inheritance at Compile Time static T MakeT(); public: enum { exists = sizeof(Test(MakeT())) == sizeof(Small) }; };

PROGRAMMING TECHNIQUES Detecting Convertibility and Inheritance at Compile Time int main() { using namespace std; cout « Conversion ::exists « ' ' « Convesrion >::exists « ' '; }

PROGRAMMING TECHNIQUES Conversion We can implement one more constant inside Conversion: sameType, which is true if T and U represent the same type: template class Conversion {... as above... enum { sameType = false }; };

PROGRAMMING TECHNIQUES Conversion We implement sameType through a partial specialization of Conversion template class Conversion { public: enum { exists = 1, sameType = 1 }; };

PROGRAMMING TECHNIQUES SuperSubClass Macro //With the help of Conversion, it is now very //easy to determine inheritance #define SUPERSUBCLASS(T, U) \ (Conversion ::exists\ && \ !Conversion ::sameType);

PROGRAMMING TECHNIQUES SuperSubClass Macro SUPERSUBCLASS(T, U) evaluates to true if U inherits from T publicly, or if T and U are actually the same type. SUPERSUBCLASS does its job by evaluating the convertibility from a const U* to a const T*.

PROGRAMMING TECHNIQUES In the next slides: A wrapper around type_info NullType and EmptyType – the helpful helpers ;) …and finally: TypeTraits

PROGRAMMING TECHNIQUES Standard type_info class std::type_info gives the ability to investigate object types at runtime Hard to exploit: Disables the copy constructor and assignment operator, which makes storing type_info objects impossible. Does not guarantee that each invocation returns a reference to the same type_info object.

PROGRAMMING TECHNIQUES Loki wrapper class solution class TypeInfo { public: TypeInfo(); TypeInfo(const std::type_info&); TypeInfo(const TypeInfo&); TypeInfo& operator==(const TypeInfo&); bool before(const TypeInfo&) const; const char* name() const; private: const std::type_info* pInfo_; }

PROGRAMMING TECHNIQUES Loki wrapper class solution // Comparison operators bool operator==(const TypeInfo&, const TypeInfo&); bool operator!=(const TypeInfo&, const TypeInfo&); bool operator<(const TypeInfo&, const TypeInfo&); bool operator<=(const TypeInfo&, const TypeInfo&); bool operator>(const TypeInfo&, const TypeInfo&); bool operator>=(const TypeInfo&, const TypeInfo&);

PROGRAMMING TECHNIQUES Loki wrapper class solution // Now you can directly compare objects of type TypeInfo and std::type_info void Fun(Base* pObj) { TypeInfo info = typeid(Derived);... if (typeid(*pObj) == info) {... pBase actually points to a Derived object... }... }

PROGRAMMING TECHNIQUES Important features The ability to copy and compare TypeInfo objects is important in many situations. The cloning factory in and one double- dispatch engine provided in future seminars put TypeInfo to good use.

PROGRAMMING TECHNIQUES NullType & EmptyType helper Classes class NullType {}; Used for cases in which a type must be there syntactically but doesn't have a semantic sense. struct EmptyType {}; EmptyType is a legal type to inherit from, and you can pass around values of type EmptyType Will be used later in TypeLists

PROGRAMMING TECHNIQUES Type Traits Traits are a generic programming technique that allows compile-time decisions to be made based on types, much as you would make runtime decisions based on values “Extra level of indirection" that solves many software engineering problems Type-related decisions outside the immediate context in which they are made.

PROGRAMMING TECHNIQUES Copying application template OutIt Copy(Init first, Init last, OutIt result) { for (; first != last; ++first, ++result) *result = *first; }

PROGRAMMING TECHNIQUES Implementing Pointer Traits //T is not a pointer, and a pointee type doesn't apply. template class TypeTraits { private: template struct PointerTraits { enum(result = false }; typedef NullType PointeeType; }; …

PROGRAMMING TECHNIQUES Implementing Pointer Traits //A better match than the generic template for any pointer type. template struct PointerTraits { enum { result = true }; typedef U PointeeType; }; public: enum { isPointer = PointerTraits ::result }; typedef PointerTraits ::PointeeType PointeeType; };

PROGRAMMING TECHNIQUES Summary