Differentiate between constructor with default argument value and empty argument list

Question

In C++, is there any way to differentiate between a constructor with no argument and one with arguments that all have default values?

Like this:

class Object {
public:
      Object(int a = 0, int b = 0 ){
      }

      Object(){
      }
};

In addition, the compiler could not determine which constructors should be used in the following code sample:

Object obj;  // which one, Object(int,int) or Object()

Nope. A constructor with all **default**ed parameters is a **default** constructor. — NathanOliver, Feb 06 '18 at 20:53
If both arguments can have defaults, it likely means you have duplicate behavior in both c'tors. — StoryTeller - Unslander Monica, Feb 06 '18 at 20:54
Even if it did compile, combining default parameter values overloaded methods is not a good idea... — selbie, Feb 06 '18 at 20:56
You may find interesting to look at this to solve your disambiguation problem https://isocpp.org/wiki/faq/ctors#named-ctor-idiom — Fryz, Feb 06 '18 at 21:05
Not to sound rude, but why have both, that is, what's the difference between the two for your program's sake, that made you want to try this? — Dan Chase, Feb 07 '18 at 03:23

score 4 · Answer 1 · answered Feb 06 '18 at 21:03

4

Assuming the two c'tors are really exceptionally different (I suspect that's unlikely, since both supposedly create some "default state" for the object), you can do as the standard library does when it needs to disambiguate c'tors. You can make it work based of off tag dispatch:

class Object {
  public:
  enum class from_ints_t{};
  static constexpr from_ints_t from_ints{};

  Object(from_ints_t, int a = 0, int b = 0 ){
  }

  Object(){
  }
};

Now default constructing looks like Object obj; and constructing from the default values of those integers looks like Object obj{Object::from_ints};. There's no ambiguity left.

answered Feb 06 '18 at 21:03

StoryTeller - Unslander Monica

165,132
21
377
458

1

What is the reason you use a strongly typed enum and not a simple class for `from_ints`? – davidhigh Feb 06 '18 at 21:13
@davidhigh - force of habit. A class will do just the same, maybe even better. – StoryTeller - Unslander Monica Feb 06 '18 at 21:15

Amir Kirsh · Accepted Answer · 2018-02-06T23:24:27.470

Just for the fun, was trying to propose something like:

struct Object {
      // SFINAE
      template<class T,
               typename = typename std::enable_if<std::is_same<T, int>::value>::type>
      Object(T a = 0, T b = 0){
          std::cout << "ctor with two ints and defaults" << std::endl;
      }

      Object(){
          std::cout << "empty ctor" << std::endl;
      }
};

int main() {
    Object o1;
    Object o2(8, 9);
    Object o3<int>();    
}

But unfortunately the creation of o3 in that way is not allowed, as apparently you cannot explicitly specify template argument for a constructor, see: Can the template parameters of a constructor be explicitly specified? (answer is: no...)

Anyway, this was just for fun.

I found the answer by Scab in the comment above the most appropriate for the imagined need - use named ctor idiom - http://isocpp.org/wiki/faq/ctors#named-ctor-idiom:

struct Object {
    static Object emptyCtor() { return Object{}; }
    static Object defaultIntegers() { return Object{0, 0}; }
    static Object create(int a, int b) { return Object{a, b}; }
protected:
    Object(int a, int b){
      std::cout << "ctor with two ints" << std::endl;
    }

    Object(){
      std::cout << "empty ctor" << std::endl;
    }
};

int main() {
    Object o1 = Object::emptyCtor();
    Object o2 = Object::defaultIntegers();
    Object o3 = Object::create(8, 9);
}

Differentiate between constructor with default argument value and empty argument list

2 Answers2