Question

假设我有一个带有3个整数参数的构造函数或方法。

Object.h

Object::Object(int alenght, int awidth, int aheight);

有没有办法确保在编译类型中我以正确的顺序传递它们？

int l = 10;
int w = 15;
int h = 5;

的main.cpp

Object myObject(l,w,h); // is correct
Object myObject(w,l,h); // incorrect but compiles

当然我可以为每个整数创建一个类，但这非常耗时。有没有办法，基于模板可能在编译时生成错误，而不需要为每个整数创建一个类？

Answer 1

在当前版本的C ++中，你无能为力。 C ++的下一个版本将允许类似：

Object myObject = { .length = 10, .width = 15, .height = 5 };

与此同时，你必须使用某种黑客，例如为每个参数定义一个单独的类型，以便编译器可以报告类型不匹配。这是一个代码示例：

struct Object
{
    int length, width, height;

    struct Length { explicit Length(int x): x(x) {}; int x; };
    struct Width  { explicit Width(int x):  x(x) {}; int x; };
    struct Height { explicit Height(int x): x(x) {}; int x; };

    Object(Length length, Width width, Height height):
        length(length.x), width(width.x), height(height.x)
    {}
};

int main()
{
    Object obj( Object::Length(10), Object::Width(15), Object::Height(5) );
}

Answer 2

您可以使用标记创建单个整数（或数字）适配器，然后只允许将正确的类型传递给参数，从而最大限度地减少样板量。

struct l_tag {};
struct w_tag {};
struct h_tag {};

template <typename Int, typename Tag>
struct int_adaptor
{
public:
    explicit int_adaptor(Int x = Int()):
        data_(x)
    {}

    // ....

private:
    Int data_;
};

using l_type = int_adaptor<int, l_tag>;
using w_type = int_adaptor<int, w_tag>;
using h_type = int_adaptor<int, h_tag>;

这将允许编译时强制执行正确的类型签名，并最小化样板。然而，在实践中，它可能比所需的更加模板化。

Answer 3

总之，没有。执行此操作的唯一方法是使每个参数成为不同的类型，并确保不能将每个类型作为另一种类型传入。您可以编写单个模板类来包装整数，然后根据枚举对每个参数类型进行专门化。例如。

Answer 4

没有

有三个整数，语言和编译器都没有任何方法知道它们的意思，除非你引入一些类型安全（但你已经排除了这一点）。

处理此问题的传统方法是使用测试。

C ++ 11确保原始类型以正确的顺序传递

4 个答案: