พลังการคำนวณสูงสุดของการนำ C ไปใช้งาน

ถ้าเราไปตามหนังสือ (หรือรุ่นอื่น ๆ ของข้อกำหนดภาษาถ้าคุณต้องการ), การใช้พลังงาน C สามารถมีเท่าไหร่?

โปรดทราบว่า“ การติดตั้ง C” มีความหมายทางเทคนิค: มันเป็นอินสแตนซ์เฉพาะของสเปคภาษาการเขียนโปรแกรม C ที่มีการบันทึกพฤติกรรมการใช้งานที่กำหนดไว้ การติดตั้ง AC ไม่จำเป็นต้องสามารถทำงานบนคอมพิวเตอร์จริงได้ มันต้องใช้ภาษาทั้งหมดรวมถึงวัตถุทุกชิ้นที่มีการแทนค่าบิตสตริงและประเภทที่มีขนาดที่กำหนดการนำไปใช้

สำหรับวัตถุประสงค์ของคำถามนี้ไม่มีที่เก็บข้อมูลภายนอก อินพุต / เอาต์พุตเดียวที่คุณสามารถทำได้คือgetchar(เพื่ออ่านอินพุตโปรแกรม) และputchar(เพื่อเขียนเอาต์พุตของโปรแกรม) นอกจากนี้ยังมีโปรแกรมใด ๆ ที่จะเรียกไม่ได้กำหนดพฤติกรรมที่ไม่ถูกต้อง: โปรแกรมที่ถูกต้องจะต้องมีพฤติกรรมที่กำหนดโดยสเปค C บวกรายละเอียดการดำเนินงานของพฤติกรรมการดำเนินงานที่กำหนดไว้ในภาคผนวก J (สำหรับ C99) โปรดทราบว่าการเรียกฟังก์ชั่นห้องสมุดที่ไม่ได้กล่าวถึงในมาตรฐานเป็นพฤติกรรมที่ไม่ได้กำหนด

ปฏิกิริยาเริ่มต้นของฉันคือการใช้งาน C ไม่มีอะไรมากไปกว่าระบบ จำกัด อัตโนมัติเนื่องจากมันมีข้อ จำกัด เกี่ยวกับจำนวนหน่วยความจำที่กำหนดแอดเดรสได้ (คุณไม่สามารถจัดการกับหน่วยความจำได้มากกว่าsizeof(char*) * CHAR_BITบิตเนื่องจากหน่วยความจำที่แตกต่างกัน ในตัวชี้ไบต์)

อย่างไรก็ตามฉันคิดว่าการใช้งานสามารถทำได้มากกว่านี้ เท่าที่ฉันสามารถบอกได้มาตรฐานไม่มีข้อ จำกัด เกี่ยวกับความลึกของการเรียกซ้ำ ดังนั้นคุณสามารถเรียกใช้ฟังก์ชันเรียกซ้ำได้มากเท่าที่คุณต้องการเฉพาะการโทรจำนวน จำกัด เท่านั้นที่ต้องใช้registerอาร์กิวเมนต์ที่ไม่สามารถระบุตำแหน่งได้ ( ) ดังนั้นการดำเนินงาน C ที่ช่วยให้การเรียกซ้ำโดยพลการและมีการ จำกัด จำนวนของregisterวัตถุที่สามารถเข้ารหัสกำหนดขยายลงออโต

ถูกต้องหรือไม่ คุณจะพบว่าการติดตั้ง C ที่มีประสิทธิภาพยิ่งขึ้น? มีการนำ C ทัวริงไปใช้หรือไม่?

