เหตุใดตัวอักษรตัวอักษร C จึงอยู่ภายในแทนอักขระ

ใน C sizeof('a') == sizeof(char) == 1++, สิ่งนี้ทำให้เข้าใจง่ายเนื่องจาก'a'เป็นอักขระตามตัวอักษรและsizeof(char) == 1ตามที่กำหนดโดยมาตรฐาน

ใน C อย่างไรก็ตามsizeof('a') == sizeof(int). นั่นคือดูเหมือนว่าอักษรตัวอักษร C เป็นจำนวนเต็ม มีใครรู้บ้างว่าทำไม? ฉันสามารถค้นหาการกล่าวถึง C quirk นี้ได้มากมาย แต่ไม่มีคำอธิบายว่าเหตุใดจึงมีอยู่

การอภิปรายในเรื่องเดียวกัน

"โดยเฉพาะอย่างยิ่งการส่งเสริมการขายแบบอินทิกรัลใน K&R C แทบจะเป็นไปไม่ได้เลยที่จะใช้ค่าอักขระโดยไม่ได้รับการเลื่อนขั้นเป็น int ก่อนดังนั้นการทำให้อักขระคงที่ int ในตอนแรกจึงตัดขั้นตอนนั้นออกไปและยังคงเป็นอักขระหลายตัว ค่าคงที่เช่น 'abcd' หรือจำนวนมากจะพอดีกับ int "

คำถามเดิมคือ "ทำไม"

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

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

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

สิ่งนี้ทำให้สิ่งต่าง ๆ ไม่สอดคล้องกันดังนั้นเมื่อ K&R เขียนหนังสือที่มีชื่อเสียงของพวกเขาพวกเขาจึงวางกฎที่ว่าตัวอักษรตามตัวอักษรจะได้รับการเลื่อนระดับเป็น int ในนิพจน์ใด ๆ เสมอไม่ใช่แค่พารามิเตอร์ฟังก์ชัน

เมื่อคณะกรรมการ ANSI กำหนดมาตรฐาน C เป็นครั้งแรกพวกเขาได้เปลี่ยนกฎนี้เพื่อให้ตัวอักษรตามตัวอักษรเป็น int เนื่องจากดูเหมือนจะเป็นวิธีที่ง่ายกว่าในการบรรลุสิ่งเดียวกัน

เมื่อ C ++ ได้รับการออกแบบฟังก์ชันทั้งหมดจำเป็นต้องมีต้นแบบทั้งหมด (ยังไม่จำเป็นต้องใช้ใน C แม้ว่าจะได้รับการยอมรับในระดับสากลว่าเป็นแนวปฏิบัติที่ดีก็ตาม) ด้วยเหตุนี้จึงมีการตัดสินใจว่าสามารถเก็บอักขระตามตัวอักษรไว้ในถ่านได้ ข้อดีของสิ่งนี้ใน C ++ คือฟังก์ชันที่มีพารามิเตอร์ char และฟังก์ชันที่มีพารามิเตอร์ int มีลายเซ็นที่แตกต่างกัน ข้อได้เปรียบนี้ไม่เป็นเช่นนั้นในค.

นี่คือเหตุผลที่พวกเขาแตกต่างกัน วิวัฒนาการ...

ฉันไม่ทราบสาเหตุที่เฉพาะเจาะจงว่าทำไมอักขระตามตัวอักษรใน C จึงเป็นประเภท int แต่ในภาษา C ++ มีเหตุผลที่ดีที่จะไม่ไปในทางนั้น พิจารณาสิ่งนี้:

void print(int);
void print(char);

print('a');

คุณคาดว่าการเรียกพิมพ์จะเลือกเวอร์ชันที่สองโดยใช้ถ่าน การมีอักขระตามตัวอักษรเป็น int จะทำให้เป็นไปไม่ได้ โปรดสังเกตว่าในตัวอักษร C ++ ที่มีอักขระมากกว่าหนึ่งตัวยังคงมีประเภท int แม้ว่าค่าจะถูกกำหนดการนำไปใช้งาน ดังนั้น'ab'มีประเภทintในขณะที่มีประเภท'a'char

ใช้ gcc บน MacBook ของฉันฉันลอง:

#include <stdio.h>
#define test(A) do{printf(#A":\t%i\n",sizeof(A));}while(0)
int main(void){
  test('a');
  test("a");
  test("");
  test(char);
  test(short);
  test(int);
  test(long);
  test((char)0x0);
  test((short)0x0);
  test((int)0x0);
  test((long)0x0);
  return 0;
};

ซึ่งเมื่อรันให้:

'a':    4
"a":    2
"":     1
char:   1
short:  2
int:    4
long:   4
(char)0x0:      1
(short)0x0:     2
(int)0x0:       4
(long)0x0:      4

ซึ่งแสดงให้เห็นว่าอักขระคือ 8 บิตอย่างที่คุณสงสัย แต่ตัวอักษรตัวอักษรเป็น int

ย้อนกลับไปตอนที่เขียน C ภาษาแอสเซมบลี MACRO-11 ของ PDP-11 มี:

MOV #'A, R0      // 8-bit character encoding for 'A' into 16 bit register

สิ่งนี้พบได้บ่อยในภาษาแอสเซมบลี - 8 บิตต่ำจะเก็บโค้ดอักขระส่วนบิตอื่น ๆ เคลียร์เป็น 0 PDP-11 ยังมี:

MOV #"AB, R0     // 16-bit character encoding for 'A' (low byte) and 'B'

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

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

address: value
20: 'X'
21: 'A'
22: 'A'
23: 'X'
24: 0
25: 'A'
26: 'A'
27: 0
28: 'A'

ถ้าคุณต้องการอ่านแค่ 'A' จากหน่วยความจำหลักนี้ลงในรีจิสเตอร์คุณจะอ่านอันไหน?

• ซีพียูบางตัวอาจรองรับการอ่านค่า 16 บิตในการลงทะเบียน 16 บิตโดยตรงซึ่งหมายความว่าการอ่านที่ 20 หรือ 22 จะต้องมีการล้างบิตจาก 'X' และขึ้นอยู่กับความสิ้นสุดของ CPU อย่างใดอย่างหนึ่ง จะต้องเปลี่ยนเป็นไบต์ลำดับต่ำ

• ซีพียูบางตัวอาจต้องการการอ่านที่จัดตำแหน่งหน่วยความจำซึ่งหมายความว่าแอดเดรสต่ำสุดที่เกี่ยวข้องจะต้องมีขนาดข้อมูลหลายขนาดคุณอาจอ่านได้จากที่อยู่ 24 และ 25 แต่ไม่ใช่ 27 และ 28

ดังนั้นคอมไพเลอร์ที่สร้างโค้ดเพื่อรับ 'A' ลงในรีจิสเตอร์อาจต้องการที่จะเสียหน่วยความจำเพิ่มเล็กน้อยและเข้ารหัสค่าเป็น 0 'A' หรือ 'A' 0 - ขึ้นอยู่กับ endianness และตรวจสอบให้แน่ใจว่ามันอยู่ในแนวเดียวกันอย่างถูกต้อง ( เช่นไม่อยู่ในที่อยู่หน่วยความจำแปลก ๆ )

ฉันเดาว่า C เพียงแค่ดำเนินการในระดับนี้ของพฤติกรรมที่เน้น CPU เป็นศูนย์กลางโดยนึกถึงค่าคงที่ของอักขระที่มีขนาดการลงทะเบียนของหน่วยความจำโดยพิจารณาจากการประเมินทั่วไปของ C ว่าเป็น "แอสเซมเบลอร์ระดับสูง"

