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

const（或非const）函数的调用不依赖于参数的常量，而只取决于被调用对象的常量（在我们的例子中是obj）。重载需要不同的类型而且（非const 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 2

在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) { /* ... */ }被认为是函数的正确原型

{{1}}

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

Answer 3

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

调用函数时，参数的值将传递给函数。如果传递一个值，那么该值将是函数获得的值。如果你传递一个指针，那么你的函数将得到一个指针。

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

为了好的衡量，所有这些函数调用对于接收它们的函数看起来都是IDENTICAL：

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并转换回来...

随意破坏我的回答和评论。

const参数的函数重载（后续）

6 个答案: