将函数赋值给函数指针，const参数的正确性？

Question

我现在正在大学学习C ++和OOP的基础知识。 我不是100％确定函数指针在为它们分配函数时如何工作。 我遇到了以下代码：

void mystery7(int a, const double b) { cout << "mystery7" << endl; }
const int mystery8(int a, double b) { cout << "mystery8" << endl; }

int main() {
    void(*p1)(int, double) = mystery7;            /* No error! */
    void(*p2)(int, const double) = mystery7;
    const int(*p3)(int, double) = mystery8;
    const int(*p4)(const int, double) = mystery8; /* No error! */
}

根据我的理解， p2和p3分配很好，因为函数参数类型匹配且const-ness是正确的。 但为什么p1和p4分配失败呢？ 将const double / int与非const double / int匹配不应该是非法的吗？

Answer 1

根据C ++标准（C ++ 17,16.1可重载声明）

（3.4） - 仅存在或不存在const和/或volatile的参数声明是等效的。 也就是说，在确定声明，定义或调用哪个函数时，将忽略每个参数类型的const和volatile类型说明符。

因此，在确定函数类型的过程中，将丢弃例如下面的函数声明的第二个参数的限定符const。

void mystery7(int a, const double b);

函数类型为void( int, double ) 。

还要考虑以下函数声明

void f( const int * const p );

它等同于以下声明

void f( const int * p );

它是使参数保持不变的第二个const（即它将指针本身声明为一个不能在函数内重新分配的常量对象）。 第一个const定义指针的类型。 它没有被丢弃。

注意这一点虽然在C ++标准中使用术语“const引用”引用本身不能与指针相反。 这是以下声明

int & const x = initializer;

是不正确的。

虽然这个宣言

int * const x = initializer;

是正确的，并声明一个常量指针。

Answer 2

对value传递的函数参数有一个特殊规则。

虽然它们上的const会影响它们在函数内的使用（以防止意外），但它在签名上基本上被忽略了。 这是因为通过值传递的对象的const对调用站点上的原始复制对象没有任何影响。

这就是你所看到的。

（就我个人而言，我认为这个设计决定是一个错误;它是令人困惑和不必要的！但它就是它。注意它来自同一段，默默地改变void foo(T arg[5]);进入void foo(T* arg); ;,所以我们必须要处理好大量的胡扯！）

但请记住，这不仅仅会删除这种参数类型中的任何 const 。 在int* const ，指针是const ，但是在int const* （或const int* ）中，指针是非const但是是const东西。 只有第一个例子涉及指针本身的const并将被剥离。

---

[dcl.fct]/5使用以下规则确定函数的类型。 每个参数的类型（包括函数参数包）由其自己的decl-specifier-seq和声明符确定。 在确定每个参数的类型之后，将“ T数组”或函数类型T任何参数调整为“指向T指针”。 生成参数类型列表后， 在形成函数类型时，将删除修改参数类型的任何顶级cv限定符 。 生成的已转换参数类型列表以及省略号或函数参数包的存在与否是函数的parameter-type-list 。 [注意：此转换不会影响参数的类型。 例如， int(*)(const int p, decltype(p)*)和int(*)(int, const int*)是相同的类型。 - 结束说明]

Answer 3

在某种情况下，向函数参数添加或删除const限定符是一个严重的错误。 它是通过指针传递参数时出现的 。

这是一个可能出错的简单例子。 此代码在C中被破坏：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// char * strncpy ( char * destination, const char * source, size_t num );

/* Undeclare the macro required by the C standard, to get a function name that
 * we can assign to a pointer:
 */
#undef strncpy

// The correct declaration:
char* (*const fp1)(char*, const char*, size_t) = strncpy;
// Changing const char* to char* will give a warning:
char* (*const fp2)(char*, char*, size_t) = strncpy;
// Adding a const qualifier is actually dangerous:
char* (*const fp3)(const char*, const char*, size_t) = strncpy;

const char* const unmodifiable = "hello, world!";

int main(void)
{
  // This is undefined behavior:
  fp3( unmodifiable, "Whoops!", sizeof(unmodifiable) );

  fputs( unmodifiable, stdout );
  return EXIT_SUCCESS;
}

这里的问题是fp3 。 这是一个指向接受两个const char*参数的函数的指针。 但是，它指向标准库调用strncpy() ¹，其第一个参数是它修改的缓冲区。 也就是说， fp3( dest, src, length )有一个类型，它承诺不会修改数据dest点，但是它会将参数传递给strncpy() ，后者会修改该数据！ 这是唯一可能的，因为我们更改了函数的类型签名。

尝试修改字符串常量是未定义的行为 - 我们有效地告诉程序调用strncpy( "hello, world!", "Whoops!", sizeof("hello, world!") ) - 以及我测试过的几个不同的编译器，它会在运行时静默失败。

任何现代的C编译器都应该允许赋值给fp1但警告你用fp2或fp3射击自己。 在C ++中，没有reinterpret_cast ， fp2和fp3行根本不会编译。 添加显式强制转换会使编译器假设您知道正在执行的操作并使警告静音，但由于其未定义的行为，程序仍然会失败。

const auto fp2 =
  reinterpret_cast<char*(*)(char*, char*, size_t)>(strncpy);
// Adding a const qualifier is actually dangerous:
const auto fp3 =
  reinterpret_cast<char*(*)(const char*, const char*, size_t)>(strncpy);

对于通过值传递的参数，不会出现这种情况，因为编译器会复制这些参数。 标记由值const传递的参数只意味着该函数不期望需要修改其临时副本。 例如，如果标准库在内部声明为char* strncpy( char* const dest, const char* const src, const size_t n ) ，则它将无法使用K＆R idiom *dest++ = *src++; 。 这会修改函数的参数的临时副本，我们将其声明为const 。 由于这不会影响程序的其余部分，因此C不介意在函数原型或函数指针中添加或删除const限定符。 通常，您不会将它们作为头文件中公共接口的一部分，因为它们是实现细节。

¹虽然我使用strncpy()作为具有正确签名的众所周知的函数的示例，但它通常被弃用。