Question

此问题与Warning (Anachronism): Assigning void(*)(int) to extern "C" void(*)(int)有关。在引用的问题中，我们有一个函数指针typedef声明为extern "C"：

extern "C" {
  typedef void (*SignalHandlerFn) (int);
};

当我们尝试分配它时：

new_handler.sa_handler = (pfn ? reinterpret_cast<SignalHandlerFn>(pfn) :
                                reinterpret_cast<SignalHandlerFn>(defaultHandler));

导致错误（行号有点偏，但上面的行产生了它）：

/opt/solarisstudio12.4/bin/CC -DDEBUG -c test.cpp
...
"ossig.h", line 75: Warning (Anachronism): Using void(*)(int) to initialize extern "C" void(*)(int).
"test.cpp", line 135:     Where: While instantiating "SignalHandler<5, 0>::SignalHandler(extern "C" void(*)(int), int)".
"test.cpp", line 135:     Where: Instantiated from non-template code.
2 Warning(s) detected.

我能说的最好，extern "C"在使用reinterpret_cast时被丢弃了。然而，C演员按预期工作。

我相信Sun Studio 12.4（SunCC 5.13）使用C ++ 03作为defult。但我的问题同时适用于C ++ 03和C ++ 11，因为由于GCC 4.8和4.9的普及，我们目前看到了很多这两个问题。

C ++是否会从声明中删除extern "C"？

solaris:~$ cat test.cxx
#include <signal.h>

extern "C" {
  typedef void (*SignalHandlerFn) (int);
};

template <int S, bool O=false>
struct SignalHandler
{
  SignalHandler(SignalHandlerFn pfn = NULL, int flags = 0) : m_installed(false)
  {
    struct sigaction new_handler;

    do
    {
      int ret = 0;

      ret = sigaction (S, 0, &m_old);
      if (ret != 0) break; // Failed

      if (m_old.sa_handler != 0 && !O) break;

      new_handler.sa_handler = (pfn ? reinterpret_cast<SignalHandlerFn>(pfn) :
                                      reinterpret_cast<SignalHandlerFn>(&SignalHandler::NullHandler));
      new_handler.sa_flags = (pfn ? flags : 0);

      ret = sigemptyset (&new_handler.sa_mask);
      if (ret != 0) break; // Failed

      ret = sigaction (S, &new_handler, 0);
      if (ret != 0) break; // Failed

      m_installed = true;

    } while(0);
  }

  ~SignalHandler()
  {
    if (m_installed)
      sigaction (S, &m_old, 0);
  }

private:
  struct sigaction m_old;
  bool m_installed;

  static void NullHandler(int /*unused*/) { /* continue*/ }

private:
  // Not copyable
  SignalHandler(const SignalHandler &);
  void operator=(const SignalHandler &);
};

int main(int argc, char* argv[])
{
  SignalHandler<SIGTRAP, 0> handler;
  return 0;
}

Answer 1

reinterpret_cast<T>或者生成T类型的表达式，或者由于不存在允许的转换而形成错误。（参考：[expr.reinterpret.cast] / 1）。

语言链接是类型的一部分（参考：[dcl.link] / 1）。

因此reinterpret_cast<SignalHandlerFn>的结果要么是格式错误的，要么是指向C语言链接的函数的指针。

因此，将此转换描述为“剥离外部C”似乎是不正确的 - 尽管编译器当然可以通过发出诊断来对不良代码做出反应，然后继续进行，好像代码有一些任意行为。

在您的代码示例中，reinterpret_cast<SignalHandlerFn>的两种用法都是格式正确的，因为reinterpret_cast可以将任何函数指针转换为任何其他函数指针（ref：[expr.reinterpret.cast] / 6）。

但是，通过SignalHandler::NullHandler调用sa_handler将导致未定义的行为（参考：同上。）。编译器产生的警告可能是为了警告这种情况。

Answer 2

sigaction结构定义为：

   struct sigaction {
       void     (*sa_handler)(int);
       void     (*sa_sigaction)(int, siginfo_t *, void *);
       sigset_t   sa_mask;
       int        sa_flags;
       void     (*sa_restorer)(void);
   };

你使用struct sigaction的void（* sa_handler）（int）;从一些SignalHandlerFn获得分配。因此，两个声明都应该在extern "C"之内，例如

extern "C" {
  #include <signal.h>
};

和

extern "C" {
  typedef void (*SignalHandlerFn) (int);
};

或者两者都应该支持C ++的名字mangling，即。没有extern "C"作为：

  #include <signal.h>

和

  typedef void (*SignalHandlerFn) (int);

C ++是否会剥夺＆＃34;外部＆＃34; C＆＃34;＆＃39;从声明？

2 个答案: