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

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

ดังนั้น: C99 ทัวริงเสร็จสมบูรณ์?

ฉันไม่แน่ใจ แต่ฉันคิดว่าคำตอบคือไม่ด้วยเหตุผลที่ลึกซึ้ง ฉันถามวิทยาศาสตร์คอมพิวเตอร์เชิงทฤษฎีเมื่อสองสามปีก่อนและไม่ได้รับคำตอบที่นอกเหนือไปจากสิ่งที่ฉันจะนำเสนอที่นี่

ในภาษาโปรแกรมส่วนใหญ่คุณสามารถจำลองเครื่องทัวริงโดย:

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

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

สิ่งนี้ใช้ไม่ได้ใน C เพราะเป็นไปไม่ได้ที่จะมีลิสต์ที่เชื่อมโยงซึ่งสามารถเติบโตได้ตลอดไป: มีจำนวน จำกัด ของโหนดเสมอ

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

ในการนำ C มาใช้นั้นไบต์จะมีค่าที่เป็นไปได้ข้อมูลทั้งหมดสามารถแสดงเป็นอาร์เรย์ไบต์: ชนิดมีค่าสูงสุด ค่าที่เป็นไปได้ จำนวนนี้แตกต่างกันไปในการใช้งานที่แตกต่างกันของ C แต่สำหรับการใช้งานที่กำหนดของ C ก็เป็นค่าคงที่ 2 CHAR_BIT ×ขนาด$2^{\texttt{CHAR_BIT}}$t$2^{\texttt{CHAR_BIT} \times \texttt{sizeof(t)}}$

โดยเฉพาะอย่างยิ่งพอยน์เตอร์สามารถใช้ได้สูงสุดค่า ซึ่งหมายความว่ามีจำนวนสูงสุดของวัตถุที่กำหนดแอดเดรสได้$2^{\texttt{CHAR_BIT} \times \texttt{sizeof(void*)}}$

ค่าของCHAR_BITและsizeof(void*)สามารถสังเกตได้ดังนั้นหากคุณมีหน่วยความจำไม่เพียงพอคุณจะไม่สามารถเรียกใช้โปรแกรมที่มีค่าขนาดใหญ่กว่าสำหรับพารามิเตอร์เหล่านั้นได้ คุณจะใช้โปรแกรมภายใต้ภาษาการเขียนโปรแกรมที่แตกต่างกัน - การใช้งาน C ที่แตกต่างกัน

หากโปรแกรมในภาษาสามารถมีสถานะของขอบเขตที่ จำกัด ได้เท่านั้นภาษาการเขียนโปรแกรมจะไม่สามารถแสดงออกได้อย่างชัดเจนกว่าออโต จำกัด ของ C ที่ถูก จำกัด ให้อยู่ในที่จัดเก็บข้อมูลได้นั้นอนุญาตได้เพียงไม่เกินสถานะของโปรแกรมโดยที่คือขนาดของไวยากรณ์นามธรรมของ โปรแกรม (แสดงถึงสถานะของโฟลว์ควบคุม) ดังนั้นโปรแกรมนี้สามารถจำลองโดยหุ่นยนต์ จำกัด กับหลายรัฐ หาก C มีความหมายมากจะต้องผ่านการใช้คุณสมบัติอื่น ๆ$n \times 2^{\texttt{CHAR_BIT} \times \texttt{sizeof(void*)}}$$n$

C ไม่ได้กำหนดความลึกการเรียกซ้ำสูงสุดโดยตรง การใช้งานได้รับอนุญาตให้มีสูงสุด แต่ก็อนุญาตให้ไม่มี แต่เราจะสื่อสารระหว่างการเรียกใช้ฟังก์ชันและหลักได้อย่างไร ข้อโต้แย้งนั้นไม่ดีถ้าพวกมันสามารถจัดการได้เพราะมันจะจำกัดความลึกของการเรียกซ้ำ: ถ้าคุณมีฟังก์ชั่นint f(int x) { … f(…) …}การเกิดขึ้นทั้งหมดของxเฟรมที่แอ็คทีฟfจะมีที่อยู่ของตัวเองดังนั้นจำนวนการโทรที่ซ้อนกันจะถูก จำกัด ด้วยจำนวน xของที่อยู่เป็นไปได้สำหรับ

