C实现的最大计算能力

如果我们按照本书（或您愿意的话，可以选择其他任何语言规范版本）进行阅读，那么C实现可以具有多少计算能力？

请注意，“ C实现”具有技术含义：它是C编程语言规范的特定实例，其中记录了实现定义的行为。AC实施不必一定可以在实际计算机上运行。它确实必须实现整个语言，包括每个具有位字符串表示形式的对象和具有实现定义的大小的类型。

出于此问题的目的，没有外部存储。您可能执行的唯一输入/输出是getchar（读取程序输入）和putchar（写入程序输出）。同样，任何调用未定义行为的程序都是无效的：有效程序的行为必须由C规范以及附录J中列出的实现定义的行为的实现描述（对于C99）进行定义。请注意，标准中未提及的调用库函数是未定义的行为。

我最初的反应是，C实现只不过是有限的自动机，因为它对可寻址内存的数量有限制（您不能寻址的存储sizeof(char*) * CHAR_BIT位数更多，因为存储时不同的内存地址必须具有不同的位模式）在字节指针中）。

但是，我认为实现不仅仅可以做到这一点。据我所知，该标准对递归的深度没有限制。因此，您可以根据需要进行任意数量的递归函数调用，只有有限数量的调用中的所有调用都必须使用不可寻址（register）参数。因此，允许任意递归并且对register对象数量没有限制的C实现可以编码确定性下推自动机。

它是否正确？您能找到更强大的C实现吗？是否存在图灵完备的C实现？

正如问题中指出的那样，标准C要求存在一个值UCHAR_MAX，以便每个类型的变量unsigned char将始终保持一个介于0到UCHAR_MAX（含）之间的值。它还要求每个动态分配的对象都由一个字节序列表示，该字节序列可以通过type的指针标识unsigned char*，并且必须有一个常量sizeof(unsigned char*)，使得该类型的每个指针都可以由sizeof(unsigned char *)type 的值序列标识unsigned char。因此，可以同时动态分配的对象数严格限制为。没有什么可以阻止理论上的编译器分配这些常量的值以支持超过$UCHAR\_MAX ^{sizeof(unsigned\ char*)}$$10^{10^{10}}$ 对象，但从理论上讲，无论有多大，任何边界的存在都意味着事物不是无限的。

如果没有分配任何在堆栈上分配的地址，那么程序可以在堆栈上存储无限量的信息。因此，可能会有一个C程序能够执行某些事情，而这是任何大小的有限自动机都无法完成的。因此，尽管（或者也许是因为）对堆栈变量的访问比对动态分配的变量的访问受到更多限制，但它使C从有限的自动机变成了下推式自动机。

但是，还有另一个潜在的问题：如果程序检查与两个指向不同对象的指针关联的字符值的基础固定长度序列，则这些序列必须是唯一的。由于只有可能的字符值序列，因此，如果代码曾经检查过以下对象，则任何创建了多个指向不同对象的指针的程序均不符合C标准。与那些指针关联的字符序列$UCHAR\_MAX ^{sizeof(unsigned\ char*)}$。但是，在某些情况下，编译器可能会确定没有代码会检查与指针关联的字符序列。如果每个“字符”实际上都能够容纳任何有限的整数，并且该机器的内存是一个无穷无尽的整数序列（给定无限磁带的图灵机，尽管它确实很慢，但可以模拟这样的机器），然后确实有可能使C成为图灵完备的语言。

使用C11的（可选）线程库，可以在无限递归深度的情况下完成Turing的完整实现。

创建一个新线程将产生第二个堆栈；图灵完整性的两个堆栈就足够了。一个堆栈表示头部的左侧，另一个堆栈表示右侧。

我认为这已经完成了图灵：我们可以使用此技巧来编写一个模拟UTM的程序（我很快就手工编写了代码，因此可能存在一些语法错误...但是我希望逻辑中没有（主要）错误。 :-)

• 定义一个可用作磁带表示的双链表的结构

    typdef struct {
      cell_t * pred; //左侧的单元格
      cell_t * succ; //右边的单元格
      int val; //储存格值
    } cell_t 

的head将是一个指向cell_t结构

• 定义可用于存储当前状态和标志的结构

    typedef struct {
      int状态
      int标志；
    } info_t 

• 然后定义一个单循环函数，当头部位于双链表的边界之间时，该函数将模拟Universal TM；当头部碰到边界时，设置info_t结构的标志（HIT_LEFT，HIT_RIGHT）并返回：

void Simulation_UTM（cell_t * head，info_t * info）{
  而（true）{
    head-> val = UTM_nextsymbol [info-> state，head-> val]; //写符号
    info-> state = UTM_nextstate [info-> state，head-> val]; //下一个状态
    if（info-> state == HALT_STATE）{//打印是否接受并退出程序
       putchar（（info-> state == ACCEPT_STATE）？'1'：'0'）;
       退出（0）;
    }
    int move = UTM_nextmove [info-> state，head-> val];
    如果（移动== MOVE_LEFT）{
      head = head-> pred; // 向左移动
      如果（head == NULL）{info-> flag = HIT_LEFT; 返回; }
    }其他{
      头=头->成功; // 向右移
      如果（head == NULL）{info-> flag = HIT_RIGHT; 返回; }
    }
  } //仍在边界中……继续
}

