ฉันควรใส่ส่วนหัวใดสำหรับ "size_t"

ตามที่cppreference.com size_tกำหนดไว้ในหลายส่วนหัว ได้แก่

<cstddef>
<cstdio>
<cstring>
<ctime>

และตั้งแต่ C ++ 11 ก็เช่นกัน

<cstdlib>
<cwchar> 

ก่อนอื่นฉันสงสัยว่าทำไมถึงเป็นเช่นนี้ สิ่งนี้ไม่ขัดกับหลักการDRYหรือไม่? อย่างไรก็ตามคำถามของฉันคือ:

ซึ่งหนึ่งในหัวข้างต้นที่ผมควรจะรวมถึงการใช้งานsize_t? มันสำคัญหรือไม่?

สมมติว่าฉันต้องการลดฟังก์ชั่นและประเภทที่ฉันกำลังนำเข้าฉันจะไปด้วยcstddefเพราะมันไม่ได้ประกาศฟังก์ชันใด ๆ และประกาศเพียง 6 ประเภทเท่านั้น ส่วนอื่น ๆ มุ่งเน้นไปที่โดเมนเฉพาะ (สตริงเวลา IO) ที่อาจไม่สำคัญสำหรับคุณ

โปรดทราบว่าcstddefรับประกันเฉพาะการกำหนดstd::size_tนั่นคือการกำหนดsize_tในเนมสเปซstdแม้ว่าอาจระบุชื่อนี้ในเนมสเปซส่วนกลางด้วย (มีประสิทธิภาพธรรมดาsize_t)

ในทางตรงกันข้ามstddef.h(ซึ่งเป็นส่วนหัวที่มีอยู่ใน C) รับประกันที่จะกำหนดsize_tใน namespace ทั่วโลกและอาจstd::size_tยังมี

ในความเป็นจริงบทสรุป (รวมอยู่ในมาตรฐาน C ++) ของส่วนหัวหลายส่วนsize_tโดยเฉพาะรวมถึงส่วนหัวเพิ่มเติมกำหนดประเภทsize_t(ตามมาตรฐาน C เนื่องจาก<cX>ส่วนหัวเป็นเพียง<X.h>ส่วนหัวISO C ที่มีการเปลี่ยนแปลงที่สังเกตเห็นซึ่งsize_tไม่ได้ระบุการลบออก)

อย่างไรก็ตามมาตรฐาน C ++ หมายถึง<cstddef>คำจำกัดความของstd::size_t

• ใน18.2 ประเภท ,
• ใน5.3.3 Sizeof ,
• ใน3.7.4.2 ฟังก์ชัน Deallocation (ซึ่งอ้างถึง 18.2) และ
• ใน3.7.4.1 ฟังก์ชันการจัดสรร (หมายถึง 18.2)

ดังนั้นและเนื่องจากการ<cstddef>แนะนำเฉพาะประเภทและไม่มีฟังก์ชันใด ๆ ฉันจึงใช้ส่วนหัวนี้เพื่อให้std::size_tพร้อมใช้งาน

สังเกตบางสิ่ง:

1. ประเภทของstd::size_tสามารถหาได้โดยใช้decltypeโดยไม่รวมส่วนหัว

   หากคุณกำลังวางแผนที่จะแนะนำ typedef ในรหัสของคุณอยู่แล้ว (เช่นเพราะคุณเขียนภาชนะและต้องการที่จะให้size_typetypedef) คุณสามารถใช้ทั่วโลกsizeof, sizeof...หรือalignofผู้ประกอบการเพื่อกำหนดประเภทของคุณโดยไม่รวมถึงส่วนหัวใด ๆ ที่ทุกคนตั้งแต่ผู้ประกอบการ theose กลับstd::size_tต่อ ความคมชัดมาตรฐานและคุณสามารถใช้decltypeกับ:

   using size_type = decltype(alignof(char));
   

