C++ 字段'__jmpbuf'；无法解决-cpp

我在尝试编译程序时遇到以下错误：

Field '__jmpbuf' could not be resolved

我花了几个小时寻找解决办法，但似乎找不到罪魁祸首在哪里

Thread.h

文件包含类的头。它有一个私人成员：

sigjmp_buf _env;

并且实现在Thread.cpp中：

#include "Thread.h"
#include <setjmp.h>
#include "translateAdd.h"
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <sys/time.h>

#define COUNTER_INIT -1

int Thread::_idCounter = COUNTER_INIT;

Thread::Thread(void (*threadsFunc)(void))
: threadsFunction(threadsFunc), _stack(new char[STACK_SIZE]), _quantums(1)
{
      address_t sp, pc;

      sp = (address_t)_stack + STACK_SIZE - sizeof(address_t);
      pc = (address_t)threadsFunc;
      // set environment for later return
      sigsetjmp(_env, 1);
      (_env->__jmpbuf)[JB_SP] = translate_address(sp);
      (_env->__jmpbuf)[JB_PC] = translate_address(pc);
      sigemptyset(&_env->__saved_mask);

    _id = ++_idCounter;

    _state = READY;

}

#包括“Thread.h”
#包括
#包括“translatead.h”
#包括
#包括
#包括
#包括
#定义计数器_INIT-1
int线程：：_idCounter=COUNTER_INIT；
螺纹：：螺纹（空心（*threadsFunc）（空心））
：threadsFunction（threadsFunc），_stack（新字符[堆栈大小]），_quantums（1）
{
地址\u t sp，pc；
sp=（地址）堆栈+堆栈大小-大小（地址）；
pc=（地址）threadsFunc；
//设置稍后返回的环境
sigsetjmp（_env，1）；
（_env->_jmpbuf）[JB_SP]=翻译地址（SP）；
（_env->_jmpbuf）[JB_PC]=翻译地址（PC）；
SIGEPTYSET（&_env->uu saved_mask）；
_id=+\u id计数器；
_状态=就绪；
}

编辑：在ubuntu 32位下使用eclipse作为IDE

编辑：另一个未在我的计算机上编译的完整示例：

#include <stdio.h>
#include <setjmp.h>
#include <signal.h>
#include <unistd.h>
#include <sys/time.h>

#define SECOND 1000000
#define STACK_SIZE 4096

char stack1[STACK_SIZE];
char stack2[STACK_SIZE];

sigjmp_buf env[2];

#ifdef __x86_64__
/* code for 64 bit Intel arch */

typedef unsigned long address_t;
#define JB_SP 6
#define JB_PC 7

/* A translation is required when using an address of a variable.
   Use this as a black box in your code. */
address_t translate_address(address_t addr)
{
    address_t ret;
    asm volatile("xor    %%fs:0x30,%0\n"
        "rol    $0x11,%0\n"
                 : "=g" (ret)
                 : "0" (addr));
    return ret;
}

#else
/* code for 32 bit Intel arch */

typedef unsigned int address_t;
#define JB_SP 4
#define JB_PC 5 

/* A translation is required when using an address of a variable.
   Use this as a black box in your code. */
address_t translate_address(address_t addr)
{
    address_t ret;
    asm volatile("xor    %%gs:0x18,%0\n"
        "rol    $0x9,%0\n"
                 : "=g" (ret)
                 : "0" (addr));
    return ret;
}

#endif

void switchThreads(void)
{
  static int currentThread = 0;

  int ret_val = sigsetjmp(env[currentThread],1);
  printf("SWITCH: ret_val=%d\n", ret_val); 
  if (ret_val == 1) {
      return;
  }
  currentThread = 1 - currentThread;
  siglongjmp(env[currentThread],1);
}

void f(void)
{
  int i = 0;
  while(1){
    ++i;
    printf("in f (%d)\n",i);
    if (i % 3 == 0) {
      printf("f: switching\n");
      switchThreads();
    }
    usleep(SECOND);
  }
}

void g(void)
{
  int i = 0;
  while(1){
    ++i;
    printf("in g (%d)\n",i);
    if (i % 5 == 0) {
      printf("g: switching\n");
      switchThreads();
    }
    usleep(SECOND);
  }
}

