C++ overloading; variable args of same type?

Question

I have a class, whose constructor looks like this:

Chunker::Chunker(int chunkSizeX, int chunkSizeY){
    chunkX = chunkSizeX;
    chunkY = chunkSizeY;
}

I would like to offer the user the ability to have either chunkSizeY or chunkSizeX to have a default value (which needs to be calculated by Chunker).

I.E so they might pass in a 'AUTO' keyword or something so that the constructor knows.

Can I do something like:

Chunker::Chunker(int chunkSizeX, char chunkSizeY)

Chunker::Chunker(char chunkSizeX, int chunkSizeY)

Chunker::Chunker(char chunkSizeX, char chunkSizeY)

So that if it gets a char for one or both of the values, it knows to auto-calculate them?

I'm sure their must be a better/standard way I don't know of yet....?

Yes, you can do that, no, there is no better way that I know of. What are you asking? — Beta
– Beta, Commented Feb 23, 2015 at 16:04
I have no problem with it if that is the 'normal' way. I am a relative newbie to c++ and it 'felt' like I wan't doing it in the 'standard' method or perhaps there is a more succinct way? — jramm
– jramm, Commented Feb 23, 2015 at 16:06
@Beta No better way? This approach is not very expressive at all and would certainly confuse me. I'd recommend using boost::optional, or alternatively the builder pattern as Paul Evans has described. Another common way to do this is using pointers, where a null pointer represents an omitted argument, but I find that is also not expressive. — Joseph Mansfield
– Joseph Mansfield, Commented Feb 23, 2015 at 16:11

Jarod42 · Accepted Answer · 2015-02-23 16:20:29Z

5

You may use a special empty class to help:

struct Default {};

class Chunker
{
public:
    Chunker(int x, int y) : chunkX(x), chunkY(y) {}
    Chunker(Default, int y) : chunkX(42), chunkY(y) {}
    Chunker(int x, int Default) : chunkX(x), chunkY(42) {}

private:
    int chunkX;
    int chunkY;
};

usage:

Chunker c(1, 2);
Chunker cx(3, Default{});
Chunker cy(Default{}, 4);

or use "static builder"

class Chunker
{
public:
    Chunker(int x, int y) : chunkX(x), chunkY(y) {}
    static Chunker FromX(int x) { return Chunker(x, 42); }
    static Chunker FromY(int y) { return Chunker(42, y); }
private:
    int chunkX;
    int chunkY;
};

usage:

Chunker c(1, 2);
Chunker cx = Chunker::FromX(3);
Chunker cy = Chunker::FromY(4);

answered Feb 23, 2015 at 16:20

Jarod42

227k15 gold badges214 silver badges350 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

jramm Over a year ago

Nice examples, thanks. Quite like the use of static functions.

Paul Evans · Accepted Answer · 2015-02-23 16:05:22Z

4

Simply write a helper class that builtds Chunkers, something like:

class MakeChunker {

    void setX(int x) { ...
    void setY(int y) { ...
    Chunker make()

answered Feb 23, 2015 at 16:05

Paul Evans

27.7k3 gold badges41 silver badges56 bronze badges

Comments

Ulrich Eckhardt · Accepted Answer · 2015-02-24 15:13:08Z

2

I'd suggest Boost.Optional, which will give you code like this:

void function(optional<int> x, optional<int> y) {
    if (x) {
        // use *x
    }
    if (y) {
        // use *y
    }
}

That said, for the case of constructors, it's sometimes a good idea to add a static factory function in the class:

class Chunker {
    static Chunker create_with_x(int x) {
        ...
    }
    static Chunker create_with_y(int y) {
        ...
    }
};

answered Feb 24, 2015 at 15:13

Ulrich Eckhardt

17.7k5 gold badges31 silver badges63 bronze badges

Comments

Math · Accepted Answer · 2015-02-23 16:14:33Z

0

You can specify multiple constructors in C++ as long as they have different signatures, and the appropriate constructor will be selected by the compiler for each call.

So you can perfectly do :

In Chunker.cpp

Chunker::Chunker(int chunkSizeX, char chunkSizeY) {...} // First constructor
Chunker::Chunker(char chunkSizeX, int chunkSizeY) {...} // Second constructor
Chunker::Chunker(char chunkSizeX, char chunkSizeY) {...} // Third constructor

Then in another file of your program:

Chunker::chunker chunker1 = Chunker::Chunker(1, 'b') // First constructor is used
Chunker::chunker chunker2 = Chunker::Chunker('a', 2) // Second constructor is used
Chunker::chunker chunker3 = Chunker::Chunker('a', 'b') // Third constructor is used

answered Feb 23, 2015 at 16:14

Math

2,4562 gold badges22 silver badges22 bronze badges

3 Comments

Jarod42 Over a year ago

char != const char*

Angew is no longer proud of SO Over a year ago

You probably mean 'b', not "b"; dtto for other cases.

anatolyg Over a year ago

The char parameters should not be 'a' or 'b' or anything. OP wanted "AUTO keyword or something". Using explicit and different chars is confusing. Also you should mention implicit conversions (e.g. what happens when the constructor's parameters are size_t and char?)

Collectives™ on Stack Overflow

C++ overloading; variable args of same type?

4 Answers 4

1 Comment

Comments

Comments

3 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

1 Comment

Comments

Comments

3 Comments

Your Answer

Sign up or log in

Post as a guest

Related