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

ภาษา C มีประเภททางคณิตศาสตร์พื้นฐาน เช่น ประเภท จำนวนเต็มและจำนวนจริงและไวยากรณ์สำหรับสร้างอาร์เรย์และประเภทผสม ไลบรารีมาตรฐานของภาษา Cมีคำจำกัดความเพิ่มเติมของประเภทสนับสนุนที่มีคุณสมบัติเพิ่มเติม เช่น การจัดเก็บข้อมูลที่มีขนาดที่แน่นอน โดยไม่ขึ้นอยู่กับการใช้งานภาษาบนแพลตฟอร์มฮาร์ดแวร์เฉพาะ^{[ 1 ] [ 2 ]}

ภาษา C มีตัวระบุชนิดข้อมูลทางคณิตศาสตร์พื้นฐานสี่แบบ ได้แก่char, int, floatและdouble(รวมถึงชนิดข้อมูลบูลีนด้วยbool) และตัวดัดแปลง ได้แก่signed, unsigned, short, และlongตารางต่อไปนี้แสดงรายการการผสมผสานที่อนุญาตในการระบุการประกาศเฉพาะขนาดพื้นที่จัดเก็บข้อมูลจำนวนมาก

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

ข้อกำหนดความสัมพันธ์คือ ต้องlong longไม่น้อยกว่าlongซึ่งไม่น้อยกว่า ซึ่งไม่intน้อยกว่าshortเนื่องจากcharขนาดของ เป็นขนาดขั้นต่ำสุดของชนิดข้อมูลที่รองรับเสมอ จึงไม่มีชนิดข้อมูลอื่นใด (ยกเว้นบิตฟิลด์ ) ที่จะมีขนาดเล็กกว่าได้

ขนาดขั้นต่ำสำหรับcharคือ 8 บิต ขนาดขั้นต่ำสำหรับshortและintคือ 16 บิต ส่วน สำหรับlongนั้นมีขนาด 32 บิต และlong longต้องมีอย่างน้อย 64 บิต

ประเภทintควรเป็นประเภทจำนวนเต็มที่โปรเซสเซอร์เป้าหมายทำงานได้อย่างมีประสิทธิภาพมากที่สุด ซึ่งช่วยให้มีความยืดหยุ่นสูง เช่น ประเภททั้งหมดสามารถเป็น 64 บิตได้ อย่างไรก็ตาม รูปแบบความกว้างของจำนวนเต็ม (โมเดลข้อมูล) ที่แตกต่างกันหลายแบบก็เป็นที่นิยม เนื่องจากโมเดลข้อมูลกำหนดวิธีการสื่อสารระหว่างโปรแกรมต่างๆ จึงมีการใช้โมเดลข้อมูลที่เป็นเอกภาพภายในอินเทอร์เฟซแอปพลิเคชันระบบปฏิบัติการที่กำหนด^{[ 10 ]}

ในทางปฏิบัติcharโดยทั่วไปจะมีขนาด 8 บิต และshortโดยทั่วไปจะมีขนาด 16 บิต (เช่นเดียวกับค่าที่ไม่ระบุเครื่องหมาย) สิ่งนี้เป็นจริงสำหรับแพลตฟอร์มที่หลากหลาย เช่นSunOS  4 Unix ในยุค 1990, Microsoft MS-DOS , Linuxรุ่นใหม่และ Microchip MCC18 สำหรับไมโครคอนโทรลเลอร์ PIC 8 บิตแบบฝังตัวPOSIX กำหนดให้มีcharขนาด 8 บิตพอดี^{[ 11 ] [ 12 ]}

กฎต่างๆ ในมาตรฐาน C ทำให้unsigned charประเภทพื้นฐานที่ใช้สำหรับอาร์เรย์เหมาะสมที่จะจัดเก็บวัตถุที่ไม่ใช่ฟิลด์บิตใดๆ ได้แก่ การไม่มีบิตเติมและการแสดงกับดัก คำจำกัดความของการแสดงวัตถุ [ ^{8 ] และความเป็นไปได้ของ การ}ใช้นามแฝง^{[ 13 ]}

ขนาดและลักษณะการทำงานของชนิดข้อมูลจุดลอยตัวนั้นแตกต่างกันไปตามการใช้งาน ข้อกำหนดเพียงอย่างเดียวคือlong doubleต้องไม่น้อยกว่าdoubleซึ่งต้องไม่น้อยกว่า โดยปกติแล้ว จะใช้รูปแบบเลขฐานสองแบบIEEE 754floatขนาด 32 บิตและ 64 บิต สำหรับ และตามลำดับ floatdouble

มาตรฐานC99ประกอบด้วยชนิดข้อมูลจุดลอยตัวจริงแบบใหม่float_tและdouble_tซึ่งกำหนดไว้ใน ชนิดข้อมูล<math.h>เหล่านี้สอดคล้องกับชนิดข้อมูลที่ใช้สำหรับผลลัพธ์ระดับกลางของนิพจน์จุดลอยตัวเมื่อFLT_EVAL_METHODมีค่าเป็น 0, 1 หรือ 2 ชนิดข้อมูลเหล่านี้อาจมีความกว้างlong doubleมากกว่า

นอกจากนี้ C99 ยังเพิ่มประเภทข้อมูลที่ซับซ้อนได้แก่float _Complex, double _Complex, C11เพิ่ม ประเภท ข้อมูลสมมติ (ซึ่งอธิบายไว้ในภาคผนวกข้อมูลของ C99) ได้แก่, , การรวมส่วนหัวทำให้สามารถเข้าถึงประเภทข้อมูลเหล่านี้ได้โดยใช้และตามลำดับ long double _Complexfloat _Imaginarydouble _Imaginarylong double _Imaginary<complex.h>compleximaginary

C99เพิ่มชนิดข้อมูลบูลีน (Boolean_Bool ) นอกจากนี้<stdbool.h>ส่วนหัวยังกำหนดให้boolเป็นชื่อเรียกย่อที่สะดวกสำหรับชนิดนี้ และยังมีมาโครสำหรับtrueและfalseอีก ด้วย _Boolทำงานคล้ายกับชนิดข้อมูลจำนวนเต็มปกติ โดยมีข้อยกเว้นหนึ่งอย่างคือ การแปลงใดๆ เป็น จะ_Boolให้ค่า 0 (เท็จ) ถ้าค่าเท่ากับ 0 มิฉะนั้นจะให้ค่า 1 (จริง) พฤติกรรมนี้มีไว้เพื่อหลีกเลี่ยงการโอเวอร์โฟลว์ของจำนวนเต็มในการแปลงแบบแคบโดยปริยาย ตัวอย่างเช่น ในโค้ดต่อไปนี้:

