เมื่อใดที่จะใช้ std :: size_t?

ฉันแค่สงสัยว่าฉันควรใช้std::size_tกับลูปและสิ่งของแทนได้intอย่างไร ตัวอย่างเช่น

#include <cstdint>

int main()
{
    for (std::size_t i = 0; i < 10; ++i) {
        // std::size_t OK here? Or should I use, say, unsigned int instead?
    }
}

โดยทั่วไปแล้ววิธีปฏิบัติที่ดีที่สุดเกี่ยวกับเวลาที่ใช้std::size_tคืออะไร

กฎที่ดีของหัวแม่มือคือสำหรับสิ่งที่คุณจะต้องเปรียบเทียบในสภาพที่ห่วงกับสิ่งที่เป็นธรรมชาติstd::size_tของตัวเอง

std::size_tเป็นประเภทของsizeofการแสดงออกใด ๆและเป็นที่รับประกันว่าจะสามารถแสดงขนาดสูงสุดของวัตถุใด ๆ (รวมถึงอาร์เรย์ใด ๆ ) ใน C ++ โดยการขยายมันยังรับประกันว่าจะมีขนาดใหญ่พอสำหรับดัชนีอาเรย์ใด ๆ ดังนั้นมันจึงเป็นชนิดที่เป็นธรรมชาติสำหรับการวนซ้ำโดยดัชนีเหนืออาร์เรย์

หากคุณเพิ่งนับจำนวนมากมันอาจดูเป็นธรรมชาติมากกว่าที่จะใช้ชนิดของตัวแปรที่เก็บหมายเลขนั้นintหรือunsigned int( หรือถ้ามีขนาดใหญ่พอ) เนื่องจากขนาดเหล่านี้ควรเป็นขนาดธรรมชาติสำหรับเครื่อง

size_tเป็นประเภทผลลัพธ์ของsizeofโอเปอเรเตอร์

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

นอกจากนี้การใช้size_tเพื่อแสดงขนาดเป็นไบต์ช่วยให้สามารถพกพาโค้ดได้

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

for (size_t i = 0, max = strlen (str); i < max; i++)
    doSomethingWith (str[i]);

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

แต่ระวังสิ่งต่าง ๆ เช่น:

for (size_t i = strlen (str) - 1; i >= 0; i--)

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

for (size_t i = strlen (str); i-- > 0; )

โดยขยับพร่องลงในโพสต์ตรวจสอบผลข้างเคียงของสภาพความต่อเนื่องนี้จะตรวจสอบความต่อเนื่องกับค่าก่อนที่จะลดลง แต่ยังคงใช้ค่า decremented ภายในวง (ซึ่งเป็นเหตุผลที่วิ่งออกจากห่วงlen .. 1มากกว่าlen-1 .. 0)

โดยคำจำกัดความsize_tเป็นผลมาจากsizeofผู้ประกอบการ size_tถูกสร้างเพื่ออ้างถึงขนาด

จำนวนครั้งที่คุณทำบางสิ่งบางอย่าง (10 ในตัวอย่างของคุณ) ไม่เกี่ยวกับขนาดเพื่อให้การใช้งานว่าทำไมsize_t? intหรือunsigned intควรจะโอเค

แน่นอนว่ามันเกี่ยวข้องกับสิ่งที่คุณทำiในวง หากคุณส่งผ่านไปยังฟังก์ชั่นที่รับunsigned intเช่นเลือกunsigned intตัวอย่างเช่นเลือก

ไม่ว่าในกรณีใดฉันแนะนำให้หลีกเลี่ยงการแปลงประเภทโดยนัย ทำให้การแปลงประเภททั้งหมดชัดเจน

size_tเป็นวิธีที่อ่านได้ง่ายมากในการระบุขนาดของรายการ - ความยาวของสตริงจำนวนไบต์ที่ตัวชี้ใช้เป็นต้นนอกจากนี้ยังสามารถพกพาข้ามแพลตฟอร์มได้ - คุณจะพบว่า 64 บิตและ 32 บิตทำงานได้ดีกับระบบของระบบและsize_t- สิ่งที่unsigned intอาจไม่ทำ (เช่นเมื่อใดควรใช้unsigned long

คำตอบสั้น ๆ :

แทบจะไม่เคย

คำตอบยาว:

เมื่อใดก็ตามที่คุณต้องมีเวกเตอร์ของถ่านที่ใหญ่กว่านั้น 2gb ในระบบ 32 บิต ในทุกกรณีการใช้งานการใช้ประเภทที่เซ็นชื่อนั้นปลอดภัยกว่าการใช้ประเภทที่ไม่ได้ลงนาม

ตัวอย่าง:

std::vector<A> data;
[...]
// calculate the index that should be used;
size_t i = calc_index(param1, param2);
// doing calculations close to the underflow of an integer is already dangerous

// do some bounds checking
if( i - 1 < 0 ) {
    // always false, because 0-1 on unsigned creates an underflow
    return LEFT_BORDER;
} else if( i >= data.size() - 1 ) {
    // if i already had an underflow, this becomes true
    return RIGHT_BORDER;
}

// now you have a bug that is very hard to track, because you never 
// get an exception or anything anymore, to detect that you actually 
// return the false border case.

return calc_something(data[i-1], data[i], data[i+1]);

ลงนามเทียบเท่าsize_tเป็นไม่ได้ptrdiff_t intแต่intในกรณีส่วนใหญ่ยังใช้งานได้ดีกว่า size_t ptrdiff_tคือlongในระบบ 32 และ 64 บิต

ซึ่งหมายความว่าคุณต้องแปลงเป็นและจาก size_t ทุกครั้งที่คุณโต้ตอบกับ std :: container ซึ่งไม่สวยงามมาก แต่ในการประชุมที่กำลังจะเกิดขึ้นผู้เขียน c ++ กล่าวว่าการออกแบบ std :: vector ด้วยขนาดที่ไม่ได้ลงนามนั้นเป็นความผิดพลาด

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

calc_something(data[size_t(i-1)], data[size_t(i)], data[size_t(i+1)]);

ถ้าเพียงแค่ต้องการย้ำคอลเลคชั่นโดยไม่มีการ จำกัด ขอบเขตให้ใช้ช่วงสำหรับ:

for(const auto& d : data) {
    [...]
}

ต่อไปนี้เป็นคำบางคำจาก Bjarne Stroustrup (ผู้เขียน C ++) ที่เป็นเจ้าของภาษา

สำหรับบางคนข้อผิดพลาดในการออกแบบที่ลงชื่อ / ไม่ได้ลงชื่อใน STL นั้นมีเหตุผลเพียงพอที่จะไม่ใช้ std :: vector แต่เป็นการใช้งานของตัวเองแทน

ใช้ std :: size_t สำหรับการทำดัชนี / นับอาร์เรย์ C-style

สำหรับคอนเทนเนอร์ STL คุณจะมี (ตัวอย่าง) vector<int>::size_typeซึ่งควรใช้สำหรับการทำดัชนีและการนับองค์ประกอบเวกเตอร์

ในทางปฏิบัติพวกเขามักจะเป็นทั้ง ints ที่ไม่ได้ลงชื่อ แต่ไม่รับประกันโดยเฉพาะเมื่อใช้ตัวจัดสรรแบบกำหนดเอง

ในไม่ช้าคอมพิวเตอร์ส่วนใหญ่จะเป็นสถาปัตยกรรม 64- บิตที่มีระบบปฏิบัติการ 64 บิต: เป็นโปรแกรมที่ทำงานบนภาชนะที่มีองค์ประกอบหลายพันล้านรายการ จากนั้นคุณต้องใช้size_tแทนintดัชนีลูปมิฉะนั้นดัชนีของคุณจะล้อมรอบที่องค์ประกอบ 2 ^ 32: th ทั้งบนระบบ 32- และ 64- บิต

เตรียมพร้อมสำหรับอนาคต!

เมื่อใช้ size_t ให้ระวังด้วยนิพจน์ต่อไปนี้

size_t i = containner.find("mytoken");
size_t x = 99;
if (i-x>-1 && i+x < containner.size()) {
    cout << containner[i-x] << " " << containner[i+x] << endl;
}

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

if ((int)(i-x) > -1 or (i-x) >= 0)

ทั้งสองวิธีควรทำงาน นี่คือการทดสอบการทำงานของฉัน

size_t i = 5;
cerr << "i-7=" << i-7 << " (int)(i-7)=" << (int)(i-7) << endl;

ผลลัพธ์: i-7 = 18446744073709551614 (int) (i-7) = - 2

ฉันต้องการความคิดเห็นของผู้อื่น

size_t ถูกส่งคืนโดยไลบรารีต่าง ๆ เพื่อระบุว่าขนาดของคอนเทนเนอร์นั้นไม่ใช่ศูนย์ คุณใช้มันเมื่อคุณกลับมาอีกครั้ง: 0

อย่างไรก็ตามในตัวอย่างของคุณด้านบนวนลูปใน size_t เป็นข้อผิดพลาดที่อาจเกิดขึ้น พิจารณาสิ่งต่อไปนี้:

for (size_t i = thing.size(); i >= 0; --i) {
  // this will never terminate because size_t is a typedef for
  // unsigned int which can not be negative by definition
  // therefore i will always be >= 0
  printf("the never ending story. la la la la");
}

การใช้จำนวนเต็มที่ไม่ได้ลงนามมีศักยภาพในการสร้างปัญหาที่ละเอียดเหล่านี้ ดังนั้นฉันจึงชอบใช้ size_t เฉพาะเมื่อฉันโต้ตอบกับคอนเทนเนอร์ / ประเภทที่ต้องการ

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

ส่วนใหญ่จะใช้ในการทำดัชนีอาร์เรย์ / ลูป / ที่อยู่ทางคณิตศาสตร์และอื่น ๆ ฟังก์ชั่นที่เหมือนmemset()กันยอมรับsize_tเฉพาะในทางทฤษฎีเพราะคุณอาจมีหน่วยความจำขนาดบล็อก2^32-1(บนแพลตฟอร์ม 32 บิต)

สำหรับลูปที่เรียบง่ายเช่นนั้นไม่รบกวนและใช้แค่ int

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

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

หลีกเลี่ยงสิ่งนั้นโดยใช้ประเภทข้อมูลที่ลงชื่อ / ไม่ได้ลงนามหรือพิมพ์ตัวอักษรเพื่อแฮ็คที่รวดเร็ว

size_t ไม่ได้ลงนาม int ดังนั้นเมื่อใดก็ตามที่คุณต้องการ int ที่ไม่ได้ลงชื่อคุณสามารถใช้มันได้

ฉันใช้มันเมื่อฉันต้องการระบุขนาดของอาเรย์, ตัวนับและ ...

void * operator new (size_t size); is a good use of it.