Can you explicitly use a constructor overload?

Question

If I have 2 constructor overloads

calculations(double vector, double angle);
calculations(double horizontalVector, double verticalVector);

How can I ensure the compiler specifically uses one of the overloads that I choose (as each of them do different things behind the scenes)?

They are the same constructor, not overloads. Variable names don't matter. — Lukas-T, May 24 '21 at 08:22
That is not an overload, the argument name does not contribute to overload resolution. — Mansoor, May 24 '21 at 08:23
Ah okay, because the variable name is a dummy. Is there anyway then, that I can use the second one? — asjhdbashjdbasjhdbhjb, May 24 '21 at 08:23
Disambiguate with a third argument or use a different function name (or template parameter). — Mansoor, May 24 '21 at 08:24
I think you should take a step back to your design instead, and rethink the need for two constructors using the exact same arguments. — Some programmer dude, May 24 '21 at 08:25
`that I can use the second one? ` It's _the same_ one. I believe you want to research tag dispatching. — KamilCuk, May 24 '21 at 08:28
You can use "static constructors", as for `struct Angle { static Angle Degree(double); static Angle Radian(double); /*..*/};`. — Jarod42, May 24 '21 at 08:28
How do you repesent a vector as a `double`? Are those "vector" parameters actually polar and cartesian coordinates? — molbdnilo, May 24 '21 at 08:34

score 5 · Answer 1 · answered May 24 '21 at 08:26

If you want to have overloads, the types needs to be different. One way to do this is the so called whole value idiom.

Make a struct for each parameters: a vector (watching out for potential name clashes), angle and so on.

The you will have two different constructors.

score 4 · Answer 2 · answered May 24 '21 at 08:42

4

Assuming that your parameters are actually polar and cartesian coordinates rather than vectors,

calculations(double length, double angle);
calculations(double x_coordinate, double y_coordinate);

you can abstract those into types,

struct Polar { double length, angle; };
struct Cartesian {double x, y; };

and overload

calculations(const Polar& p);
calculations(const Cartesian& c);

and then

calculations c1(Polar{1,1});
calculations c2(Cartesian{1,1});

answered May 24 '21 at 08:42

molbdnilo

64,751
3
43
82

@einpoklum: it is the issue of doctorlove answer, missing example. So it is not clear, but her answer is more something like `calculations(Length length, Angle angle); calculations(X x, Y y);`. – Jarod42 May 24 '21 at 08:54

score 2 · Answer 3 · answered May 24 '21 at 08:37

To provide different functions with same parameters you can use tag dispatching, where you provide unused parameter to do overloading.

struct Calculations {
  struct UseTwoVectors {};
  Calculations(double vector, double angle);
  Calculations(double horizontalVector, double verticalVector, const UseTwoVectors&);
};
int main() {
    Calculations c(1, 2);
    Calculations d(1, 2, Calculations::UseTwoVectors());
}

Overall I do not know what these arguments represent - I suspect there is something wrong with abstraction in your code. You could take a different approach and make a class from your parameters.

struct VectorAngle {
    double vector, angle;
};
struct TwoVectors {
    double horizontalVector, verticalVector;
};
struct Calculations {
  Calculations(const VectorAngle& v);
  Calculations(const TwoVectors& v);
};
int main() {
    Calculations c(VectorAngle{1, 2});
    Calculations d(TwoVectors{1, 2});
};

Can you explicitly use a constructor overload?

3 Answers3