void setup(void)
{
  address_t sp, pc;

  sp = (address_t)stack1 + STACK_SIZE - sizeof(address_t);
  pc = (address_t)f;
  sigsetjmp(env[0], 1);
  (env[0]->__jmpbuf)[JB_SP] = translate_address(sp);
  (env[0]->__jmpbuf)[JB_PC] = translate_address(pc);
  sigemptyset(&env[0]->__saved_mask);     

  sp = (address_t)stack2 + STACK_SIZE - sizeof(address_t);
  pc = (address_t)g;
  sigsetjmp(env[1], 1);
  (env[1]->__jmpbuf)[JB_SP] = translate_address(sp);
  (env[1]->__jmpbuf)[JB_PC] = translate_address(pc);
  sigemptyset(&env[1]->__saved_mask);         
}

int main(void)
{
  setup();      
  siglongjmp(env[0], 1);
  return 0;
}

#包括
#包括
#包括
#包括
#包括
#定义第二个1000000
#定义堆栈大小4096
char stack1[堆栈大小]；
字符堆栈2[堆栈大小]；
sigjmp_buf env[2]；
#ifdef\uuux86\u64__
/*64位Intel arch的代码*/
typedef无符号长地址\u t；
#定义JB_SP 6
#定义JB_PC 7
/*使用变量地址时需要进行转换。
将其用作代码中的黑框*/
地址翻译地址（地址地址）
{
地址(ret)；
asm易失性（“xor%%fs:0x30，%0\n”
rol$0x11，%0\n
：“=g”（ret）
：“0”（地址））；
返回ret；
}
#否则
/*32位Intel arch的代码*/
typedef无符号整数地址\u t；
#定义JB_SP 4
#定义JB_PC 5
/*使用变量地址时需要进行转换。
将其用作代码中的黑框*/
地址翻译地址（地址地址）
{
地址(ret)；
asm易失性（“xor%%gs:0x18，%0\n”
rol$0x9，%0\n
：“=g”（ret）
：“0”（地址））；
返回ret；
}
#恩迪夫
空心螺纹（空心）
{
静态int currentThread=0；
int ret_val=sigsetjmp（env[currentThread]，1）；
printf（“开关：返回值=%d\n”，返回值）；
如果（ret_val==1）{
返回；
}
currentThread=1—currentThread；
siglongjmp（env[currentThread]，1）；
}
无效f（无效）
{
int i=0；
而(1){
++一,；
printf（“在f（%d）\n）中，i）；
如果（i%3==0）{
printf（“f:switching\n”）；
开关线程（）；
}
usleep（第二）；
}
}
无效g（无效）
{
int i=0；
而(1){
++一,；
printf（“在g（%d）\n中，i）；
如果（i%5==0）{
printf（“g:switching\n”）；
开关线程（）；
}
usleep（第二）；
}
}
作废设置（作废）
{
地址\u t sp，pc；
sp=（地址）堆栈1+堆栈大小-sizeof（地址）；
pc=（地址）f；
sigsetjmp（env[0]，1）；
（env[0]->uu jmpbuf）[JB_SP]=翻译地址（SP）；
（env[0]->jmpbuf）[JB_PC]=翻译地址（PC）；
SIGEPTYSET（&env[0]->\u已保存\u掩码）；
sp=（地址）堆栈2+堆栈大小-sizeof（地址）；
pc=（地址）g；
sigsetjmp（env[1]，1）；
（env[1]->jmpbuf）[JB_SP]=翻译地址（SP）；
（env[1]->jmpbuf）[JB_PC]=翻译地址（PC）；
SIGEPTYSET（&env[1]->\u已保存\u掩码）；
}
内部主（空）
{
设置（）；
siglongjmp（env[0]，1）；
返回0；
}

如果确实需要使用内部字段（仅对系统上的编译器有效），则需要检查以下类型：

typedef struct __jmp_buf_tag sigjmp_buf[1];

这意味着

sigjmp_buf

不是指针，而是一个包含单个结构的数组。因此，您可以像使用普通结构数组一样使用它：

sigjmp_buf _env;

_env[0].__jmpbuf[x] = y;

---

我真的建议不要使用这个结构的内部字段。Linux还有其他功能来简化协作线程（这似乎是您正在实现的）。

未指定

sigjmp_buf

类型。您可以也不应该将其用作结构指针。

sigjmp_buf

通常定义为数组。这段代码（我猜不是你的代码）似乎认为它应该被定义为其他东西。@JoachimPileborg我们被告知要使用它。我已经添加了一个完整的代码示例，如果您可以look@john我添加了另一个使用数组的示例。仍然不编译它之所以不编译，是因为不能使用其中的字段。你甚至不知道它是否是一个指针（在这种情况下，你使用它时没有让它指向任何东西），更不用说带字段的结构了。这是一个不透明的盒子，你对它的内容一无所知。