(ดู 6.3.3 ในหน้า 6-25 ของhttp://www.dmv.net/dec/pdf/macro.pdf )

ฉันจำได้ว่าอ่าน K&R และเห็นข้อมูลโค้ดที่จะอ่านทีละอักขระจนกว่าจะถึง EOF เนื่องจากอักขระทั้งหมดเป็นอักขระที่ถูกต้องที่จะอยู่ในไฟล์ / อินพุตสตรีมจึงหมายความว่า EOF ไม่สามารถเป็นค่าถ่านได้ สิ่งที่โค้ดทำคือใส่อักขระอ่านลงใน int จากนั้นทดสอบ EOF จากนั้นแปลงเป็น char หากไม่ใช่

ฉันรู้ว่านี่ไม่ได้ตอบคำถามของคุณอย่างตรงไปตรงมา แต่มันจะสมเหตุสมผลสำหรับตัวอักษรที่เหลือที่จะมีขนาด (int) ถ้าตัวอักษร EOF เป็น

int r;
char buffer[1024], *p; // don't use in production - buffer overflow likely
p = buffer;

while ((r = getc(file)) != EOF)
{
  *(p++) = (char) r;
}

ฉันไม่เห็นเหตุผลของมัน (ตัวอักษร C char เป็นประเภท int) แต่นี่คือสิ่งที่ Stroustrup พูดถึงเรื่องนี้ (จากการออกแบบและวิวัฒนาการ 11.2.1 - ความละเอียดแบบละเอียด):

ใน C ประเภทของตัวละครตัวอักษรดังกล่าวเป็นเป็น'a' intน่าแปลกที่การให้'a'ประเภทcharใน C ++ ไม่ก่อให้เกิดปัญหาความเข้ากันได้ ยกเว้นตัวอย่างทางพยาธิวิทยาsizeof('a')ทุกโครงสร้างที่สามารถแสดงได้ทั้ง C และ C ++ ให้ผลลัพธ์เหมือนกัน

ดังนั้นส่วนใหญ่ไม่ควรทำให้เกิดปัญหา

เหตุผลทางประวัติศาสตร์คือ C และ B รุ่นก่อนได้รับการพัฒนาในรุ่นต่างๆของมินิคอมพิวเตอร์ DEC PDP ที่มีขนาดคำต่างๆซึ่งรองรับ ASCII แบบ 8 บิต แต่สามารถคำนวณเลขคณิตบนรีจิสเตอร์เท่านั้น (ไม่ใช่ PDP-11 อย่างไรก็ตามที่มาในภายหลัง) C เวอร์ชันก่อนกำหนดintให้เป็นขนาดคำดั้งเดิมของเครื่องและค่าใด ๆ ที่เล็กกว่าที่intจำเป็นต้องขยายintเพื่อที่จะส่งผ่านไปยังหรือจากฟังก์ชัน หรือใช้ในนิพจน์เชิงตรรกะหรือเลขคณิตแบบบิตเพราะนั่นคือวิธีการทำงานของฮาร์ดแวร์พื้นฐาน

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

นี่คือพฤติกรรมที่ถูกต้องเรียกว่า "การส่งเสริมแบบครบวงจร" มันสามารถเกิดขึ้นได้ในกรณีอื่น ๆ เช่นกัน (ตัวดำเนินการไบนารีส่วนใหญ่ถ้าฉันจำไม่ผิด)

แก้ไข: เพียงเพื่อให้แน่ใจว่าฉันจะตรวจสอบสำเนาของฉันของผู้เชี่ยวชาญด้านการเขียนโปรแกรม C: ความลับลึกและผมยืนยันว่าตัวอักษรถ่านไม่ได้เริ่มต้นด้วยการเป็นชนิดint เริ่มต้นเป็นประเภทcharแต่เมื่อใช้ในนิพจน์จะได้รับการเลื่อนขั้นเป็นไฟล์ int ต่อไปนี้มาจากหนังสือ:

ตัวอักษรมีประเภท int และไปที่นั่นโดยทำตามกฎสำหรับการเลื่อนตำแหน่งจากประเภท char นี่ครอบคลุมสั้นเกินไปใน K&R 1 ในหน้าที่ 39 โดยระบุว่า:

อักขระทุกตัวในนิพจน์จะถูกแปลงเป็น int .... สังเกตว่า float ทั้งหมดในนิพจน์จะถูกแปลงเป็น double .... เนื่องจากอาร์กิวเมนต์ของฟังก์ชันเป็นนิพจน์การแปลงประเภทจะเกิดขึ้นเมื่ออาร์กิวเมนต์ถูกส่งไปยังฟังก์ชัน: ใน โดยเฉพาะถ่านและสั้นกลายเป็น int ลอยกลายเป็นสองเท่า

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

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

นี่เป็นเพียงสัมผัสเดียวกับข้อมูลจำเพาะของภาษา แต่ในฮาร์ดแวร์ CPU มักจะมีขนาดรีจิสเตอร์เพียงหนึ่งขนาด - 32 บิตสมมติว่า - และเมื่อใดก็ตามที่ทำงานบนถ่าน (โดยการบวกลบหรือเปรียบเทียบ) จะมี การแปลงโดยนัยเป็น int เมื่อโหลดลงในรีจิสเตอร์ คอมไพเลอร์จะดูแลการมาสก์อย่างเหมาะสมและเปลี่ยนหมายเลขหลังจากการดำเนินการแต่ละครั้งดังนั้นหากคุณเพิ่มพูด 2 ถึง (ถ่านที่ไม่ได้ลงชื่อ) 254 มันจะพันรอบเป็น 0 แทนที่จะเป็น 256 แต่ภายในซิลิกอนจะเป็น int จนกว่าคุณจะบันทึกกลับไปยังหน่วยความจำ

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

(x86 วอนอาจทราบว่ามีเช่น op addh ดั้งเดิมที่เพิ่มการลงทะเบียนแบบกว้างสั้นในขั้นตอนเดียว แต่ภายในแกน RISC จะแปลเป็นสองขั้นตอน: เพิ่มตัวเลขจากนั้นขยายเครื่องหมายเช่นคู่เพิ่ม / extsh บน PowerPC)