C++ 重载；相同类型的变量参数？答案

【问题标题】：C++ overloading; variable args of same type?C++ 重载；相同类型的变量参数？
【发布时间】：2015-04-25 00:27:57
【问题描述】：

我有一个类，其构造函数如下所示：

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

我想为用户提供让chunkSizeY 或chunkSizeX 具有默认值（需要由Chunker 计算）的能力。

IE，所以他们可能会传入一个“AUTO”关键字或其他东西，以便构造函数知道。

我可以这样做吗：

Chunker::Chunker(int chunkSizeX, char chunkSizeY)

Chunker::Chunker(char chunkSizeX, int chunkSizeY)

Chunker::Chunker(char chunkSizeX, char chunkSizeY)

所以如果它为一个或两个值获得char，它知道自动计算它们吗？

我确定他们一定是我还不知道的更好/标准的方式......？

【问题讨论】：

是的，你可以这样做，不，我知道没有更好的方法。你在问什么？
你描述的方式到底有什么问题？
如果这是“正常”方式，我对此没有任何问题。我是 C++ 的一个相对新手，它“感觉”就像我不想用“标准”方法做它，或者也许有更简洁的方法？
从char 投射到int 是一个糟糕的计划吗？
@Beta 没有更好的方法？这种方法根本不是很有表现力，肯定会让我感到困惑。我建议使用boost::optional，或者使用 Paul Evans 描述的构建器模式。另一种常见的方法是使用指针，其中空指针表示省略的参数，但我发现这也没有表达力。

标签： c++ overloading default-value optional-parameters

【解决方案1】：

只需编写一个内置Chunkers 的帮助类，类似于：

class MakeChunker {

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

【讨论】：

【解决方案2】：

你可以在C++中指定多个构造函数，只要它们有不同的签名，编译器会为每次调用选择合适的构造函数。

所以你可以完美地做到：

在 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

然后在你程序的另一个文件中：

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

【讨论】：

char != const char*
你的意思可能是'b'，而不是"b"； dtto 用于其他情况。
char 参数不应该是 'a' 或 'b' 或任何东西。 OP想要“AUTO关键字或其他东西”。使用显式和不同的 chars 会令人困惑。您还应该提及隐式转换（例如，当构造函数的参数为size_t 和char 时会发生什么？）

【解决方案3】：

你可以使用一个特殊的空类来帮助：

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;
};

用法：

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

或使用“静态构建器”

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;
};

用法：

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

【讨论】：

很好的例子，谢谢。很像使用静态函数。

【解决方案4】：

我建议使用 Boost.Optional，它会为您提供如下代码：

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

也就是说，对于构造函数，有时在类中添加静态工厂函数是个好主意：

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

【讨论】：