带有 const 参数的函数重载（跟进）

Question

这是Previous Question的跟进

它变得非常复杂，所以我开始一个新线程以使我的观点更清楚。（不想删除以前的线程，因为其他提供有价值反馈的人不会失去他们获得的声誉点数）

更新的代码：（符合并有效）

#include <iostream>
 using std::cout;

 class Test {
         public:
         Test(){ }   
         int foo (const int) const;
         int foo (int );
 };  

 int main ()
 {   
         Test obj;
         int variable=0;  
         int output;
     do{ 
         output=obj.foo(3);        // Call the const function 
         cout<<"output::"<<output<<std::endl;
         output=obj.foo(variable); // Want to make it call the non const function 
         cout<<"output::"<<output<<std::endl;
         variable++; 
             usleep (2000000);
        }while(1);  
 }   

 int Test::foo(int a)
 {   
    cout<<"NON CONST"<<std::endl;
    a++;
    return a;
 }   

 int Test::foo (const int a) const
 {   
    cout<<"CONST"<<std::endl;
    return a;
 }   

输出（我得到）：

NON CONST
output::4
NON CONST
output::1
NON CONST
output::4
NON CONST
output::2
NON CONST
output::4
NON CONST
output::3
NON CONST
output::4
NON CONST
output::4
NON CONST
output::4
NON CONST
output::5

输出（我想要/想到的）

CONST
output::3
NON CONST
output::1
CONST
output::3
NON CONST
output::2
CONST
output::3
NON CONST
output::3
CONST
output::3
NON CONST
output::4
CONST
output::3
NON CONST
output::5

希望我能更好地提出我的问题。我知道其他方法可以做到这一点。但这可能吗？

Answer 1

在 C++ 中，函数签名

int Test::foo (const int a) const

和

int Test::foo (int a) const

被认为是完全一样的。

参数上的const之所以被忽略是因为它不能以任何方式影响调用者。由于参数是按值传递的，因此会复制调用者提供的值。对于调用者来说，被调用的函数是否可以更改该副本并不重要。 出于这个原因，C++ 忽略了函数参数上的顶级const-限定（如果传递引用，顶级const 不会出现），甚至认为int foo(int); 被认为是正确的原型功能

int foo(const int)
{
    /* ... */
}

简而言之，在 C++ 中，不可能在（值）函数参数的常量上重载函数。 要获得所需的输出，您可以考虑为非常量重载使用非常量引用参数。

Answer 2

const（或非const）函数的调用不依赖于参数的常量，而只依赖于被调用对象的常量（在我们的例子中为obj）。重载需要不同的类型，而 (non-const const) 不是，所以我认为你不能在这样做的时候重载。 （因为您正在定义一个 const 和一个非常量方法，但这不是重载。） 为了说服自己，试着把声明末尾的 const 去掉，看看是否允许声明

int foo(int a);
int foo(const int a);

你会得到一个错误。

在第二种情况下，您认为 foo 期望 const int 作为参数，但不是。 const 绑定到 a 而不是 int。所以它说的是 foo 期望一个 int，你可以使用 a 来引用它，那将是 const ：你不能修改 a。这就是为什么（参数的）const 没有出现在函数签名中的原因（这对于参考来说会有所不同）。
函数外的 const 指的是被调用的对象，所以这是签名的一部分

int foo(int a); # type => int (Test::*)(int)
int foo(const int a) const; # => int (const Test::*)(int)

int foo(const int a) ; # => int (Test::*)(int)
int foo(int a) const; # => int (const Test::*)(int)

（我对类型语法不是 100% 确定，所以不要评论它，这只是提供一个想法）

如您所见，const 被 a 删除。你也可以写int const a，即使不是标准的写法，也是完全合法的。

顺便说一句，你的代码永远不会做你所期望的，你应该使用对 int 的引用来修改它

int Test::foo(int &a) ...

Answer 3

好的，这就是它的工作原理：

当你调用一个函数时，参数的值被传递给函数。如果你传递一个值，那么这个值就是函数得到的值。如果你传递一个指针，那么你的函数就会得到一个指针。

当你的函数接收到参数时，它看到的只是一个整数值。它无法确定该值的来源，也不能是静态的或非静态的。这些属性属于指针，表示是否可以改变指针所指向的值，而不是指针本身。

为了更好地衡量，所有这些函数调用看起来与接收它们的函数相同：

int i=1;
int* b = new int;
*b = 4;
func(5);
func(3+2);
func(i+4);
func(*b+1);

所以要回答你的问题，你正在做的事情是不可能的。

编辑：要更改变量，请使用 int 和 int 指针重载函数。通过将 int 值的地址传递给函数，您的函数可以更改它。

Answer 4

是的，我不能让它调用 const 版本 - 除非我这样做：

const Test obj2;
output=obj2.foo(3);        // Call the const function 

无论传入什么参数，只要能调用非const，都会。如果你有一个 const 对象，它会调用函数的 const 版本。

有趣。

Answer 5

只是一个澄清。但是，我们可以在函数中重载带有和不带有 const 参数的指针，对吧？

如，

int Test::foo (const int* a);
int Test::foo (int* a);

这有什么不同？

Answer 6

将const int 转换为字符串，用字符串重载foo 并转换回...

随意破坏我的答案和 cmets。