ในภาษาการเขียนโปรแกรม 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 constants are known at compile time, and are often a safer means to define integral constants than macros. An enum's underlying size is usually int, but since C23 an enum's underlying size can be directly specified to be any integral type.

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

Because enums are not type-safe, they can be assigned a value of another enum. Enums also need not be assigned values necessarily within the range of defined values.

enumColorcolor=YELLOW;// YELLOW = 3enumMonthmonth=JUNE;// JUNE = 6color=month;// color is now 6 (INDIGO)month=999;// there may not be a value of 999 in enum Month, but still allowed

Structures (structs) aggregate the storage of multiple data items, of potentially differing data types, into one contiguous memory block referenced by a single variable. Members may possibly be padded for memory alignment, and thus it is often recommended to order fields from largest to smallest size for efficient memory usage.

structStudent{charname[50];unsignedintid;unsignedintsemester;floatgpa;};// Positional initialization - values matches field orderstructStudentalice={"Alice",123,2,3.8};// Designated initializer (since C99)structStudentbob={.name="Bob",.id=246,.semester=1,.gpa=3.9};

Structs may also use bit fields to allow fields to share the same storage units, but layouts are implementation-defined.

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
• ตัวแปรที่ยังไม่ได้กำหนดค่าเริ่มต้น
• จำนวนเต็ม (วิทยาการคอมพิวเตอร์)
• การชดเชยของ