โปรแกรม AC สามารถใช้ที่เก็บข้อมูลที่ไม่สามารถระบุตำแหน่งได้ในรูปแบบของregisterตัวแปร การใช้งาน“ ปกติ” สามารถมีตัวแปรขนาดเล็กจำนวน จำกัด ที่ไม่มีที่อยู่เท่านั้น แต่ในทางทฤษฎีแล้วการใช้งานอาจทำให้มีregisterพื้นที่เก็บข้อมูลไม่ จำกัด เช่นในการดำเนินงานที่คุณสามารถทำให้จำนวนเงินที่มากมายของสาย recursive registerกับฟังก์ชันตราบใดที่มีการโต้แย้ง แต่เนื่องจากข้อโต้แย้งคือregisterคุณไม่สามารถสร้างตัวชี้ได้ดังนั้นคุณจึงต้องคัดลอกข้อมูลรอบ ๆ อย่างชัดเจน: คุณสามารถส่งผ่านข้อมูลจำนวน จำกัด เท่านั้นไม่ใช่โครงสร้างข้อมูลขนาดที่กำหนดเองซึ่งเป็นตัวชี้

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

ฉันไม่สามารถหาทางไปต่อได้

(แน่นอนคุณสามารถทำให้โปรแกรมจัดเก็บเนื้อหาเทปจากภายนอกผ่านฟังก์ชั่นอินพุต / เอาท์พุต แต่จากนั้นคุณจะไม่ถามว่า C นั้นสมบูรณ์แบบทัวริงหรือไม่ แต่ C บวกกับระบบจัดเก็บข้อมูลที่ไม่มีที่สิ้นสุดนั้น . ซึ่งคำตอบคือน่าเบื่อ“ใช่” คุณก็เหมือนกันอาจกำหนดจัดเก็บข้อมูลที่จะเป็น oracle ทัวริง - โทร  fopen("oracle", "r+"), fwriteเนื้อหาเทปเริ่มต้นกับมันและfread. กลับเนื้อหาเทปสุดท้าย)

การเพิ่ม C99 ของva_copyAPI อาร์กิวเมนต์ variadic อาจให้เราเป็นประตูสู่ความสำเร็จของทัวริง เนื่องจากเป็นไปได้ที่จะวนซ้ำผ่านรายการอาร์กิวเมนต์ variadic มากกว่าหนึ่งครั้งในฟังก์ชันอื่นที่ไม่ใช่อาร์กิวเมนต์ที่ได้รับอาร์กิวเมนต์va_argsตั้งแต่แรก

แน่นอนการใช้งานจริงของอาร์กิวเมนต์ variadic API อาจจะมีตัวชี้อยู่ที่ไหนสักแห่ง แต่ในเครื่องนามธรรมของเรามันสามารถนำมาใช้โดยใช้เวทมนตร์แทน

ต่อไปนี้เป็นตัวอย่างการใช้งานหุ่นยนต์แบบกดลง 2 สแต็กพร้อมกฎการเปลี่ยนแปลงโดยพลการ:

#include <stdarg.h>
typedef struct { va_list va; } wrapped_stack; // Struct wrapper needed if va_list is an array type.
#define NUM_SYMBOLS /* ... */
#define NUM_STATES /* ... */
typedef enum { NOP, POP1, POP2, PUSH1, PUSH2 } operation_type;
typedef struct { int next_state; operation_type optype; int opsymbol; } transition;
transition transition_table[NUM_STATES][NUM_SYMBOLS][NUM_SYMBOLS] = { /* ... */ };