ดังที่ระบุไว้ในคำถามมาตรฐาน C กำหนดให้มีค่า UCHAR_MAX อยู่เช่นนั้นตัวแปรทุกประเภทunsigned charจะเก็บค่าระหว่าง 0 ถึง UCHAR_MAX เสมอ มันยังต้องใช้ว่าทุกวัตถุที่จัดสรรแบบไดนามิกจะแสดงโดยลำดับของไบต์ที่สามารถระบุตัวตนผ่านตัวชี้ของประเภทunsigned char*และที่มีอย่างต่อเนื่องsizeof(unsigned char*)ดังกล่าวว่าตัวชี้ชนิดว่าทุกที่จะระบุตัวตนได้โดยลำดับของค่าประเภทsizeof(unsigned char *) unsigned charจำนวนของวัตถุที่สามารถจัดสรรพร้อมกันแบบไดนามิกจึงถูก จำกัด ไว้ที่ ) ไม่มีสิ่งใดที่จะป้องกันนักแปลเชิงทฤษฎีจากการกำหนดค่าของค่าคงที่เหล่านั้นเพื่อสนับสนุนวัตถุมากกว่า 10 10 10แต่จากมุมมองทางทฤษฎีการดำรงอยู่ของขอบเขตใด ๆ ไม่ว่าขนาดใหญ่หมายความว่าสิ่งที่ไม่สิ้นสุด$UCHAR\_MAX ^{sizeof(unsigned\ char*)}$$10^{10^{10}}$

โปรแกรมสามารถเก็บปริมาณมากมายของข้อมูลเกี่ยวกับสแต็คถ้าไม่มีอะไรที่จะถูกจัดสรรในกองที่เคยมีอยู่ของนำ ; เราสามารถมีโปรแกรม C ที่สามารถทำบางสิ่งบางอย่างซึ่งไม่สามารถทำได้โดยหุ่นยนต์ที่มีขนาด จำกัด ใด ๆ ดังนั้นถึงแม้ว่า (หรืออาจเป็นเพราะ) การเข้าถึงตัวแปรสแต็กมีข้อ จำกัด มากกว่าการเข้าถึงตัวแปรที่จัดสรรแบบไดนามิก แต่จะเปลี่ยน C จากการเป็นหุ่นยนต์ที่มีขอบเขต จำกัด ให้กลายเป็นหุ่นยนต์แบบกดลง

อย่างไรก็ตามมีรอยย่นที่อาจเกิดขึ้นได้อีก: มันเป็นสิ่งจำเป็นว่าหากโปรแกรมตรวจสอบลำดับของอักขระที่มีความยาวคงที่ซึ่งเชื่อมโยงกับตัวชี้สองตัวไปยังวัตถุที่แตกต่างกันลำดับเหล่านั้นจะต้องไม่ซ้ำกัน เพราะมีเพียง$UCHAR\_MAX ^{sizeof(unsigned\ char*)}$ลำดับที่เป็นไปได้ของค่าตัวโปรแกรมที่สร้างจำนวนตัวชี้ไปยังวัตถุที่แตกต่างกันในส่วนที่เกินจากที่ไม่สามารถปฏิบัติตามมาตรฐานซีหากรหัสที่เคยตรวจสอบลำดับของตัวละครที่เกี่ยวข้องกับคำแนะนำเหล่านั้น มันอาจเป็นไปได้ในบางกรณีอย่างไรก็ตามสำหรับคอมไพเลอร์เพื่อตรวจสอบว่าไม่มีรหัสใดที่จะตรวจสอบลำดับของอักขระที่เกี่ยวข้องกับตัวชี้ ถ้าแต่ละคน "ถ่าน" ที่จริงก็คือความสามารถในการถือครองจำนวนเต็ม จำกัด ใด ๆ และหน่วยความจำของเครื่องเป็นลำดับนับอนันต์ของจำนวนเต็ม [รับเครื่องทัวริงไม่ จำกัด เทปใครสามารถเลียนแบบเครื่องดังกล่าวถึงแม้ว่ามันจะเป็นจริงๆช้า] จากนั้น มันจะเป็นไปได้ที่จะทำให้ C เป็นภาษาทัวริงที่สมบูรณ์