• 然后定义一个递归函数，该函数首先调用模拟UTM例程，然后在需要扩展磁带时递归调用自身。当磁带需要在顶部扩展（HIT_RIGHT）没问题时，当磁带需要在底部扩展（HIT_LEFT）时，只需使用双链表向上移动单元格的值即可：

void stacker（cell_t * top，cell_t * bottom，cell_t * head，info_t * info）{
  Simulation_UTM（head，info）;
  cell_t newcell; //新单元格
  newcell.pred =顶部; //用新单元格更新双链表
  newcell.succ = NULL;
  top-> succ =＆newcell;
  newcell.val = EMPTY_SYMBOL;

  开关（信息->点击）{
    案例HIT_RIGHT：
      堆栈器（＆newcell，bottom，newcell，info）;
      打破;
    案例HIT_BOTTOM：
      cell_t * tmp = newcell;
      while（tmp-> pred！= NULL）{//上移值
        tmp-> val = tmp-> pred-> val;
        tmp = tmp-> pred;
      }
      tmp-> val = EMPTY_SYMBOL;
      堆栈器（＆newcell，bottom，bottom，info）;
      打破;
  }
}

• 初始磁带可以用一个简单的递归函数填充，该函数构建双链表，然后stacker在读取输入磁带的最后一个符号时调用该函数（使用readchar）

void init_tape（cell_t * top，cell_t * bottom，info_t * info）{
  cell_t newcell;
  int c = readchar（）;
  如果（c == END_OF_INPUT）堆栈器（＆top，bottom，bottom，info）; //没有更多的符号，开始
  newcell.pred =顶部;
  如果（top！= NULL）top.succ =＆newcell; else bottom =＆newcell;
  init_tape（＆newcell，bottom，info）;
}

编辑：经过一番思考之后，指针出现了问题...

如果递归函数的每个调用都stacker可以维护一个有效的指针指向调用者本地定义的变量，那么一切都很好 ; 否则，我的算法将无法在无限递归上保留有效的双向链接列表（在这种情况下，看不到使用递归模拟无限随机访问存储的方法）。

只要您拥有无限的调用堆栈大小，就可以在调用堆栈上对磁带进行编码，并通过回绕堆栈指针来随机访问它，而无需从函数调用中返回。

EdIT：如果只能使用有限的ram，则此构造将不再起作用，因此请参见下文。

但是，为什么您的堆栈可以是无限的，而固有内存不是，这是一个非常可疑的问题。因此，实际上我想说的是，由于状态的数量是有限的，因此您甚至无法识别所有常规语言（如果您不计算利用无限堆栈的堆栈倒数技巧）。

我什至推测您可以识别的语言数量是有限的（即使语言本身可以是无限的，例如a*也可以，但b^k仅适用于ks的数量有限）。

编辑：这是不正确的，因为您可以在其他功能中对当前状态进行编码，因此您可以真正识别所有常规语言。

出于相同的原因，您很可能会获得所有Type-2语言，但是我不确定是否可以将状态和堆栈常量都放在调用堆栈上。但总的来说，您可以有效地忽略ram，因为您始终可以缩放自动机的大小，因此您的字母超过了ram的容量。因此，如果您可以仅模拟一个具有堆栈的TM，则Type-2等于Type-0，不是吗？

我曾经考虑过这一点，因此决定尝试使用预期的语义实现非上下文无关的语言。实现的关键部分是以下功能：

void *it;

void read_triple(void *back)
{
  if(read_a()) read_triple(&back);
  else reject();
  for(it = back; it != NULL; it = *it)
     if(!read_b()) reject();
  if(read_c()) return;
  else reject();
}

$\{a^n b^n c^n\}$

至少，我认为这可行。不过，可能是我犯了一些根本性的错误。

固定版本：

void *it;

void read_triple(void *back)
{
  if(read_a()) read_triple(&back);
  else for(it = back; it != NULL; it = * (void **) it)
     if(!read_b()) reject();
  if(read_c()) return;
  else reject();
}

按照@supercat的答案：

C的不完全性主张似乎围绕着不同的对象应该具有不同的地址，并且假定地址集是有限的。正如@supercat所写

正如问题中指出的那样，标准C要求存在一个值UCHAR_MAX，以使每个unsigned char类型的变量始终保持介于0到0 UCHAR_MAX（含）之间的值。它还要求每个动态分配的对象都由一个字节序列表示，该字节序列可以通过unsigned char *类型的指针来标识，并且必须有一个常量sizeof(unsigned char*)，使得该类型的每个指针都可以由一系列sizeof(unsigned char *)unsigned类型的值来标识。字符

unsigned char*$\mathbb{N}$$\{0, 1\}$sizeof(unsigned char*)$\{0, 1\}^{\operatorname{sizeof}(\mathit{unsigned\ char*})}$$\mathbb{N}$sizeof(unsigned char*)$\mathbb{N}$$\omega$

在这一点上，应该检查一下C标准是否确实允许这样做。

sizeof$\in \mathbb Z$