功能分辨率

Question

我有很多带有这个签名的函数：

DoSomething(int x, int y, int z, int t, int u, int p);

它们都有相同数量的参数和相同类型的参数。

我希望能够像这样使用它们：

DoSomething(1, 2, 3, 4, 5, 6);

我知道编译器无法区分具有相同签名的函数（它们是完全非法的）。

为此，我想将函数的参数包装在逻辑“构造”中。这并不意味着类或结构。例如：

DoSomething(Construct1(x, y, z), Construct2(t, u, p));
or
DoSomething(Construct1(x, y), Constrcut2(t, u, p, o));

在这种情况下，我可以区分这两个函数并且它们具有相同数量的参数。如果我使用具有不同构造函数的对象，即使它是 const by ref，使用类或结构，仍然会创建 Construct。例如：

DoSomething(const Construct1& constr1, const Construct2& constr2)
{
    constr1.x + constr2.t
}
DoSomething(Construct1(1, 2, 3), Construct2(4, 5, 6));

在这种情况下，Construct1 和 Construct2 都被创建了。

我想要的是：

DoSomething(Construct1(x, y, z), Construct2(t, u, p));
or
DoSomething(Construct1(x, y), Constrcut2(t, u, p, o));

在编译时展开为：

DoSomething(int x, int y, int z, int t, int u, int p);

从而消除了创建对象的需要。我不是在寻找对象解决方案。任何可以扩展它的东西都是受欢迎的。即使它是一个宏。我不是在寻找一个完整的解决方案，但如果您能指出我应该阅读的内容以便自己制作，那么这非常受欢迎。

提前致谢。

Answer 1

重载是基于参数types 而不是参数names。您不能拥有具有相同类型的参数列表的重载函数。

Answer 2

我认为你有几个误解。最明显的是参数的名称很重要......它们并不重要，就编译器而言，这两个函数声明声明了一个接受 6 个整数的函数（考虑一下，如果它们不同，@987654321 @做什么？）

第二个误解是对象的创建必然意味着分配。在您提供的代码中：DoSomething( Object1(x,y,z), Object2(t,y,u) ) 有两个对象，但没有一个动态分配（除非您在 Object1 或 Object2 构造函数中执行它们）。

总体而言，您应该编写可读的代码，并且只有当证明很慢时，然后配置文件并尝试优化瓶颈。

Answer 3

恐怕你得另寻路了。编译器会忽略您在函数声明中为参数指定的任何名称，因此就它所关心的而言，您所拥有的是：

DoSomething(int, int, int, int, int, int);

DoSomething(int, int, int, int, int, int);

由于它们之间没有区别，因此您根本没有声明两个重载函数——您只是声明了两次相同的函数。尝试使用相同的签名定义两个函数则违反了单一定义规则。

编辑：哦，我想我应该补充一点，如果没有返回类型，那些也不是允许的函数声明（不是说它与手头的问题有关，但以防万一有人决定对此感到迂腐——虽然我很难想象一个 C++ 程序员会做这样的事情）。

Answer 4

您可以通过让 Object1 和 Object2 公开底层存储 int 来避免不需要的副本

struct Object1 {
...
int x;
int y;
...

}

//<--- passed by reference, no copy happens --->
DoSomething( const Object1& o1, const Object2& o2 ) 
{
  int somethingUseful = o1.x * o2.w - o1.y * o2.z;
}

如果您仍然觉得这种方法出现的副本并不真正需要，请详细说明。

Answer 5

你甚至不能在 C++ 中定义两个相同的函数，所以如果假设它们确实存在，那么询问编译器如何区分这两者是没有意义的。

然后您似乎在问如何在不需要额外分配的情况下传递对象。这是通过 const 引用完成的，但考虑到您甚至还没有固化程序的结构，因此担心这一点似乎还为时过早。首先编写您的程序，然后再在需要时进行优化。过早的优化是万恶之源。