ด้วยเธรดไลบรารีของ C11 (เป็นทางเลือก) คุณสามารถทำการปรับใช้แบบทัวริงอย่างสมบูรณ์โดยให้ความลึกในการเรียกซ้ำไม่ จำกัด

การสร้างเธรดใหม่ทำให้ได้สแต็กที่สอง สองกองก็เพียงพอสำหรับทัวริงครบถ้วน กองหนึ่งหมายถึงสิ่งที่อยู่ทางด้านซ้ายของหัวกองอื่น ๆ ที่อยู่ทางขวา

ฉันคิดว่าทัวริงสมบูรณ์ : เราสามารถเขียนโปรแกรมที่จำลอง 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) และกลับมา:

ถือเป็นโมฆะ simulate_UTM (cell_t * head, info_t * info) {
  ในขณะที่ (จริง) {
    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 == MOVE_LEFT) {
      หัว = หัว -> pred; // เลื่อนไปทางซ้าย
      if (head == NULL) {info-> flag = HIT_LEFT; กลับ; }
    } อื่น {
      หัว = หัว -> succ; // เลื่อนไปทางขวา
      if (head == NULL) {info-> flag = HIT_RIGHT; กลับ; }
    }
  } // ยังอยู่ในขอบเขต ... ดำเนินต่อไป
}

• จากนั้นกำหนดฟังก์ชั่นแบบเรียกซ้ำที่เรียกรูทีน UTM จำลองก่อนแล้วจึงเรียกตัวเองซ้ำเมื่อต้องการขยายเทป เมื่อต้องการขยายเทปด้านบน (HIT_RIGHT) ไม่มีปัญหาเมื่อต้องการเลื่อนด้านล่าง (HIT_LEFT) เพียงเลื่อนค่าของเซลล์โดยใช้รายการที่เชื่อมโยงสองครั้ง:

ตัว void stacker (cell_t * top, cell_t * bottom, cell_t * head, info_t * ข้อมูล) {
  simulate_UTM (หัว, ข้อมูล);
  cell_t newcell; // เซลล์ใหม่
  newcell.pred = top; // อัปเดตรายการที่ลิงก์สองครั้งด้วยเซลล์ใหม่
  newcell.succ = NULL;
  top-> succ = & newcell;
  newcell.val = EMPTY_SYMBOL;

  สวิตช์ (ข้อมูล -> จำนวนครั้ง) {
    กรณี HIT_RIGHT:
      stacker (& newcell, ด้านล่าง, newcell, ข้อมูล);
      ทำลาย;
    กรณี HIT_BOTTOM:
      cell_t * tmp = newcell;
      ในขณะที่ (tmp-> pred! = NULL) {// เลื่อนค่า
        tmp-> val = tmp-> pred-> val;
        tmp = tmp-> pred;
      }
      tmp-> val = EMPTY_SYMBOL;
      รถยก (& newcell, ด้านล่าง, ด้านล่าง, ข้อมูล);
      ทำลาย;
  }
}

• เทปเริ่มต้นสามารถเติมเต็มด้วยฟังก์ชั่นวนซ้ำอย่างง่ายที่สร้างรายการเชื่อมโยงสองชั้นแล้วเรียกใช้stackerฟังก์ชันเมื่ออ่านสัญลักษณ์สุดท้ายของเทปป้อนข้อมูล (โดยใช้ readchar)

โมฆะ init_tape (cell_t * ด้านบน, cell_t * ด้านล่าง, info_t * ข้อมูล) {
  cell_t newcell;
  int c = readchar ();
  ถ้า (c == END_OF_INPUT) รถยก (& บน, ล่าง, ล่าง, ข้อมูล); // ไม่มีสัญลักษณ์เพิ่มเติมให้เริ่ม
  newcell.pred = top;
  if (top! = NULL) top.succ = & newcell; else bottom = & newcell;
  init_tape (& newcell, ด้านล่าง, ข้อมูล);
}