2. std::size_tไม่สามารถมองเห็นได้ทั่วโลกแม้ว่าฟังก์ชันที่มีstd::size_tอาร์กิวเมนต์จะอยู่

   ฟังก์ชันการจัดสรรและการยกเลิกการจัดสรรส่วนกลางที่ประกาศโดยปริยาย

   void* operator new(std::size_t);
   void* operator new[](std::size_t);
   void operator delete(void*);
   void operator delete[](void*);
   

   ไม่แนะนำsize_t, stdหรือstd::size_tและ

   อ้างถึงstdหรือstd::size_tมีรูปแบบไม่ถูกต้องเว้นแต่จะมีการประกาศชื่อโดยรวมส่วนหัวที่เหมาะสม

3. ผู้ใช้ไม่สามารถกำหนดนิยามใหม่ได้std::size_tแม้ว่าจะเป็นไปได้ที่จะมี typedef หลายตัวที่อ้างถึงประเภทเดียวกันในเนมสเปซเดียวกัน

   แม้ว่าการเกิดขึ้นของคำจำกัดความsize_tภายในหลายคำstdจะถูกต้องสมบูรณ์ตาม7.1.3 / 3แต่ไม่อนุญาตให้เพิ่มการประกาศใด ๆnamespace stdตาม17.6.4.2.1 / 1 :

   ลักษณะการทำงานของโปรแกรม C ++ ไม่ได้กำหนดไว้หากเพิ่มการประกาศหรือคำจำกัดความให้กับ namespace std หรือใน namespace ภายใน namespace std เว้นแต่จะระบุไว้เป็นอย่างอื่น

   การเพิ่ม typedef ที่เหมาะสมสำหรับsize_tเนมสเปซจะไม่ละเมิด7.1.3แต่เป็นการละเมิด17.6.4.2.1และนำไปสู่พฤติกรรมที่ไม่ได้กำหนด

   _{คำชี้แจง: พยายามอย่าตีความ7.1.3ผิดพลาดและอย่าเพิ่มการประกาศหรือคำจำกัดความลงในstd(ยกเว้นกรณีเฉพาะเทมเพลตบางกรณีที่ typedef ไม่ใช่ความเชี่ยวชาญพิเศษของเทมเพลต) การขยายไฟล์namespace std}

ไฟล์ส่วนหัวของไลบรารีมาตรฐานทั้งหมดมีความหมายเดียวกัน ไม่สำคัญว่าคุณจะใส่รหัสใดในรหัสของคุณเอง ในคอมพิวเตอร์ของฉันฉันมีคำประกาศต่อไปนี้ใน_stddef.h. ไฟล์นี้รวมอยู่ในทุกไฟล์ที่คุณระบุไว้

/*
   Define the size_t type in the std namespace if in C++ or globally if in C.
   If we're in C++, make the _SIZE_T macro expand to std::size_t
*/

#if !defined(_SIZE_T) && !defined(_SIZE_T_DEFINED)
#  define _SIZE_T_DEFINED
#if defined(_WIN64)
   typedef unsigned __int64 size_t;
#else
   typedef unsigned int size_t;
#endif
#  if defined(__cplusplus)
#    define _SIZE_T std::size_t
#  else
#    define _SIZE_T size_t
#  endif
#endif

คุณสามารถทำได้โดยไม่ต้องมีส่วนหัว:

using size_t = decltype(sizeof(int));
using size_t = decltype(sizeof 1); //  The shortest is my favourite.
using size_t = decltype(sizeof "anything");

เนื่องจากมาตรฐาน C ++ ต้องการ:

ผลมาจากsizeofและเป็นค่าคงที่ของประเภทsizeof... std::size_t[หมายเหตุ: std::size_tกำหนดไว้ในส่วนหัวมาตรฐาน<cstddef>(18.2) - หมายเหตุ]

กล่าวอีกนัยหนึ่งมาตรฐานต้องการ:

static_assert(std::is_same<decltype(sizeof(int)), std::size_t>::value,
              "This never fails.");

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

นี้เป็นเพราะ:

• §7.1.3.1 typedef-nameไม่แนะนำประเภทใหม่แบบที่การประกาศคลาส (9.1) หรือการประกาศ enum ทำ

• §7.1.3.3ในขอบเขตที่ไม่ใช่คลาสที่typedefกำหนดตัวระบุสามารถใช้เพื่อกำหนดชื่อของประเภทใด ๆ ที่ประกาศในขอบเขตนั้นใหม่เพื่ออ้างถึงประเภทที่อ้างถึงอยู่แล้ว

สำหรับผู้คลางแคลงที่บอกว่านี่เป็นการเพิ่มประเภทใหม่ในเนมสเปซstdและการกระทำดังกล่าวเป็นสิ่งต้องห้ามอย่างชัดเจนโดยมาตรฐานและนี่คือ UB และนั่นคือทั้งหมดที่อยู่ในนั้น ฉันต้องบอกว่าทัศนคตินี้เป็นการเพิกเฉยและปฏิเสธความเข้าใจที่ลึกซึ้งยิ่งขึ้นเกี่ยวกับปัญหาพื้นฐาน

มาตรฐานห้ามเพิ่มการประกาศและคำจำกัดความใหม่ลงในเนมสเปซstdเนื่องจากการทำเช่นนั้นผู้ใช้อาจทำให้ไลบรารีมาตรฐานยุ่งเหยิงและทำให้ขาของเขาหลุดออกไปทั้งหมด สำหรับนักเขียนมาตรฐานมันง่ายกว่าที่จะปล่อยให้ผู้ใช้เชี่ยวชาญบางสิ่งบางอย่างและห้ามทำสิ่งอื่นใดเพื่อการวัดที่ดีแทนที่จะห้ามทุกสิ่งที่ผู้ใช้ไม่ควรทำและเสี่ยงต่อการพลาดบางสิ่งที่สำคัญ (และขานั้น) พวกเขาเคยทำมาแล้วในอดีตเมื่อกำหนดให้ไม่ต้องสร้างคอนเทนเนอร์มาตรฐานด้วยประเภทที่ไม่สมบูรณ์ในขณะที่ในความเป็นจริงคอนเทนเนอร์บางอย่างสามารถทำได้ดี (ดูThe Standard Librarian: Containers of Incomplete types by Matthew H. Austern ):

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

... เมื่อมองย้อนกลับไปตอนนี้เมื่อเข้าใจเทคโนโลยีมากขึ้นแล้วการตัดสินใจนั้นยังดูเหมือนถูกต้อง ใช่ในบางกรณีเป็นไปได้ที่จะใช้คอนเทนเนอร์มาตรฐานบางส่วนเพื่อให้สามารถสร้างอินสแตนซ์กับประเภทที่ไม่สมบูรณ์ได้ แต่ก็เป็นที่ชัดเจนว่าในกรณีอื่น ๆ อาจเป็นเรื่องยากหรือเป็นไปไม่ได้ ส่วนใหญ่เป็นโอกาสที่การทดสอบครั้งแรกที่เราลองใช้std::vectorนั้นเป็นหนึ่งในกรณีที่ง่าย

เนื่องจากกฎของภาษาต้องstd::size_tเป็นไปอย่างแน่นอนdecltype(sizeof(int))การทำnamespace std { using size_t = decltype(sizeof(int)); }จึงเป็นหนึ่งในสิ่งที่ไม่ผิดอะไรเลย

ก่อนหน้า C ++ 11 ไม่มีdecltypeและด้วยเหตุนี้จึงไม่มีวิธีการประกาศประเภทของsizeofผลลัพธ์ในคำสั่งง่ายๆเพียงคำสั่งเดียวโดยไม่ต้องมีเทมเพลตมากมายที่เกี่ยวข้อง size_tนามแฝงประเภทต่างๆบนสถาปัตยกรรมเป้าหมายที่แตกต่างกันอย่างไรก็ตามมันจะไม่ใช่วิธีการแก้ปัญหาที่หรูหราในการเพิ่มประเภทในตัวใหม่เพียงเพื่อผลลัพธ์sizeofและไม่มีตัวพิมพ์มาตรฐานในตัว ดังนั้นวิธีแก้ปัญหาแบบพกพาที่สุดในขณะนั้นคือการใส่size_tนามแฝงประเภทในส่วนหัวที่เฉพาะเจาะจงและจัดทำเอกสารนั้น

ใน C ++ 11 ตอนนี้มีวิธีการเขียนข้อกำหนดที่แน่นอนของมาตรฐานนั้นเป็นการประกาศง่ายๆ