size_t ใน C คืออะไร

ฉันกำลังสับสนกับsize_tใน C. ฉันรู้ว่ามันจะถูกส่งกลับโดยsizeofผู้ประกอบการ แต่มันคืออะไรกันแน่? เป็นประเภทข้อมูลหรือไม่

สมมติว่าฉันมีforลูป:

for(i = 0; i < some_size; i++)

ฉันควรใช้int i;หรือsize_t i;?

จาก Wikipedia :

ตามมาตรฐาน ISO C 1999 (C99) size_tเป็นประเภทจำนวนเต็มที่ไม่ได้ลงชื่ออย่างน้อย 16 บิต (ดูหัวข้อ 7.17 และ 7.18.3)

size_tเป็นชนิดข้อมูลที่ไม่ได้ลงชื่อกำหนดโดยหลาย C / C ++ มาตรฐานเช่น C99 มาตรฐาน ISO / IEC 9899 stddef.hมาตรฐานที่กำหนดไว้ใน 1ก็สามารถที่จะนำเข้าต่อไปโดยรวมของ เป็นไฟล์นี้ภายในย่อยรวมถึงstdlib.hstddef.h

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

ในฐานะนัยหมายsize_tถึงชนิดที่รับประกันว่าจะเก็บดัชนีอาร์เรย์

size_tเป็นประเภทที่ไม่ได้ลงนาม ดังนั้นจึงไม่สามารถแสดงค่าลบใด ๆ (<0) คุณใช้มันเมื่อคุณกำลังนับบางสิ่งและแน่ใจว่ามันจะไม่เป็นลบ ตัวอย่างเช่นstrlen()ส่งกลับค่า a size_tเนื่องจากความยาวของสตริงต้องมีอย่างน้อย 0

ในตัวอย่างของคุณถ้าดัชนีลูปของคุณจะมากกว่า 0 เสมอมันอาจสมเหตุสมผลที่จะใช้size_tหรือประเภทข้อมูลที่ไม่ได้ลงนามอื่น ๆ

เมื่อคุณใช้size_tวัตถุคุณต้องตรวจสอบให้แน่ใจว่าในบริบททั้งหมดที่ใช้รวมถึงคณิตศาสตร์คุณต้องการค่าที่ไม่เป็นลบ ตัวอย่างเช่นสมมติว่าคุณมี:

size_t s1 = strlen(str1);
size_t s2 = strlen(str2);

และคุณต้องการค้นหาความแตกต่างของความยาวของและstr2 str1คุณไม่สามารถทำ:

int diff = s2 - s1; /* bad */

นี่เป็นเพราะค่าที่กำหนดให้diffจะเป็นจำนวนบวกเสมอแม้ว่าจะs2 < s1คำนวณด้วยชนิดที่ไม่ได้ลงนามก็ตาม ในกรณีนี้ขึ้นอยู่กับสิ่งที่กรณีการใช้งานของคุณคือคุณอาจจะดีกว่าการใช้int(หรือlong long) สำหรับและs1s2

มีฟังก์ชั่นบางอย่างใน C / POSIX ที่สามารถ / ควรใช้size_tแต่ไม่ใช่เพราะเหตุผลทางประวัติศาสตร์ ยกตัวอย่างเช่นพารามิเตอร์ตัวที่สองที่จะfgetsควรจะต้องแต่size_tint

size_t เป็นประเภทที่สามารถเก็บดัชนีอาร์เรย์ใด ๆ

ขึ้นอยู่กับการนำไปใช้งานสามารถเป็นหนึ่งใน:

unsigned char

unsigned short

unsigned int

unsigned long

unsigned long long

นี่คือวิธีที่size_tกำหนดไว้ในstddef.hเครื่องของฉัน:

typedef unsigned long size_t;

ถ้าคุณเป็นประเภทเชิงประจักษ์ ,

echo | gcc -E -xc -include 'stddef.h' - | grep size_t

เอาท์พุตสำหรับ Ubuntu 14.04 GCC 64 บิต 4.8:

typedef long unsigned int size_t;

โปรดทราบว่าstddef.hมีให้โดย GCC และไม่ใช่ glibc ภายใต้src/gcc/ginclude/stddef.hใน GCC 4.2

รูปลักษณ์ C99 ที่น่าสนใจ

