关于c ++ 14：C ++函数参数安全性

C++ function argument safety

在一个接受同一类型的几个参数的函数中，我们如何保证调用方不会弄乱顺序呢？

例如

1	void allocate_things(int num_buffers, int pages_per_buffer, int default_value ...

以后

1 2	// uhmm.. lets see which was which uhh.. allocate_things(40,22,80,...

相关讨论

一个典型的解决方案是将参数放在具有命名字段的结构中。

1
2
3
4
5

AllocateParams p;
p.num_buffers = 1;
p.pages_per_buffer = 10;
p.default_value = 93;
allocate_things(p);

当然，你不必使用字段。您可以使用成员函数或任何您喜欢的函数。

相关讨论

你可以这样做，但allocate_things仍然是个坏名字，AllocateParams也不好。创建或多或少不相关变量的结构可能会使事情变得更加模糊。
@是的，同意，但这不是代码评审堆栈交换。如果您对原始作者的代码有评论，那么它们属于对问题的评论，而不是对答案的评论。此代码示例旨在说明特定的技术，而不是其他任何技术。
@我想很明显这些只是占位符名称。
我想指出的是，您的答案确实提供了解决问题的解决方案，但实际问题却存在于其他地方：只需避免具有三个或更多同一类型参数的功能。不仅因为接口很难正确使用，而且很可能函数做了太多的事情，应该拆分。
我不完全相信。这不是把问题转移到别处了吗？你不能不小心把成员变量设置得和参数变量一样错误吗？
@使用这种模式，程序员必须睡得更熟才能出错，因为他们需要按名称引用字段。(直到他们忘记了为什么要这样做，并且认为绕过有支撑的init列表是明智的，以原始问题+新的无意义填充符结尾[编辑：nate，我们又做了])
@Galik，即allocate_things({ 1, 10, 93 });。
@我想很明显这不应该是一个真正的功能。你关于函数"做了太多事情"的断言基本上是没有根据的，你所得到的唯一信息就是函数名，这也是显然是由函数名组成的！也可能是foo()。这种无关紧要的评论是我对堆栈溢出感到沮丧的最大原因。
@弗兰克普夫：如果你认为有一个真正的，真诚的问题没有得到解决，就去对这个问题发表评论，或者写下你自己的答案，如果它足够重要的话。函数执行"太多的事情"的问题与被问的实际问题毫无关系。
@迪特里切普：我不太明白你所说的"这种无关紧要的评论"是什么意思，但我真的不想让你失望。我在写了自己对这个问题的答案之后，写了我最初的评论。虽然你的回答是好的，肯定是正确的，但从长远来看，我的建议可能对手术更有帮助。当然，你是对的，其中有一些猜测，这就是为什么我写了"可能"，但这是基于我在类似情况下的经验。
@Dietrichepp：刚刚注意到有人投票结束，因为这个问题吸引了固执己见的答案-似乎是正确的：)
如果你确实使用了一个结构，你可能会发现人们使用隐式初始化语法allocate_things({1, 10, 93})，把你放回你开始的地方，但是现在有了一对额外的大括号来消除视觉噪音。您可以通过指定一个构造函数来防止这种情况的发生，但是您仍然使您的用户的生活更加困难。
是的，这里有一些有趣的折衷。有时，在创建一个易于使用的API和像对待孩子一样对待用户(希望他们是有能力的程序员)之间有一条很好的界限。

如果你有一个C++ 11编译器，你可以使用用户定义的文字和用户定义的类型。以下是一个幼稚的方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

struct num_buffers_t {
constexpr num_buffers_t(int n) : n(n) {} // constexpr constructor requires C++14
int n;
};

struct pages_per_buffer_t {
constexpr pages_per_buffer_t(int n) : n(n) {}
int n;
};

constexpr num_buffers_t operator"" _buffers(unsigned long long int n) {
return num_buffers_t(n);
}

constexpr pages_per_buffer_t operator"" _pages_per_buffer(unsigned long long int n) {
return pages_per_buffer_t(n);
}

void allocate_things(num_buffers_t num_buffers, pages_per_buffer_t pages_per_buffer) {
// do stuff...
}

template <typename S, typename T>
void allocate_things(S, T) = delete; // forbid calling with other types, eg. integer literals

int main() {
// now we see which is which ...
allocate_things(40_buffers, 22_pages_per_buffer);

// the following does not compile (see the 'deleted' function):
// allocate_things(40, 22);
// allocate_things(40, 22_pages_per_buffer);
// allocate_things(22_pages_per_buffer, 40_buffers);
}

相关讨论