void step(int state, va_list stack1, va_list stack2);
void push1(va_list stack2, int next_state, ...) {
    va_list stack1;
    va_start(stack1, next_state);
    step(next_state, stack1, stack2);
}
void push2(va_list stack1, int next_state, ...) {
    va_list stack2;
    va_start(stack2, next_state);
    step(next_state, stack1, stack2);
}
void step(int state, va_list stack1, va_list stack2) {
    va_list stack1_copy, stack2_copy;
    va_copy(stack1_copy, stack1); va_copy(stack2_copy, stack2);
    int symbol1 = va_arg(stack1_copy, int), symbol2 = va_arg(stack2_copy, int);
    transition tr = transition_table[state][symbol1][symbol2];
    wrapped_stack ws;
    switch(tr.optype) {
        case NOP: step(tr.next_state, stack1, stack2);
        // Note: attempting to pop the stack's bottom value results in undefined behavior.
        case POP1: ws = va_arg(stack1_copy, wrapped_stack); step(tr.next_state, ws.va, stack2);
        case POP2: ws = va_arg(stack2_copy, wrapped_stack); step(tr.next_state, stack1, ws.va);
        case PUSH1: va_copy(ws.va, stack1); push1(stack2, tr.next_state, tr.opsymbol, ws);
        case PUSH2: va_copy(ws.va, stack2); push2(stack1, tr.next_state, tr.opsymbol, ws);
    }
}
void start_helper1(va_list stack1, int dummy, ...) {
    va_list stack2;
    va_start(stack2, dummy);
    step(0, stack1, stack2);
}
void start_helper0(int dummy, ...) {
    va_list stack1;
    va_start(stack1, dummy);
    start_helper1(stack1, 0, 0);
}
// Begin execution in state 0 with each stack initialized to {0}
void start() {
    start_helper0(0, 0);
}

หมายเหตุ: ถ้าva_listเป็นประเภทอาเรย์ก็จะมีพารามิเตอร์พอยน์เตอร์ที่ซ่อนอยู่ในฟังก์ชั่น ดังนั้นมันอาจจะดีกว่าการเปลี่ยนประเภทของทุกข้อโต้แย้งva_listwrapped_stack

เลขคณิตที่ไม่เป็นมาตรฐานอาจเป็นเพราะอะไร

ดังนั้นจึงดูเหมือนว่าปัญหามีขนาด จำกัด sizeof(t)ของ อย่างไรก็ตามฉันคิดว่าฉันรู้วิธีแก้ไข

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

นี้เป็นหนึ่งในวิชาของหลักสูตร: ทฤษฎีบท Tennenbaum ของ มันระบุว่าแบบจำลองทางคณิตศาสตร์เพียงอย่างเดียวของ Peano คือแบบมาตรฐานซึ่งเห็นได้ชัดว่าจะไม่ทำ อย่างไรก็ตามเท่าที่ฉันรู้ C ไม่จำเป็นต้องมีการใช้งานเพื่อใช้ชนิดข้อมูลที่ตอบสนองความจริงของ Peano และไม่ต้องใช้การคำนวณเพื่อให้สามารถคำนวณได้ดังนั้นจึงไม่ควรเป็นปัญหา

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

IMO ข้อ จำกัด ที่แข็งแกร่งคือพื้นที่ที่กำหนดแอดเดรสได้ (ผ่านขนาดตัวชี้) มี จำกัด และไม่สามารถกู้คืนได้

หนึ่งสามารถสนับสนุนหน่วยความจำที่สามารถ "สลับไปยังดิสก์" แต่ในบางจุดข้อมูลที่อยู่จะเกินขนาดแอดเดรสที่กำหนด

ในทางปฏิบัติข้อ จำกัด เหล่านี้ไม่เกี่ยวข้องกับทัวริงครบถ้วน ข้อกำหนดที่แท้จริงคือการอนุญาตให้เทปมีความยาวไม่ จำกัด นั่นจะสร้างปัญหาการหยุดชะงักของสิ่งต่าง ๆ (จักรวาลจะคำนวณเทปอย่างไร)

มันเป็นการหลอกลวงเช่นเดียวกับการพูดว่า "Python ไม่สมบูรณ์เนื่องจากคุณไม่สามารถสร้างรายการที่มีขนาดใหญ่มาก"

[แก้ไข: ขอบคุณ Mr. Whitledge ที่ช่วยอธิบายวิธีการแก้ไข]

สื่อแบบถอดได้ช่วยให้เราหลีกเลี่ยงปัญหาหน่วยความจำที่ไม่ได้ จำกัด บางทีผู้คนจะคิดว่านี่เป็นการละเมิด แต่ฉันคิดว่ามันใช้ได้และหลีกเลี่ยงไม่ได้

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

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

ฉันคิดว่าการคัดค้านหลักน่าจะเป็นการมีส่วนร่วมของผู้ใช้ แต่ดูเหมือนว่าจะหลีกเลี่ยงไม่ได้ในการดำเนินการใด ๆ เพราะดูเหมือนว่าจะไม่มีวิธีอื่นในการใช้หน่วยความจำที่ไม่ได้ จำกัด

เลือกที่size_tจะมีขนาดใหญ่อย่างไม่ จำกัด

คุณสามารถเลือกที่size_tจะมีขนาดใหญ่อย่างไม่ จำกัด ตามธรรมชาติมันเป็นไปไม่ได้ที่จะตระหนักถึงการใช้งาน แต่นั่นไม่น่าแปลกใจเลยเพราะธรรมชาติอัน จำกัด ของโลกที่เราอาศัยอยู่

ผลกระทบเชิงปฏิบัติ

แต่แม้ว่ามันจะเป็นไปได้ที่จะตระหนักถึงการดำเนินการดังกล่าวจะมีปัญหาในทางปฏิบัติ พิจารณาคำสั่ง C ต่อไปนี้:

printf("%zu\n",SIZE_MAX);

SIZE_MAXSIZE_MAX$O(2^{size\_t})$size_tSIZE_MAXprintf

โชคดีสำหรับวัตถุประสงค์ทางทฤษฎีของเราฉันไม่พบข้อกำหนดใด ๆ ในข้อกำหนดที่รับประกันprintfจะยุติสำหรับอินพุตทั้งหมด ดังนั้นเท่าที่ฉันทราบเราไม่ละเมิดข้อกำหนด C ที่นี่

ในความสมบูรณ์ของคอมพิวเตอร์

มันยังคงที่จะพิสูจน์ว่าการดำเนินการทางทฤษฎีของเราคือทัวริงสมบูรณ์ เราสามารถแสดงสิ่งนี้ได้โดยการใช้ "เครื่องทัวริงเทปแปะเดียว"

พวกเราส่วนใหญ่อาจใช้เครื่องทัวริงเป็นโครงการโรงเรียน ฉันจะไม่ให้รายละเอียดเกี่ยวกับการใช้งานเฉพาะ แต่นี่เป็นกลยุทธ์ที่ใช้กันโดยทั่วไป:

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

ตอนนี้เรามาดูสิ่งที่จำเป็นในการตระหนักถึงการใช้งานดังกล่าว:

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

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

อาร์กิวเมนต์หลักที่นี่คือขนาดของ size_t มี จำกัด แม้ว่าจะมีขนาดใหญ่มาก

มีวิธีแก้ไขปัญหาอยู่แม้ว่าฉันจะไม่แน่ใจว่าสิ่งนี้สอดคล้องกับ ISO C หรือไม่

สมมติว่าคุณมีเครื่องที่มีหน่วยความจำไม่ จำกัด ดังนั้นคุณจะไม่ถูก จำกัด ขนาดตัวชี้ คุณยังมีประเภท size_t อยู่ หากคุณถามฉันว่า sizeof (size_t) คำตอบจะเป็นแค่ sizeof (size_t) หากคุณถามว่ามันมากกว่า 100 ตัวอย่างคำตอบคือใช่ หากคุณถามว่า sizeof (size_t) / 2 คืออะไรคุณสามารถเดาได้ว่าคำตอบยังคงเป็น sizeof (size_t) หากคุณต้องการพิมพ์เราสามารถเห็นด้วยกับผลลัพธ์บางอย่าง ความแตกต่างของทั้งสองนี้อาจเป็น NaN เป็นต้น

สรุปคือการผ่อนคลายเงื่อนไขสำหรับ size_t มีขนาด จำกัด จะไม่ทำให้โปรแกรมที่มีอยู่แล้วพัง

PS การจัดสรรขนาดหน่วยความจำของ (size_t) ยังคงเป็นไปได้คุณต้องการเพียงขนาดที่นับได้ดังนั้นสมมติว่าคุณใช้ทุกสิ่ง (หรือเคล็ดลับที่คล้ายกัน)

ใช่แล้ว.

1. คำตอบที่ยกมา

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