• mallocใช้size_tเป็นอาร์กิวเมนต์จึงกำหนดขนาดสูงสุดที่อาจถูกจัดสรร

  และเนื่องจากมันถูกส่งคืนโดยsizeofฉันคิดว่ามัน จำกัด ขนาดสูงสุดของอาเรย์ใด ๆ

  ดูเพิ่มเติมที่: ขนาดสูงสุดของอาร์เรย์ใน C คืออะไร?

manpage สำหรับtypes.hพูดว่า:

size_t จะเป็นประเภทจำนวนเต็มที่ไม่ได้ลงนาม

เนื่องจากยังไม่มีใครพูดถึงมันความสำคัญทางภาษาหลักของsize_tคือsizeofผู้ดำเนินการคืนค่าประเภทนั้น ในทำนองเดียวกันความสำคัญหลักของptrdiff_tคือการลบหนึ่งตัวชี้จากที่อื่นจะให้คุณค่าของประเภทนั้น ฟังก์ชั่นห้องสมุดที่ยอมรับมันทำเช่นนั้นเพราะมันจะช่วยให้ฟังก์ชั่นดังกล่าวสามารถทำงานกับวัตถุที่มีขนาดเกิน UINT_MAX บนระบบที่วัตถุดังกล่าวอาจมีอยู่ได้โดยไม่บังคับให้ผู้โทรต้องเสียรหัสผ่านค่าที่มากกว่า "unsigned int" บนระบบ จะเพียงพอสำหรับวัตถุที่เป็นไปได้ทั้งหมด

จะเข้าไปทำไม size_tต้องมีอยู่และวิธีที่เรามาที่นี่:

ในแง่ปฏิบัติsize_tและptrdiff_tรับประกันว่าจะมีความกว้าง 64 บิตในการใช้งานแบบ 64 บิต, 32 บิตในการใช้งานแบบ 32 บิตและอื่น ๆ พวกเขาไม่สามารถบังคับประเภทที่มีอยู่ให้หมายความว่าในคอมไพเลอร์ทุกตัวโดยไม่ทำลายรหัสดั้งเดิม

size_tหรือptrdiff_tไม่จำเป็นต้องเหมือนกับหรือintptr_t uintptr_tพวกเขาแตกต่างกันไปตามสถาปัตยกรรมบางประเภทที่ยังคงใช้งานอยู่เมื่อsize_tและptrdiff_tถูกเพิ่มลงในมาตรฐานในช่วงปลายยุค 80 และล้าสมัยเมื่อ C99 ได้เพิ่มประเภทใหม่จำนวนมาก แต่ยังไม่ได้หายไป (เช่น Windows 16 บิต) x86 ในโหมดการป้องกันแบบ 16 บิตมีหน่วยความจำแบบแบ่งส่วนซึ่งอาร์เรย์หรือโครงสร้างที่ใหญ่ที่สุดที่เป็นไปได้อาจมีขนาดเพียง 65,536 ไบต์ แต่farตัวชี้จำเป็นต้องมีความกว้าง 32 บิตซึ่งกว้างกว่ารีจิสเตอร์ ในนั้นintptr_tจะได้รับ 32 บิตกว้าง แต่size_tและptrdiff_tอาจมีขนาด 16 บิตและพอดีกับการลงทะเบียน และใครจะรู้ว่าระบบปฏิบัติการแบบไหนที่จะถูกเขียนในอนาคต ในทางทฤษฎีแล้วสถาปัตยกรรม i386 เสนอรูปแบบการแบ่งเซ็กเมนต์ 32 บิตพร้อมพอยน์เตอร์ 48 บิตที่ไม่เคยใช้ระบบปฏิบัติการมาก่อน

ประเภทของออฟเซ็ตหน่วยความจำอาจไม่เป็นlongเพราะรหัสดั้งเดิมมากเกินไปถือว่าlongมีความกว้าง 32 บิต สมมติฐานนี้ถูกสร้างขึ้นใน UNIX และ Windows APIs น่าเสียดายที่รหัสมรดกอื่น ๆ จำนวนมากยังสันนิษฐานว่า a longนั้นกว้างพอที่จะถือพอยน์เตอร์ออฟเซ็ตไฟล์จำนวนวินาทีที่ผ่านไปตั้งแต่ปี 1970 เป็นต้นไป ตอนนี้ POSIX จัดเตรียมวิธีที่เป็นมาตรฐานในการบังคับให้การสันนิษฐานหลังเป็นจริงแทนที่จะเป็นแบบดั้งเดิม แต่ก็ไม่ใช่การสันนิษฐานแบบพกพา

อาจเป็นintเพราะคอมไพเลอร์เพียงเล็กน้อยเท่านั้นในยุค 90 ที่มีintความกว้าง 64 บิต จากนั้นพวกเขาก็ประหลาดจริง ๆ ด้วยการรักษาlongความกว้าง 32 บิต การแก้ไขมาตรฐานครั้งต่อไปประกาศว่าเป็นการผิดกฎหมายintที่จะกว้างกว่าlongแต่intยังคงกว้าง 32 บิตในระบบ 64 บิตส่วนใหญ่

ไม่สามารถทำได้long long intซึ่งเพิ่มเข้ามาในภายหลังเนื่องจากถูกสร้างให้มีความกว้างอย่างน้อย 64 บิตแม้ในระบบ 32 บิต

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

size_tและintไม่สามารถใช้แทนกันได้ ตัวอย่างเช่นบน 64-bit Linux size_tมีขนาด 64 บิต (เช่นsizeof(void*)) แต่intเป็น 32- บิต

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

ตามกฎทั่วไปฉันขอแนะนำให้ใช้intสำหรับกรณีทั่วไปส่วนใหญ่และใช้size_t/ ssize_tเมื่อมีความต้องการเฉพาะเท่านั้น ( mmap()ตัวอย่างเช่น)

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

size_t เป็นชนิดข้อมูลจำนวนเต็มที่ไม่ได้ลงนาม บนระบบที่ใช้ไลบรารี GNU C สิ่งนี้จะเป็น int ที่ไม่ได้ลงนามหรือ int ที่ไม่ได้ลงนามที่มีความยาว size_t ใช้กันทั่วไปสำหรับการจัดทำดัชนีอาร์เรย์และการนับลูป

size_tหรือประเภทที่ไม่ได้ลงนามใด ๆ อาจถูกใช้เป็นตัวแปรลูปเนื่องจากตัวแปรลูปมักจะมากกว่าหรือเท่ากับ 0

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

// C program to demonstrate that size_t or
// any unsigned int type should be used 
// carefully when used in a loop

#include<stdio.h>
int main()
{
const size_t N = 10;
int a[N];

// This is fine
for (size_t n = 0; n < N; ++n)
a[n] = n;

// But reverse cycles are tricky for unsigned 
// types as can lead to infinite loop
for (size_t n = N-1; n >= 0; --n)
printf("%d ", a[n]);
}

Output
Infinite loop and then segmentation fault

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

const size_t number;

size_tใช้เป็นประจำสำหรับการทำดัชนีอาเรย์และการนับลูป ถ้าคอมไพเลอร์คือมันจะทำงานบน32-bit unsigned intหากคอมไพเลอร์64-bitมันจะทำงานunsigned long long intด้วย มีขนาดสูงสุดsize_tขึ้นอยู่กับประเภทคอมไพเลอร์

size_tแล้วกำหนดใน<stdio.h>ไฟล์ส่วนหัว แต่มันยังสามารถกำหนดโดย <stddef.h>, <stdlib.h>, <string.h>, <time.h>, <wchar.h>ส่วนหัว

• ตัวอย่าง (พร้อมconst)

#include <stdio.h>

int main()
{
    const size_t value = 200;
    size_t i;
    int arr[value];

    for (i = 0 ; i < value ; ++i)
    {
        arr[i] = i;
    }

    size_t size = sizeof(arr);
    printf("size = %zu\n", size);
}

เอาท์พุท -: size = 800

• ตัวอย่าง (ไม่รวมconst)

#include <stdio.h>

int main()
{
    size_t value = 200;
    size_t i;
    int arr[value];

    for (i = 0 ; i < value ; ++i)
    {
        arr[i] = i;
    }

    size_t size = sizeof(arr);
    printf("size = %zu\n", size);
}

เอาท์พุท -: size = 800

จากความเข้าใจของฉันsize_tเป็นunsignedจำนวนเต็มที่มีขนาดบิตใหญ่พอที่จะถือตัวชี้ของสถาปัตยกรรมพื้นเมือง

ดังนั้น:

sizeof(size_t) >= sizeof(void*)