到目前为止，还有两个很好的答案：另一种方法是尽可能地利用类型系统，并创建强typedef。例如，使用boost-strong typedef(http://www.boost.org/doc/libs/1_61_0/libs/serialization/doc/strong_typedef.html)。

1
2
3
4

BOOST_STRONG_TYPEDEF(int , num_buffers);
BOOST_STRONG_TYPEDEF(int , num_pages);

void func(num_buffers b, num_pages p);

使用错误的参数顺序调用func现在将是一个编译错误。

关于这个的几条注释。首先，Boost的强typedef在其方法中相当过时；您可以使用variadic crtp做更好的事情，并且完全避免使用宏。第二，显然这会引入一些开销，因为您经常需要显式转换。所以一般来说你不想过度使用它。在图书馆里反复出现的东西真是太好了。不太适合一个人的事情。例如，如果您正在编写一个GPS库，那么您应该有一个以米为单位的强双typedef，一个以纳秒为单位的强Int64 typedef，等等。

相关讨论

(注：post最初被标记为"c")。

c99以后允许对@dietrich epp idea:compound literal进行扩展

1
2
3
4
5
6
7
8
9

struct things {
int num_buffers;
int pages_per_buffer;
int default_value
};
allocate_things(struct things);

// Use a compound literal
allocate_things((struct things){.default_value=80, .num_buffers=40, .pages_per_buffer=22});

甚至可以传递结构的地址。

1
2
3
4

allocate_things(struct things *);

// Use a compound literal
allocate_things(&((struct things){.default_value=80,.num_buffers=40,.pages_per_buffer=22}));

相关讨论

为了完整性起见，可以在调用变为时使用命名参数。

1
2
3

void allocate_things(num_buffers=20, pages_per_buffer=40, default_value=20);
// or equivalently
void allocate_things(pages_per_buffer=40, default_value=20, num_buffers=20);

但是，在当前C++中，这需要相当多的代码来实现(在报头文件中声明EDOCX1)3，它还必须声明适当的外部对象EDCOX1(4)等，提供EDCOX1×5)，返回一个唯一合适的对象。

-------工作示例(用于Sergej)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <iostream>

struct a_t { int x=0; a_t(int i): x(i){} };
struct b_t { int x=0; b_t(int i): x(i){} };
struct c_t { int x=0; c_t(int i): x(i){} };

// implement using all possible permutations of the arguments.
// for many more argumentes better use a varidadic template.
void func(a_t a, b_t b, c_t c)
{ std::cout<<"a="<<a.x<<" b="<<b.x<<" c="<<c.x<<std::endl; }
inline void func(b_t b, c_t c, a_t a) { func(a,b,c); }
inline void func(c_t c, a_t a, b_t b) { func(a,b,c); }
inline void func(a_t a, c_t c, b_t b) { func(a,b,c); }
inline void func(c_t c, b_t b, a_t a) { func(a,b,c); }
inline void func(b_t b, a_t a, c_t c) { func(a,b,c); }

struct make_a { a_t operator=(int i) { return {i}; } } a;
struct make_b { b_t operator=(int i) { return {i}; } } b;
struct make_c { c_t operator=(int i) { return {i}; } } c;

int main()
{
func(b=2, c=10, a=42);
}

相关讨论

不能。这就是为什么建议尽可能少地使用函数参数的原因。

在您的示例中，可以有单独的函数，如set_num_buffers(int num_buffers)、set_pages_per_buffer(int pages_per_buffer)等。

您可能已经注意到，allocate_things不是一个好名字，因为它不表示函数实际在做什么。尤其是我不希望它设置默认值。

相关讨论

您真的要尝试对任意整数的所有组合进行质量保证吗？把所有的负/零值检查都扔进去？

只需为最小、中等和最大缓冲区数量以及较小、中等和较大缓冲区大小创建两个枚举类型。然后让编译器完成工作，让您的QA人员休息一个下午：

1	allocate_things(MINIMUM_BUFFER_CONFIGURATION, LARGE_BUFFER_SIZE, 42);

然后你只需要测试有限数量的组合，你就可以得到100%的覆盖率。从现在开始5年后，编写代码的人员只需要知道他们想要实现什么，而不必猜测他们可能需要的数字，或者哪些值已经在字段中进行了实际测试。

它确实使代码的扩展稍微困难一些，但听起来参数是用于低级性能调优的，因此不应认为扭曲值是便宜的/微不足道的/不需要彻底测试的。对更改的代码审阅分配某物(25，25，25)；

……

分配某物(30，80，42)；

…可能只是耸耸肩/发泄，但是对新的枚举值超大缓冲区的代码审查可能会触发关于内存使用、文档、性能测试等的所有正确讨论。