Apa itu size_t dalam C?

Saya bingung dengan size_tC. Saya tahu dikembalikan oleh sizeofoperator. Tapi apa sebenarnya itu? Apakah ini tipe data?

Katakanlah saya memiliki forloop:

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

Haruskah saya menggunakan int i;atau size_t i;?

Dari Wikipedia :

Menurut standar ISO C 1999 (C99), 1999 size_tadalah tipe integer yang tidak ditandai setidaknya 16 bit (lihat bagian 7.17 dan 7.18.3).

size_tadalah tipe data yang tidak ditandatangani yang didefinisikan oleh beberapa standar C / C ++, misalnya standar C99 ISO / IEC 9899, ​​yang didefinisikan dalam stddef.h. 1 Dapat diimpor lebih lanjut dengan memasukkan stdlib.hfile ini termasuk sub internal stddef.h.

Tipe ini digunakan untuk merepresentasikan ukuran suatu objek. Fungsi pustaka yang mengambil atau mengembalikan ukuran mengharapkannya bertipe atau memiliki tipe pengembalian size_t. Lebih lanjut, ukuran operator berbasis compiler yang paling sering digunakan harus dievaluasi dengan nilai konstan yang kompatibel dengannya size_t.

Implikasinya, size_tadalah jenis yang dijamin untuk menyimpan indeks array apa pun.

size_tadalah tipe yang tidak ditandatangani. Jadi, itu tidak dapat mewakili nilai negatif apa pun (<0). Anda menggunakannya saat menghitung sesuatu, dan yakin itu tidak negatif. Misalnya, strlen()mengembalikan a size_tkarena panjang string harus minimal 0.

Dalam contoh Anda, jika indeks loop Anda akan selalu lebih besar dari 0, mungkin masuk akal untuk digunakan size_t, atau tipe data yang tidak ditandatangani lainnya.

Ketika Anda menggunakan size_tobjek, Anda harus memastikan bahwa dalam semua konteks itu digunakan, termasuk aritmatika, Anda menginginkan nilai-nilai non-negatif. Sebagai contoh, katakanlah Anda memiliki:

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

dan Anda ingin menemukan perbedaan panjang str2dan str1. Anda tidak dapat melakukan:

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

Ini karena nilai yang ditetapkan untuk diffselalu akan menjadi angka positif, bahkan ketika s2 < s1, karena perhitungan dilakukan dengan tipe yang tidak ditandatangani. Dalam hal ini, tergantung pada apa use case Anda, Anda mungkin lebih baik menggunakan int(atau long long) untuk s1dan s2.

Ada beberapa fungsi dalam C / POSIX yang bisa / harus digunakan size_t, tetapi tidak karena alasan historis. Sebagai contoh, parameter kedua fgetsseharusnya idealnya size_t, tetapi adalah int.

size_t adalah tipe yang bisa menampung indeks array apa pun.

Bergantung pada implementasinya, dapat berupa:

unsigned char

unsigned short

unsigned int

unsigned long

unsigned long long

Inilah cara size_tdidefinisikan di stddef.hmesin saya:

typedef unsigned long size_t;

Jika Anda adalah tipe empiris ,

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

Output untuk Ubuntu 14.04 64-bit GCC 4.8:

typedef long unsigned int size_t;

Catatan yang stddef.hdisediakan oleh GCC dan tidak glibc src/gcc/ginclude/stddef.hdi bawah dalam GCC 4.2.

Penampilan C99 yang menarik

• mallocmengambil size_tsebagai argumen, sehingga menentukan ukuran maksimum yang mungkin dialokasikan.

  Dan karena itu juga dikembalikan oleh sizeof, saya pikir itu membatasi ukuran maksimum dari array apa pun.

  Lihat juga: Berapa ukuran maksimum array dalam C?

Halaman manual untuk types.h mengatakan:

size_t akan menjadi tipe integer yang tidak ditandatangani

Karena belum ada yang menyebutkannya, makna linguistik utama size_tadalah bahwa sizeofoperator mengembalikan nilai jenis itu. Demikian juga, signifikansi utama dari ptrdiff_tpengurangan satu pointer dari yang lain akan menghasilkan nilai dari jenis itu. Fungsi pustaka yang menerimanya melakukannya karena itu akan memungkinkan fungsi tersebut untuk bekerja dengan objek yang ukurannya melebihi UINT_MAX pada sistem di mana objek tersebut dapat ada, tanpa memaksa penelepon membuang kode yang melewati nilai yang lebih besar dari "unsigned int" pada sistem di mana tipe yang lebih besar akan cukup untuk semua objek yang mungkin.

Untuk size_tmengetahui mengapa perlu ada dan bagaimana kita sampai di sini:

Dalam istilah pragmatis, size_tdan ptrdiff_tdijamin selebar 64 bit pada implementasi 64-bit, lebar 32 bit pada implementasi 32-bit, dan seterusnya. Mereka tidak bisa memaksa tipe apa pun yang ada berarti bahwa, pada setiap kompiler, tanpa melanggar kode warisan.

A size_tatau ptrdiff_ttidak harus sama dengan intptr_tatau uintptr_t. Mereka berbeda pada arsitektur tertentu yang masih digunakan kapan size_tdan ptrdiff_tditambahkan ke Standar pada akhir 80-an, dan menjadi usang ketika C99 menambahkan banyak jenis baru tetapi belum hilang (seperti Windows 16-bit). X86 dalam mode terproteksi 16-bit memiliki memori tersegmentasi di mana susunan atau struktur terbesar yang mungkin hanya berukuran 65.536 byte, tetapi farpenunjuk harus lebar 32 bit, lebih lebar dari register. Pada mereka, intptr_takan menjadi lebar 32 bit tetapi size_tdanptrdiff_tbisa 16 bit lebar dan muat dalam register. Dan siapa yang tahu sistem operasi apa yang mungkin ditulis di masa depan? Secara teori, arsitektur i386 menawarkan model segmentasi 32-bit dengan pointer 48-bit yang tidak pernah digunakan oleh sistem operasi.

Jenis offset memori tidak mungkin longkarena terlalu banyak kode lama mengasumsikan bahwa longpersis 32 bit. Asumsi ini bahkan dibangun ke dalam UNIX dan Windows API. Sayangnya, banyak kode lawas lainnya juga berasumsi bahwa a longcukup lebar untuk menampung sebuah pointer, sebuah file offset, jumlah detik yang telah berlalu sejak tahun 1970, dan seterusnya. POSIX sekarang menyediakan cara terstandardisasi untuk memaksakan asumsi yang terakhir menjadi benar, bukan yang sebelumnya, tetapi tidak ada asumsi portabel untuk dibuat.

Itu tidak mungkin intkarena hanya segelintir kompiler di tahun 90-an yang membuat intlebar 64 bit. Kemudian mereka benar-benar aneh dengan menjaga longlebar 32 bit. Revisi Standar berikutnya menyatakan ilegal untuk intmenjadi lebih luas daripada long, tetapi intmasih lebar 32 bit pada kebanyakan sistem 64-bit.

Tidak mungkin long long int, yang bagaimanapun ditambahkan kemudian, karena itu dibuat setidaknya 64 bit lebar bahkan pada sistem 32-bit.

Jadi, diperlukan tipe baru. Bahkan jika tidak, semua tipe lainnya berarti sesuatu selain offset dalam array atau objek. Dan jika ada satu pelajaran dari kegagalan migrasi 32-ke-64-bit, itu harus spesifik tentang properti jenis apa yang perlu dimiliki, dan tidak menggunakan satu yang berarti berbeda dalam program yang berbeda.

size_tdan inttidak bisa dipertukarkan. Misalnya pada 64-bit Linux size_tberukuran 64-bit (yaitu sizeof(void*)) tetapi int32-bit.

Perhatikan juga bahwa size_ttidak ditandatangani. Jika Anda perlu versi yang ditandatangani maka ada ssize_tpada beberapa platform dan itu akan lebih relevan dengan contoh Anda.

Sebagai aturan umum, saya akan menyarankan menggunakan intuntuk sebagian besar kasus umum dan hanya menggunakan size_t/ ssize_tketika ada kebutuhan khusus untuk itu (dengan mmap()misalnya).

Secara umum, jika Anda mulai dari 0 dan naik, selalu gunakan tipe yang tidak ditandatangani untuk menghindari overflow yang membawa Anda ke situasi nilai negatif. Ini sangat penting, karena jika batas array Anda kurang dari maks dari loop Anda, tetapi max loop Anda lebih besar dari max tipe Anda, Anda akan membungkus negatif dan Anda mungkin mengalami kesalahan segmentasi (SIGSEGV ). Jadi, secara umum, jangan pernah gunakan int untuk loop mulai dari 0 dan naik. Gunakan tanda tangan.

size_t adalah tipe data integer yang tidak ditandatangani. Pada sistem yang menggunakan Perpustakaan C GNU, ini akan menjadi unsigned int atau unsigned long int. size_t umumnya digunakan untuk pengindeksan array dan penghitungan loop.

size_t atau tipe yang tidak ditandatangani mungkin terlihat digunakan sebagai variabel loop karena variabel loop biasanya lebih besar dari atau sama dengan 0.

Ketika kita menggunakan objek size_t , kita harus memastikan bahwa dalam semua konteks yang digunakan, termasuk aritmatika, kita hanya menginginkan nilai-nilai non-negatif. Misalnya, program berikut pasti akan memberikan hasil yang tidak terduga:

// 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_tadalah tipe data integer yang tidak ditandatangani yang hanya dapat menetapkan 0 dan lebih besar dari 0 nilai integer. Ini mengukur byte dari ukuran objek apa pun dan dikembalikan oleh sizeofoperator. constadalah representasi sintaks size_t, tetapi tanpa constAnda dapat menjalankan program.

const size_t number;

size_tsecara teratur digunakan untuk pengindeksan array dan penghitungan loop. Jika kompiler 32-bititu akan bekerja unsigned int. Jika kompiler 64-bititu akan berfungsi unsigned long long intjuga. Ada untuk ukuran maksimum size_ttergantung pada jenis kompiler.

size_tsudah menentukan pada <stdio.h>file header, tetapi juga dapat menentukan oleh <stddef.h>, <stdlib.h>, <string.h>, <time.h>, <wchar.h>header.

• Contoh (dengan 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);
}

Output -: size = 800

• Contoh (tanpa 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);
}

Output -: size = 800

Dari pemahaman saya, size_tadalah unsignedbilangan bulat yang ukuran bitnya cukup besar untuk menampung pointer dari arsitektur asli.

Begitu:

sizeof(size_t) >= sizeof(void*)