[... ] ข้อโต้แย้งของเขามีดังนี้: สมมติว่ามีคนเขียนโปรแกรมยุติที่กำหนดซึ่งอาจต้องใช้ในระหว่างการดำเนินการของมันขึ้นอยู่กับจำนวนของพื้นที่เก็บข้อมูลโดยพลการ โดยไม่ต้องเปลี่ยนโปรแกรมนั้นเป็นไปได้ที่ posteriori จะใช้ชิ้นส่วนคอมพิวเตอร์ฮาร์ดแวร์และคอมไพเลอร์ C ที่มีพื้นที่จัดเก็บเพียงพอที่จะรองรับการคำนวณนี้ สิ่งนี้อาจต้องขยายความกว้างของอักขระถ่าน (ผ่าน CHAR_BITS) และ / หรือตัวชี้ (ผ่าน size_t) แต่โปรแกรมไม่จำเป็นต้องแก้ไข เนื่องจากสิ่งนี้เป็นไปได้ C จึงเป็นทัวริง - สมบูรณ์สำหรับการยกเลิกโปรแกรม

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

เหตุผลที่ทำให้ฉันเข้าใจผิดในความคิดของฉันมันทำให้ฉันกำลังพิจารณาในระดับที่กว้างขึ้นของโปรแกรม "ที่มีประโยชน์" ที่ไม่สิ้นสุด [... ]

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

2. คำตอบเดิมของฉัน

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

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

นี่เป็นสิ่งพื้นฐานมากเกี่ยวกับระบบโลจิคัลที่ควรจะเพียงพอสำหรับการพิสูจน์ที่ไม่สร้างสรรค์ พิจารณาแคลคูลัสที่มีความจริง schemata และกฎบางอย่างเช่นชุดของสมการเชิงตรรกะคือ X ตอนนี้ถ้าคุณเพิ่มกฎหรือสัจพจน์บางอย่างชุดของผลที่ตามมาจะเพิ่มขึ้นเช่นต้องเป็น superset ของ X นี่คือเหตุผล , S4 ตรรกะกิริยาที่มีอยู่ถูกต้องใน S5. ในทำนองเดียวกันเมื่อคุณมีการระบุย่อยซึ่งเป็นทัวริงสมบูรณ์ แต่คุณเพิ่มข้อ จำกัด บางอย่างด้านบนสิ่งเหล่านี้ไม่ได้ป้องกันผลกระทบใด ๆ ใน X เช่นต้องมีวิธีหลีกเลี่ยงข้อ จำกัด ทั้งหมด หากคุณต้องการภาษาที่ไม่ใช่ทัวริงสมบูรณ์แคลคูลัสต้องลดลงไม่ขยาย ส่วนขยายที่อ้างว่ามีบางสิ่งที่เป็นไปไม่ได้ แต่จริงๆแล้วคือเพิ่มความไม่สอดคล้องกันเท่านั้น ความไม่สอดคล้องกันเหล่านี้ในมาตรฐาน C อาจไม่มีผลที่เกิดขึ้นจริงเช่นเดียวกับทัวริง - ความสมบูรณ์ที่ไม่เกี่ยวข้องกับการใช้งานจริง

จำลองหมายเลขพลขึ้นอยู่กับความลึกของการเรียกซ้ำ (เช่นนี้ ; กับความเป็นไปได้ที่จะสนับสนุนหลายหมายเลขผ่านการตั้งเวลา / หลอกหัวข้อ; ไม่มีขีด จำกัด ทางทฤษฎีที่ความลึก recursion ใน C ) หรือใช้การจัดเก็บไฟล์เพื่อจำลองหน่วยความจำโปรแกรมได้ไม่ จำกัด ( ความคิด ) เป็น อาจจะมีเพียงสองออกจากความเป็นไปได้ที่ไม่มีขีด จำกัด ในการสร้างสรรค์พิสูจน์ทัวริง-ครบถ้วนของ C99 หนึ่งควรจำไว้ว่าสำหรับความซับซ้อนในการคำนวณเวลาและพื้นที่นั้นไม่เกี่ยวข้อง โดยเฉพาะอย่างยิ่งการสมมติว่าสภาพแวดล้อมที่ จำกัด เพื่อที่จะปลอมแปลงทัวริง - ความสมบูรณ์เป็นเพียงเหตุผลวงกลมเนื่องจากข้อ จำกัด ดังกล่าวไม่รวมปัญหาทั้งหมดที่เกินความซับซ้อนที่กำหนดไว้ล่วงหน้า

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