Login | Register   
RSS Feed
Download our iPhone app
Browse DevX
Sign up for e-mail newsletters from DevX

By submitting your information, you agree that devx.com may send you DevX offers via email, phone and text message, as well as email offers about other products and services that DevX believes may be of interest to you. DevX will process your information in accordance with the Quinstreet Privacy Policy.


Use C++0x's Inheriting Constructors to Reduce Boilerplate Code in Class Hierarchies-3 : Page 3

A base class with multiple constructors forces a derived class to define corresponding constructors that merely forward their arguments to the matching base constructor. In C++03, you define the derived class's constructors manually. Learn how C++0x's inheriting constructors feature automates this process, thereby simplifying code maintenance and making your code more readable and secure.




Application Security Testing: An Integral Part of DevOps

Overriding Inheriting Constructors

As always, you can still add new constructors to a derived class, even one that uses inheriting constructors. If a user-declared constructor and an implicitly declared inheriting constructor have the same signature, the user-declared constructor takes precedence—effectively hiding the inheriting constructor with the same signature. Here's an example:

struct D1 : A1 { using A1::A1;//explicit D1(int); explicit D1( double); //a user-defined ctor hides the inherited ctor D1(int) explicit D1(int j): A1(0), x(j) {} private: int x; }; D1 d4(0); //OK, invokes D1(int n): A1(0),x(n) {}

Handling Multiple Inheritance

When a derived class has two or more immediate base classes, you can selectively state which base class's constructors to inherit using this syntax:

struct B1 { B1(char); }; struct B2 { B2(double); B2(int); }; struct D1 : B1, B2 { using B1::B1; // D1(char) using B2::B2; // D1(double), D1(int) }; D1 d('c'); //OK, invokes D1(char)

In certain cases, multiple inheritance can lead to ambiguity. Suppose you have two base classes that declare constructors with identical signatures. Inheriting these constructors will cause an error:

struct C1 { C1(int); C1(double); }; struct C2 { C2(int); }; struct D1 : C1, C2 { using C1::C1; // D1(int), D1(double) using C2::C2; // D1(int) //conflicts with D(int) above }; D1 d(5); //error, should this call C1(1) or C2(1)?

In this situation, because a user-declared constructor supersedes any implicit constructor declaration with the same signature, you can avoid the ambiguity by declaring the problematic constructor explicitly:

struct C1 { C1(int); C1(double); }; struct C2 { C2(int); }; struct D1 : C1, C2 { using C1::C1; // D1(int), D1(double) using C2::C2; // D1(int) D1(int n): C1(n), C2(n), x(n) {} //override D(int) private: int x; }; D1 d(5); //OK, calling user-defined ctor

Status and Support

Do not confuse inheriting constructors with delegating constructors; the latter apply only to constructors within the same class. The inheriting constructors proposal has already been voted into the C++0x Working Draft, so compiler vendors should start supporting this feature soon.

Danny Kalev is a certified system analyst and software engineer specializing in C++. He was a member of the C++ standards committee between 1997 and 2000 and has since been involved informally in the C++0x standardization process. He is the author of "The ANSI/ISO Professional C++ Programmer's Handbook" and "The Informit C++ Reference Guide: Techniques, Insight, and Practical Advice on C++."
Comment and Contribute






(Maximum characters: 1200). You have 1200 characters left.



We have made updates to our Privacy Policy to reflect the implementation of the General Data Protection Regulation.
Thanks for your registration, follow us on our social networks to keep up-to-date