指向 const 的指针与通常的指针（用于函数）

Question

指向 const 的指针和通常的函数指针之间有什么区别吗？什么时候适合对独立函数使用 const 限定符？

我写了简短的示例来说明我的问题：

#include <iostream>
using namespace std;

int sum( int x, int y ) { return x + y; }
typedef int sum_func( int, int );

int main()
{
    const sum_func* sum_func_cptr = &sum; // const function
    sum_func* sum_func_ptr = &sum;        // non-const function ?

    // What is the difference between sum_func_cptr and sum_func_ptr

    int x = sum_func_cptr( 2, 2 );
    cout << x << endl;

    int y = sum_func_ptr( 2, 2 );
    cout << y << endl;

    sum_func_cptr = 0;
    sum_func_ptr = 0;

    return 0;
}

g++ 没有给出警告。这就是我问的原因。

Answer 1

关于 C++03，您的代码格式错误。您可以不构造一个 const（或 volatile）限定的函数类型。每当你这样做时，你的程序就会变得不正确。

这条规则has been changed用于C++1x，使编译器忽略const/volatile。即使在 C++03 模式下，C++ 编译器通常也已经实现了这个规则。因此，以下两个将定义相同的函数两次，并导致编译错误。

typedef void Ft();


void f(Ft const*) { }
void f(Ft *) { } // another definition!

这是我的主张的证据。 C++03，8.3.5/1

cv-qualifier-seq 只能是非静态成员函数的函数类型、成员指针所指的函数类型或函数 typedef 声明的顶级函数类型的一部分。函数声明器中 cv-qualifier-seq 的效果与在函数类型之上添加 cv-qualification 不同，即它不会创建 cv-qualified 函数类型。事实上，如果在确定类型的任何时候形成了一个 cv 限定的函数类型，那么程序就是非良构的。

这是 C++1x 的文本，8.3.5/7n2914：

cv-qualifier-seq 只能是非静态成员函数的函数类型、成员指针所指的函数类型或函数 typedef 声明的顶级函数类型的一部分。函数声明器中 cv-qualifier-seq 的效果与在函数类型之上添加 cv-qualifiction 不同。在后一种情况下，cv 限定符被忽略。

上面说下面是有效的，但是，它为可以声明 const 成员函数的函数创建函数类型。

typedef void Ft() const;
struct X { Ft cMemFn; };
void X::cMemFn() const { }

Answer 2

根据定义，独立函数是 const。因此 const 和非 const 函数指针之间没有区别。

Answer 3

我想你的意思是，
sum_func* const sum_func_cptr 而不是 const sum_func* sum_func_cptr。

sum_func* const sum_func_cptr = ∑
sum_func* const sum_func_cptr = &sum_new; // will not compile.
// whereas,
const sum_func* sum_func_cptr = ∑  // will compile
const sum_func* sum_func_cptr = &sum_new; // will compile.
sum_func* sum_func_cptr = ∑  // will compile
sum_func* sum_func_cptr = &sum_new; // will compile.

-贾格纳特。

Answer 4

有趣的是，即使在指向 member 函数的指针上使用 const 说明符时，它似乎也没有效果。

#include <iostream>
using namespace std;

class Foo {
public:
  int sum( int x, int y ) {
    _x = x;
    _y = y;
    return x + y;
  }
private:
  int _x;
  int _y;
};

typedef int (Foo::*sum_func)(int,int);

int main()
{
    Foo f;
    const sum_func sum_func_cptr = &Foo::sum; // const pointer
    sum_func sum_func_ptr = &Foo::sum;        // non-const pointer

    int x = (f.*sum_func_cptr)( 2, 2 );
    cout << x << endl;

    int y = (f.*sum_func_ptr)( 2, 2 );
    cout << y << endl;

    const sum_func* sum_func_cptr_cptr = &sum_func_cptr;
    sum_func* sum_func_ptr_ptr = &sum_func_ptr;

    x = (f.**sum_func_cptr_cptr)( 2, 2 );
    cout << x << endl;

    y = (f.**sum_func_ptr_ptr)( 2, 2 );
    cout << y << endl;

    return 0;
}

Answer 5

我认为之前的回复存在基本的误解。

    const sum_func sum_func_cptr = &Foo::sum; // const pointer

也就是说sum_func_cptr是一个指向函数的常量指针，也就是说你可以用一个非常量的成员函数来初始化它，但是你以后不能把它改成指向另一个函数，因为const指的是到变量。 这相当于：

    sum_func const sum_func_cptr = &Foo::sum; // const pointer

你不同意吗？ :-)

-保罗