Home › Blogs › jason's blog

Templated Constructors in C++: Using the "explicit" Keyword

Thu, 2009-02-12 13:01 — jason

Sometimes, in the course of C++ template based programming it might be desirable to have a constructor that is templated, like the following contrived exampled:

#include <iostream>
 
struct TestClass
{
  template<typename T>
    TestClass(const T &t)
    {
      std::cout << "Constructed a TestClass " << t << std::endl;
    }
};

By creating a templated constructor, however, we have created an infinite number of automatic type conversions. That is, the following code does compile:

void TakeATestClass(const TestClass &t)
{
}
 
int main()
{
  TakeATestClass("Bob");
}

Is the above something that we really expected to compile? Probably not, but even if it is, the chance that we will lose track of it down the road and it will come back to bite us is pretty high.

In fact, this takes principle #40 from C++ Coding Standards, "Avoid providing implicit conversions," and raises it to the Nth degree.

The solution is simple. We can still retain the flexibility of the templated constructor while eliminating the accidental conversions by adding the "explicit" keyword to our constructor.

struct TestClass
{
  template<typename T>
    explicit TestClass(const T &t)
    {
      std::cout << "Constructed a TestClass " << t << std::endl;
    }
};

Our new version should eliminate all unintended constructions of our new class.

Comments

Wed, 2010-02-17 22:44 — Anonymous (not verified)

newbie point: you don't

newbie point: you don't provide an example of an intended construction.

Thu, 2010-11-25 08:01 — Michele (not verified)

not compiling

hello,
it does not compile indeed.

the output:

gcc explicitKeyword.cc

/tmp/ccUiyCDG.o: In function `__static_initialization_and_destruction_0(int, int)':
explicitKeyword.cc:(.text+0x59): undefined reference to `std::ios_base::Init::Init()'
explicitKeyword.cc:(.text+0x5e): undefined reference to `std::ios_base::Init::~Init()'
/tmp/ccUiyCDG.o: In function `TestClass::TestClass(char const (&) [4])':
explicitKeyword.cc:(.text._ZN9TestClassC1IA4_cEERKT_[TestClass::TestClass(char const (&) [4])]+0x1b): undefined reference to `std::cout'
explicitKeyword.cc:(.text._ZN9TestClassC1IA4_cEERKT_[TestClass::TestClass(char const (&) [4])]+0x20): undefined reference to `std::basic_ostream >& std::operator<< >(std::basic_ostream >&, char const*)'
explicitKeyword.cc:(.text._ZN9TestClassC1IA4_cEERKT_[TestClass::TestClass(char const (&) [4])]+0x2b): undefined reference to `std::basic_ostream >& std::operator<< >(std::basic_ostream >&, char const*)'
explicitKeyword.cc:(.text._ZN9TestClassC1IA4_cEERKT_[TestClass::TestClass(char const (&) [4])]+0x30): undefined reference to `std::basic_ostream >& std::endl >(std::basic_ostream >&)'
explicitKeyword.cc:(.text._ZN9TestClassC1IA4_cEERKT_[TestClass::TestClass(char const (&) [4])]+0x38): undefined reference to `std::basic_ostream >::operator<<(std::basic_ostream >& (*)(std::basic_ostream >&))'
/tmp/ccUiyCDG.o:(.eh_frame+0x12): undefined reference to `__gxx_personality_v0'
collect2: ld returned 1 exit status

Sat, 2010-11-27 09:48 — jason

g++ vs gcc

Consider using g++ to compile a c++ application instead of gcc. The errors you are seeing is the compiler not linking to the standard C++ library.

-Jason

Mon, 2011-01-03 17:53 — Rob (not verified)

What about a templated template?

So what about this case:

template <class T> class Foo{
    Foo()
    {
        ...
    }
 
    template <class U> explicit Foo(const Bar<U>& b)
    {
        ...
    }
};

Bar is defined in an included file.

This generates an error for me, and I'm uncertain how to proceed.

Mon, 2011-01-03 23:12 — jason

Can you provide a more

Can you provide a more complete example? Example of the definition of Bar and example usage of the constructor, and I can check it out.

-Jason