unsigned char b = 256 ;ถ้า( b ) { // ทำบางอย่าง}

ตัวแปรbจะมีค่าเป็นเท็จหากunsigned charมีขนาด 8 บิต เนื่องจากค่า 256 ไม่สามารถใส่ลงในชนิดข้อมูลได้ ทำให้ใช้เพียง 8 บิตล่าง ส่งผลให้ได้ค่าเป็นศูนย์ อย่างไรก็ตาม การเปลี่ยนชนิดข้อมูลจะทำให้โค้ดก่อนหน้านี้ทำงานได้ตามปกติ

_Bool b = 256 ;ถ้า( b ) { // ทำบางอย่าง}

ชนิดข้อมูลนี้_Boolยังช่วยให้ค่าที่เป็นจริงเปรียบเทียบกันได้เท่ากันเสมอ:

_Bool a = 1 ; _Bool b = 2 ;ถ้า( a == b ) { // โค้ดส่วนนี้จะทำงาน}

ในC23 ( boolและค่าของมันtrueและfalse) กลายเป็นฟังก์ชันหลักของภาษา (ทำให้เนื้อหาของ<stdbool.h>ล้าสมัย^{[ 14 ] [ 15 ]} ) ทำให้สามารถใช้ตัวอย่างโค้ดต่อไปนี้ได้:

bool b = true ;ถ้า( b ) { // โค้ดนี้จะทำงาน}

ตั้งแต่C23เป็นต้นมา ภาษาอนุญาตให้โปรแกรมเมอร์กำหนดจำนวนเต็มที่มีความกว้างเป็นจำนวนบิตตามอำเภอใจ ประเภทเหล่านั้นระบุเป็น โดยที่Nเป็นนิพจน์ค่าคงที่จำนวนเต็มที่แสดงจำนวนบิต รวมถึงบิตเครื่องหมายสำหรับประเภทที่มีเครื่องหมาย ซึ่งแสดงในรูปแบบสองส่วนเติมเต็ม ค่าสูงสุดของNกำหนดโดยและมีค่าอย่างน้อยดังนั้น ประเภท(หรือ) จะมีค่าตั้งแต่ -2 ถึง 1 ในขณะที่จะมีค่าตั้งแต่ 0 ถึง 3 ประเภทยังมีอยู่ด้วย โดยมีค่าเป็น 0 หรือ 1 และไม่มีประเภทที่มีเครื่องหมายที่เทียบเท่ากัน^{[ 16 ]}ข้อเสนอสำหรับC2Yเสนอให้ยกเลิกข้อจำกัดนี้และอนุญาตให้ซึ่งจะมีค่าที่เป็นไปได้คือ 0 และ -1 โดยลบกรณีพิเศษสำหรับออก^{[ 17 ]}_BitInt(N)BITINT_MAXWIDTHULLONG_WIDTH_BitInt(2)signed_BitInt(2)unsigned_BitInt(2)unsigned_BitInt(1)signed_BitInt(1)unsigned_BitInt(1)

ข้อกำหนดของภาษา C ประกอบด้วยtypedef s และเพื่อใช้แทนปริมาณที่เกี่ยวข้องกับหน่วยความจำ ขนาดของพวกมันถูกกำหนดตามความสามารถในการคำนวณทางคณิตศาสตร์ของโปรเซสเซอร์เป้าหมาย ไม่ใช่ความสามารถของหน่วยความจำ เช่น พื้นที่แอดเดรสที่ใช้งานได้ ทั้งสองประเภทนี้ถูกกำหนดไว้ในไฟล์เฮดเดอร์ size_tptrdiff_t<stddef.h>

size_tเป็นชนิดข้อมูลจำนวนเต็มไม่ระบุเครื่องหมายที่ใช้แสดงขนาดของวัตถุใดๆ (รวมถึงอาร์เรย์) ในการใช้งานเฉพาะนั้นๆ ตัวดำเนินการ `sizeof` จะให้ค่าของชนิดข้อมูลนี้ขนาดสูงสุดของ `sizeof` กำหนดโดย`sizeof` ซึ่งเป็นค่าคงที่มาโครที่กำหนดไว้ในส่วนหัว ` sizeof` รับประกันว่า `sizeof` จะมีความกว้างอย่างน้อย 16 บิต นอกจากนี้ POSIX ยังรวมถึง `sizeof` ซึ่งเป็นชนิดข้อมูลจำนวนเต็มระบุเครื่องหมายที่มีความกว้างเท่ากับ `sizeof` ด้วย size_tsize_tSIZE_MAX<stdint.h>size_tssize_tsize_t

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

ข้อมูลเกี่ยวกับคุณสมบัติที่แท้จริง เช่น ขนาดของชนิดข้อมูลทางคณิตศาสตร์พื้นฐาน จะถูกระบุผ่านค่าคงที่มาโครในไฟล์เฮดเดอร์สองไฟล์: <limits.h>ไฟล์เฮดเดอร์หนึ่งกำหนดมาโครสำหรับชนิดข้อมูลจำนวนเต็ม และ<float.h>อีกไฟล์เฮดเดอร์หนึ่งกำหนดมาโครสำหรับชนิดข้อมูลทศนิยม ค่าที่แท้จริงจะขึ้นอยู่กับการใช้งานในแต่ละระบบ

• CHAR_BIT– ขนาดของชนิดข้อมูล char ในหน่วยบิต ซึ่งโดยทั่วไปเรียกว่าขนาดของไบต์ (อย่างน้อย 8 บิต)
• SCHAR_MIN( C99) – ค่าต่ำสุดที่เป็นไปได้ของชนิดข้อมูลจำนวนเต็มที่มี เครื่องหมาย : signed char, signed SHRT_MINshort , signed int, signed long, signed long longINT_MINLONG_MINLLONG_MIN
• SCHAR_MAX( C99) – ค่าสูงสุดที่เป็นไปได้ของชนิดข้อมูลจำนวนเต็มแบบมีเครื่องหมาย: signed char, signed SHRT_MAXshort , signed int, signed long, signed long longINT_MAXLONG_MAXLLONG_MAX
• UCHAR_MAX( C99)USHRT_MAX – ค่าสูงสุดที่เป็นไปได้ของชนิดข้อมูลจำนวนเต็มที่ไม่มี เครื่องหมาย : unsigned char, unsigned short, unsigned int, UINT_MAXunsigned long, unsigned long longULONG_MAXULLONG_MAX
• CHAR_MIN– ค่าต่ำสุดที่เป็นไปได้ของอักขระ
• CHAR_MAX– ค่าสูงสุดที่เป็นไปได้ของอักขระ
• MB_LEN_MAX– จำนวนไบต์สูงสุดในอักขระแบบหลายไบต์
• BOOL_WIDTH(C23) - ความกว้างบิตของ_Bool, เท่ากับ 1 เสมอ
• CHAR_WIDTH(C23) - ความกว้างบิตของchar; CHAR_WIDTH, UCHAR_WIDTHและSCHAR_WIDTHมีค่าเท่ากันCHAR_BITตามนิยาม
• SCHAR_WIDTH, SHRT_WIDTH, INT_WIDTH, LONG_WIDTH, LLONG_WIDTH(C23) - ความกว้างบิตของsigned char, short, int, long, และlong longตามลำดับ
• UCHAR_WIDTH, USHRT_WIDTH, UINT_WIDTH, ULONG_WIDTH, ULLONG_WIDTH(C23) - ความกว้างบิตของunsigned char, unsigned short, unsigned int, unsigned long, และunsigned long longตามลำดับ

• FLT_MIN, DBL_MIN, LDBL_MIN– ค่าบวกขั้นต่ำที่ถูกทำให้เป็นมาตรฐานของ float, double และ long double ตามลำดับ
• FLT_TRUE_MIN, DBL_TRUE_MIN, LDBL_TRUE_MIN(C11) – ค่าบวกต่ำสุดของ float, double และ long double ตามลำดับ
• FLT_MAX, DBL_MAX, LDBL_MAX– ค่าสูงสุดที่จำกัดของ float, double และ long double ตามลำดับ
• FLT_ROUNDS– โหมดการปัดเศษสำหรับการคำนวณเลขทศนิยม
• FLT_EVAL_METHOD(C99) – วิธีการประเมินนิพจน์ที่เกี่ยวข้องกับชนิดข้อมูลจุดลอยตัวที่แตกต่างกัน
• FLT_RADIX– ฐานของเลขชี้กำลังในประเภทข้อมูลทศนิยม
• FLT_DIG, DBL_DIG, LDBL_DIG– จำนวนหลักทศนิยมที่สามารถแสดงได้โดยไม่สูญเสียความแม่นยำด้วย float, double และ long double ตามลำดับ
• FLT_EPSILON, DBL_EPSILON, LDBL_EPSILON– ผลต่างระหว่าง 1.0 กับค่าถัดไปที่สามารถแทนได้ของ float, double และ long double ตามลำดับ
• FLT_MANT_DIG, DBL_MANT_DIG, LDBL_MANT_DIG– จำนวนFLT_RADIXหลักฐาน - ในส่วนสำคัญของเลขทศนิยมสำหรับชนิด float, double และ long double ตามลำดับ
• FLT_MIN_EXP, DBL_MIN_EXP, LDBL_MIN_EXP– จำนวนเต็มลบที่น้อยที่สุด ซึ่งFLT_RADIXเมื่อยกกำลังด้วยค่าที่น้อยกว่าจำนวนนั้นหนึ่ง จะได้ค่า float, double และ long double ที่เป็นค่ามาตรฐาน ตามลำดับ
• FLT_MIN_10_EXP, DBL_MIN_10_EXP, LDBL_MIN_10_EXP– จำนวนเต็มลบที่น้อยที่สุดที่ทำให้ 10 ยกกำลังด้วยค่าดังกล่าวเป็น float, double และ long double ที่ถูกทำให้เป็นค่ามาตรฐานตามลำดับ
• FLT_MAX_EXP, DBL_MAX_EXP, LDBL_MAX_EXP– จำนวนเต็มบวกสูงสุดที่FLT_RADIXเมื่อยกกำลังด้วยค่าที่น้อยกว่าจำนวนนั้นหนึ่ง จะได้ค่า float, double และ long double ที่เป็นค่ามาตรฐาน ตามลำดับ
• FLT_MAX_10_EXP, DBL_MAX_10_EXP, LDBL_MAX_10_EXP– จำนวนเต็มบวกสูงสุดที่ทำให้ 10 ยกกำลังด้วยค่าดังกล่าวเป็น float, double และ long double ที่ถูกทำให้เป็นค่ามาตรฐานตามลำดับ
• DECIMAL_DIG(C99) – จำนวนหลักทศนิยมขั้นต่ำที่ทำให้สามารถแสดงจำนวนใดๆ ของชนิดข้อมูลจุดลอยตัวที่รองรับได้กว้างที่สุดในรูปทศนิยมด้วยความแม่นยำตามจำนวนDECIMAL_DIGหลักทศนิยมที่กำหนด และอ่านกลับเป็นชนิดข้อมูลจุดลอยตัวเดิมได้โดยไม่เปลี่ยนแปลงค่า ต้องDECIMAL_DIGมีอย่างน้อย 10 หลัก

มาตรฐานC99ประกอบด้วยคำจำกัดความของประเภทจำนวนเต็มใหม่หลายประเภทเพื่อเพิ่มความสามารถในการพกพาของโปรแกรม^{[ 2 ]}ประเภทจำนวนเต็มพื้นฐานที่มีอยู่แล้วถือว่าไม่เพียงพอ เนื่องจากขนาดจริงของประเภทเหล่านั้นถูกกำหนดโดยการใช้งานและอาจแตกต่างกันไปในระบบต่างๆ ประเภทใหม่เหล่านี้มีประโยชน์อย่างยิ่งในสภาพแวดล้อมแบบฝังตัวซึ่งโดยปกติฮาร์ดแวร์จะรองรับเพียงไม่กี่ประเภท และการรองรับนั้นจะแตกต่างกันไปในแต่ละสภาพแวดล้อม ประเภทใหม่ทั้งหมดได้รับการกำหนดไว้ใน<inttypes.h>ส่วนหัวและยังมีให้ใช้งานใน<stdint.h>ส่วนหัวด้วย ประเภทต่างๆ สามารถจัดกลุ่มได้เป็นหมวดหมู่ดังต่อไปนี้:

• ประเภทจำนวนเต็มที่มีขนาดความกว้างที่แน่นอน ซึ่งรับประกันว่าจะมีจำนวน บิต n เท่ากัน ในทุกการใช้งาน รวมไว้เฉพาะในกรณีที่มีให้ใช้งานในการใช้งานนั้นๆ
• ชนิดข้อมูลจำนวนเต็มที่ความกว้างน้อยที่สุด ซึ่งรับประกันว่าเป็นชนิดข้อมูลที่เล็กที่สุดที่มีอยู่ในระบบ และมีจำนวนบิตอย่างน้อยn ตามที่ระบุไว้ รับประกันว่าจะต้องมีการระบุค่า N อย่างน้อยเท่ากับ 8, 16, 32, 64
• ประเภทจำนวนเต็มที่เร็วที่สุดซึ่งรับประกันว่าเป็นประเภทจำนวนเต็มที่เร็วที่สุดที่มีอยู่ในระบบ โดยมีจำนวนบิตอย่างน้อยn ตามที่ระบุไว้ รับประกันว่าจะต้องมีการระบุค่า N อย่างน้อยเท่ากับ 8, 16, 32, 64
• ประเภทข้อมูลจำนวนเต็มที่รับประกันว่าสามารถเก็บค่าตัวชี้ได้ รวมไว้เฉพาะในกรณีที่มีให้ใช้งานในระบบเท่านั้น
• ประเภทจำนวนเต็มที่มีความกว้างสูงสุด ซึ่งรับประกันได้ว่าเป็นประเภทจำนวนเต็มที่ใหญ่ที่สุดในระบบการใช้งาน

ตารางต่อไปนี้สรุปประเภทและอินเทอร์เฟซสำหรับรับรายละเอียดการใช้งาน ( nหมายถึงจำนวนบิต):

ส่วนหัว นี้<inttypes.h>มีคุณสมบัติที่ช่วยเพิ่มประสิทธิภาพการทำงานของประเภทที่กำหนดไว้ใน<stdint.h>ส่วนหัว โดยจะกำหนดมาโครสำหรับ ตัวระบุ รูปแบบสตริง printfและscanfที่สอดคล้องกับประเภทที่กำหนดไว้<stdint.h>และฟังก์ชันต่างๆ สำหรับการทำงานกับ ประเภท intmax_tเหล่านั้นuintmax_tส่วนหัวนี้ถูกเพิ่มเข้ามาใน C99

มาโครอยู่ในรูปแบบ`<fmt>` โดยที่`{fmt}`กำหนดรูปแบบการแสดงผล และเป็นหนึ่งใน`<decimal>`, `<hexadecimal>`, `<octal>`, `<unsigned>` และ`<integer>` ` {type}`กำหนดชนิดของอาร์กิวเมนต์ และเป็นหนึ่งใน`<int>` , ` <int>`, `<int>`, ` <int>`, `<int> `, โดยที่ `<int> ` สอดคล้องกับจำนวนบิตในอาร์กิวเมนต์ PRI{fmt}{type}dxouinFASTnLEASTnPTRMAXn

มาโครอยู่ในรูปแบบ`<fmt>` โดยที่`{fmt}`กำหนดรูปแบบการแสดงผล และเป็นหนึ่งใน`<decimal>`, `<hexadecimal>`, `<octal>`, `<unsigned>` และ`<integer>` ` {type}`กำหนดชนิดของอาร์กิวเมนต์ และเป็นหนึ่งใน`<int>` , ` <int>`, `<int>`, ` <int>`, `<int> `, โดยที่ `<int> ` สอดคล้องกับจำนวนบิตในอาร์กิวเมนต์ SCN{fmt}{type}dxouinFASTnLEASTnPTRMAXn

เช่นเดียวกับชนิดข้อมูลจำนวนเต็มที่มีความกว้างคงที่ มาตรฐาน ISO/IEC TS 18661 กำหนดชนิดข้อมูลทศนิยมสำหรับการแลกเปลี่ยนข้อมูล IEEE 754 และรูปแบบขยายในระบบเลขฐานสองและฐานสิบ:

• _FloatNสำหรับรูปแบบการแลกเปลี่ยนไบนารี
• _DecimalNสำหรับรูปแบบการแลกเปลี่ยนเลขฐานสิบ;
• _FloatNxสำหรับรูปแบบไบนารีแบบขยาย;
• _DecimalNxสำหรับรูปแบบเลขฐานสิบแบบขยาย

ทุกชนิดข้อมูลTจะมีตัวชี้T ชนิดข้อมูลที่สอดคล้องกัน ตัวชี้คือชนิดข้อมูลที่เก็บที่อยู่ของตำแหน่งจัดเก็บข้อมูลของตัวแปรชนิดนั้นๆ โดยจะประกาศตัวชี้ด้วยเครื่องหมายดอกจัน (* *) ตามหลังชนิดข้อมูลพื้นฐานและอยู่หน้าชื่อตัวแปร การเว้นวรรคก่อนหรือหลังเครื่องหมายดอกจันนั้นไม่จำเป็น

char * p ; long * q ; int * r ;

นอกจากนี้ เรายังสามารถประกาศพอยน์เตอร์สำหรับชนิดข้อมูลพอยน์เตอร์ได้ ซึ่งจะสร้างพอยน์เตอร์ทางอ้อมหลายตัว เช่นchar **และint ***รวมถึงพอยน์เตอร์ไปยังชนิดข้อมูลอาร์เรย์ด้วย ชนิดหลังนี้พบได้น้อยกว่าอาร์เรย์ของพอยน์เตอร์ และไวยากรณ์ของมันอาจทำให้สับสนได้:

char * pc [ 10 ]; // อาร์เรย์ขององค์ประกอบ 10 ตัวของ 'ตัวชี้ไปยัง char' char ( * pa )[ 10 ]; // ตัวชี้ไปยังอาร์เรย์ของ char ที่มีองค์ประกอบ 10 ตัว

องค์ประกอบนี้pcต้องการหน่วยความจำสิบบล็อกที่มีขนาดเท่ากับตัวชี้ไปยังchar (โดยปกติคือ 40 หรือ 80 ไบต์บนแพลตฟอร์มทั่วไป) แต่ตัวชี้paมีเพียงตัวชี้เดียว (ขนาด 4 หรือ 8 ไบต์) และข้อมูลที่ตัวชี้อ้างถึงเป็นอาร์เรย์ขนาดสิบไบต์ ( ) sizeof*pa==10

C ยังมี "ตัวชี้ไปยังvoid" void *ด้วย^{[ 18 ]}ชื่อ "ตัวชี้ไปยังvoid" ไม่ได้หมายความว่ามันชี้ไปยังvoidหน่วยความจำ (เช่นvoidเดียวกับประเภทที่ไม่สมบูรณ์ที่ไม่มีขนาด) แต่หมายความว่ามันชี้ไปยังบางสิ่งที่มีประเภทไม่ระบุ ต้องแปลงเป็นประเภทตัวชี้อื่นก่อนจึงจะสามารถเข้าถึงค่าที่ชี้ได้ A void *อาจไม่ได้ชี้ไปยังฟังก์ชัน การเรียกใช้จะmallocส่งคืนค่าvoid *และfreeรับvoid *ค่า

ภาษา C ใช้แนวคิดของพอยเตอร์ว่างเพื่อแสดงถึงพอยเตอร์ที่ไม่ได้อ้างอิงถึงข้อมูลที่ถูกต้องใดๆ โดยทั่วไปNULLจะใช้มาโครแทนพอยเตอร์ว่าง โดยอาศัยการแปลงประเภทโดยปริยายเมื่อเป็นไปได้ อย่างไรก็ตาม การใช้งานนี้อาจมีปัญหาและอาจเป็นแหล่งที่มาของข้อผิดพลาดในการเขียนโปรแกรม โดยเฉพาะอย่างยิ่ง การขยายของNULLอาจมีประเภทพอยเตอร์หรือประเภทจำนวนเต็ม ขึ้นอยู่กับการใช้งานC23ได้แนะนำค่าคงที่ที่กำหนดไว้ล่วงหน้าnullptrและประเภทของมันnullptr_t(ซึ่งมีค่าเดียวคือnullptr) เพื่อแสดงค่าคงที่พอยเตอร์ว่าง เป็นตัวพnullptrอยเตอร์อย่างชัดเจน และอาจแปลงเป็นออบเจ็กต์หรือพอยเตอร์ฟังก์ชันใดๆ ก็ได้ และอนุญาตให้มีnullptr_tกรณีเฉพาะใน_Generic[ ^{19 ] ขนาด}และการจัดเรียงของประเภทนี้เหมือนกับพอยเตอร์ไปยังประเภทอักขระ (หรือvoid *) แต่ประเภทพอยเตอร์อื่นๆ อาจยังมีขนาดและการจัดเรียงที่แตกต่างกัน ดังนั้นพอยเตอร์ว่างทั้งหมดจึงไม่สามารถแทนที่ด้วยnullptrได้^{[ 20 ]}

สำหรับทุกประเภทข้อมูลTยกเว้น ประเภท voidและฟังก์ชัน จะมีประเภท"อาร์เรย์ของNองค์ประกอบประเภทT"อยู่ อาร์เรย์คือชุดของค่าทั้งหมดที่มีประเภทเดียวกัน ซึ่งจัดเก็บอยู่ติดกันในหน่วยความจำ อาร์เรย์ขนาดNจะถูกกำหนดดัชนีด้วยจำนวนเต็มตั้งแต่0ถึง และรวมถึงN − 1ตัวอย่างสั้นๆ มีดังนี้:

int a [ 10 ]; // อาร์เรย์ที่มี 10 องค์ประกอบ แต่ละองค์ประกอบเป็นชนิด int

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

int aa [ 10 ][ 8 ]; // อาร์เรย์ที่มี 10 องค์ประกอบ แต่ละองค์ประกอบเป็นชนิด 'อาร์เรย์ขององค์ประกอบ int 8 ตัว'

ในภาษา C สตริงมักถูกจัดเก็บเป็นอาร์เรย์ของchar( char[]) แต่สิ่งนี้แตกต่างจากพอยเตอร์ไปยังchar( char *) char[]ไม่สามารถกำหนดค่าใหม่ได้ และคงอยู่ที่ตำแหน่งที่ถูกกำหนด ในขณะที่char *สามารถกำหนดค่าใหม่ได้ แต่ไม่สามารถแก้ไขได้

char s [] = "Hello, world!" ; char * p = s ; // s สลายตัวเป็น &s[0], p ชี้ไปยังอักขระตัวแรก

แม้ว่าฟังก์ชันจะรับค่าT[]เป็นพารามิเตอร์ แต่ฟังก์ชันนั้นจะสลายตัวเป็นT *ค่าที่ชี้ไปยังองค์ประกอบแรกของฟังก์ชันนั้น

void f ( int a []);// นี่เหมือนกับ: void f ( int * a );

^{การกำหนดดัชนี ของ}อาร์เรย์นั้นกำหนดขึ้นตามเลขคณิตของตัวชี้นั่นa[i]คือ เทียบเท่ากับ^[*(a + i) 21 ^]

ในภาษา C นั้น enum เป็นชนิดจำนวนเต็มที่มีค่าจำกัดเฉพาะชุดของค่าคงที่ที่มีชื่อ^{[ 22 ]}ไม่สามารถประกาศ enum ล่วงหน้าได้ นอกจากนี้ enum ยังสามารถกำหนดค่าโดยตรงได้ และมักใช้เพื่อswitchแจงนับกรณีต่างๆ หลายกรณี

#include <stddef.h>enum สถานะ{ OK = 200 , NOT_FOUND = 404 , SERVER_ERROR = 500 };const char * get_status_string ( enum Status status ) { switch ( status ) { case OK : return "สำเร็จ" ; case NOT_FOUND : return "ไม่พบ" ; case SERVER_ERROR : return "เกิดข้อผิดพลาดของเซิร์ฟเวอร์" ; default : unreachable (); } }

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

enum Color : char { RED = 1 , ORANGE , YELLOW , GREEN , BLUE , INDIGO , VIOLET };

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

enum Color color = YELLOW ; // YELLOW = 3 enum Month month = JUNE ; // JUNE = 6color = month ; // ตอนนี้สีคือ 6 (INDIGO) month = 999 ; // อาจไม่มีค่า 999 ใน enum Month แต่ก็ยังอนุญาต

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

struct Student { char name [ 50 ]; unsigned int id ; unsigned int semester ; float gpa ; };// การกำหนดค่าเริ่มต้นตามตำแหน่ง - ค่าจะตรงกับลำดับฟิลด์struct Student alice = { "Alice" , 123 , 2 , 3.8 }; // ตัวกำหนดค่าเริ่มต้นที่กำหนด (ตั้งแต่ C99) struct Student bob = { . name = "Bob" , . id = 246 , . semester = 1 , . gpa = 3.9 };

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

struct Properties { // ฟิลด์สามฟิลด์สามารถบรรจุได้อย่างกะทัดรัดในหนึ่งไบต์unsigned char visible : 1 ; // a ใช้พื้นที่ 1 บิตunsigned char color : 3 ; // b ใช้พื้นที่ 3 บิตunsigned char size : 4 ; // c ใช้พื้นที่ 4 บิต};

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

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

#include <stdio.h>// การส่งค่าแบบ pass by value void print_student ( struct Student s ) { printf ( "Name: %s, ID: %d, in semester %d, with GPA: %.2f \n " , s . name , s . id , s . semester , s . gpa ); }// การส่งผ่านด้วยพอยเตอร์void print_student ( struct Student * s ) { printf ( "ชื่อ: %s, รหัสประจำตัว: %d, ภาคการศึกษา %d, เกรดเฉลี่ย: %.2f \n " , s -> name , s -> id , s -> semester , s -> gpa ); }

โครงสร้างสามารถประกอบขึ้นจากโครงสร้างอื่นๆ ได้:

struct Date { int year ; int month ; int day ; };struct Birthday { char name [ 50 ]; struct Date dob ; };

โครงสร้างข้อมูลที่มีตัวชี้ไปยังโครงสร้างข้อมูลประเภทเดียวกัน มักใช้ในการสร้างโครงสร้างข้อมูลแบบเชื่อมโยง :

struct LinkedList { void * item ; // เก็บรายการปัจจุบันstruct LinkedList * next ; // เก็บรายการถัดไป หรือ NULL ถ้าไม่มีอะไรถัดไป};

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

// เก็บค่าจำนวนเต็มหรือค่าทศนิยมunion Number { int i ; float f ; } d ;d.i = 10 ; // ตอนนี้ d เก็บค่า 10 d.f = 3.14f ; // ตอน นี้ d เก็บค่า 3.14 ซึ่ง เขียนทับ ค่า10

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

ยูเนียน{ int i ; float f ; struct { unsigned int u ; double d ; } s ; } u ;

ขนาดโดยรวมของuคือขนาดของu.sซึ่งก็คือผลรวมของขนาดของu.s.uและu.s.dเนื่องจากsมีขนาดใหญ่กว่าทั้งiและfเมื่อกำหนดค่าให้กับu.iบางส่วนของu.fอาจยังคงอยู่หาก มีขนาด เล็ก u.iกว่าu.f

การอ่านข้อมูลจากสมาชิกสหภาพแรงงานไม่เหมือนกับการหล่อหลอม เพราะคุณค่าของสมาชิกไม่ได้ถูกแปลง แต่เป็นการอ่านข้อมูลเท่านั้น

ตัวชี้ฟังก์ชันช่วยให้สามารถอ้างอิงถึงฟังก์ชันที่มีรูปแบบเฉพาะได้ ตัวอย่างเช่น เพื่อเก็บที่อยู่ของฟังก์ชันมาตรฐานไว้absในตัวแปรmy_int_f:

int ( * my_int_f )( int ) = & abs ; // สามารถละเว้นตัวดำเนินการ & ได้ แต่จะทำให้ชัดเจนว่ามีการใช้ "ที่อยู่ของ" abs ที่นี่

ตัวชี้ฟังก์ชันจะถูกเรียกใช้โดยใช้ชื่อเช่นเดียวกับการเรียกใช้ฟังก์ชันทั่วไป

#include <stdio.h> #include <stdlib.h>int ( * my_abs )( int ) = & abs ; int x = -42 ; int abs_of_x = my_abs ( x ); printf ( "abs(%d) = %d \n " , x , abs_of_x );

ประเภทต่างๆ ที่กล่าวมาข้างต้นสามารถจำแนกเพิ่มเติมได้ด้วยตัวกำหนดคุณสมบัติประเภท (type qualifiers ) ทำให้ได้ประเภทที่มีคุณสมบัติ (qualified type ) ณ ปี 2014 และC11มาตรฐาน C มีตัวกำหนดคุณสมบัติประเภทอยู่สี่แบบ:

• const( C89 )
• volatile( C89 )
• restrict( ซี99 )
• _Atomic( C11 ) – ชื่อหลังมีชื่อส่วนตัวเพื่อหลีกเลี่ยงการขัดแย้งกับชื่อผู้ใช้^{[ 23 ]}atomic แต่ สามารถใช้ชื่อทั่วไป ได้หาก <stdatomic.h>มีการรวมส่วนหัวไว้ด้วย

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

เว็บไซต์ Wikibook C Programmingมีหน้าหนึ่งที่กล่าวถึงหัวข้อ: ตัวแปร

• ไวยากรณ์ C
• ตัวแปรที่ยังไม่ได้กำหนดค่าเริ่มต้น
• จำนวนเต็ม (วิทยาการคอมพิวเตอร์)
• การชดเชยของ