แก้ไข:หลังจากคิดเล็กน้อยเกี่ยวกับเรื่องนี้มีปัญหากับพอยน์เตอร์ ...

ถ้าการเรียกร้องของฟังก์ชันเวียนทุกstackerสามารถ mantain ตัวชี้ที่ถูกต้องให้กับตัวแปรที่กำหนดไว้ในประเทศในโทรแล้วทุกอย่างดี ; มิฉะนั้นอัลกอริทึมของฉันไม่สามารถรวบรวมรายการเชื่อมโยงสองเท่าที่ถูกต้องในการเรียกซ้ำแบบไม่ จำกัด (และในกรณีนี้จะไม่เห็นวิธีใช้การสอบถามซ้ำเพื่อจำลองที่เก็บแบบสุ่มเข้าถึงแบบไม่ จำกัด )

ตราบใดที่คุณมีขนาดสแต็กการโทรที่ไม่ได้ จำกัด คุณสามารถเข้ารหัสเทปของคุณบนสแต็กการโทรและสุ่มเข้าถึงได้โดยกรอสแต็กตัวชี้สแต็กโดยไม่ส่งคืนจากฟังก์ชันการโทร

แก้ไข : หากคุณสามารถใช้ ram ซึ่งมี จำกัด การก่อสร้างนี้จะไม่ทำงานอีกต่อไปดังนั้นโปรดดูด้านล่าง

อย่างไรก็ตามมันเป็นเรื่องที่น่าสงสัยอย่างมากว่าทำไมสแต็กของคุณถึงไม่มีที่สิ้นสุด แต่หน่วยความจำภายในนั้นไม่ใช่ ดังนั้นจริง ๆ แล้วฉันจะบอกว่าคุณไม่สามารถจำภาษาปกติทั้งหมดได้เนื่องจากจำนวนสถานะถูก จำกัด ขอบเขต (หากคุณไม่นับกลวิธีการกองซ้อนย้อนกลับเพื่อใช้ประโยชน์กองซ้อนแบบไม่มีที่สิ้นสุด)

ฉันยังคาดการณ์ว่าจำนวนภาษาที่คุณจำได้นั้นมี จำกัด (แม้ว่าภาษาของตัวเองจะไม่มีที่สิ้นสุดเช่นa*ก็โอเค แต่b^kใช้ได้กับจำนวน จำกัดkเท่านั้น)

แก้ไข : สิ่งนี้ไม่เป็นความจริงเนื่องจากคุณสามารถเข้ารหัสสถานะปัจจุบันในฟังก์ชั่นพิเศษเพื่อให้คุณสามารถจดจำภาษาปกติทั้งหมดได้อย่างแท้จริง

คุณน่าจะได้รับภาษา Type-2 ทั้งหมดด้วยเหตุผลเดียวกัน แต่ฉันไม่แน่ใจว่าคุณสามารถจัดการทั้งสองสถานะและสแต็นค่าคงที่ใน call-stack ได้หรือไม่ แต่ในบันทึกทั่วไปคุณสามารถลืม 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ดังกล่าวซึ่งตัวแปรประเภทถ่านที่ไม่ได้ลงชื่อทุกตัวจะเก็บค่าระหว่าง 0 UCHAR_MAXถึงรวม มันต้องการเพิ่มเติมว่าวัตถุที่จัดสรรแบบไดนามิกทุกตัวจะถูกแทนด้วยลำดับของไบต์ซึ่งสามารถระบุได้ผ่านตัวชี้ประเภทถ่านที่ไม่ได้ลงนาม * และมีค่าคงที่sizeof(unsigned char*)เช่นนั้นตัวชี้ทุกประเภทนั้นจะสามารถระบุได้ด้วยลำดับของsizeof(unsigned char *)ค่าชนิดที่ไม่ได้ลงนาม ถ่าน

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$