ไกลแค่ไหนที่จะไปกับการพิมพ์ประเภทดั้งเดิมเช่น int

ฉันได้เห็นรหัส C ++ เช่นดังต่อไปนี้กับหลายtypedefๆ

อะไรคือประโยชน์ของการใช้หลาย ๆtypedefอย่างเช่นนี้เมื่อเทียบกับการใช้ภาษาซีพลัสพลัส มีวิธีอื่นที่อาจบรรลุผลประโยชน์เหล่านั้นด้วยหรือไม่

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

types.h:

typedef int16_t Version;
typedef int32_t PacketLength;
typedef int32_t Identity;
typedef int32_t CabinetNumber;
typedef int64_t Time64;
typedef int64_t RFID;
typedef int64_t NetworkAddress;
typedef int64_t PathfinderAddress;
typedef int16_t PathfinderPan;
typedef int16_t PathfinderChannel;
typedef int64_t HandsetSerialNumber;
typedef int16_t PinNumber;
typedef int16_t LoggingInterval;
typedef int16_t DelayMinutes;
typedef int16_t ReminderDelayMinutes;
typedef int16_t EscalationDelayMinutes;
typedef float CalibrationOffset;
typedef float AnalogValue;
typedef int8_t PathfinderEtrx;
typedef int8_t DampingFactor;
typedef int8_t RankNumber;
typedef int8_t SlavePort;
typedef int8_t EventLevel;
typedef int8_t Percent;
typedef int8_t SensorNumber;
typedef int8_t RoleCode;
typedef int8_t Hour;
typedef int8_t Minute;
typedef int8_t Second;
typedef int8_t Day;
typedef int8_t Month;
typedef int16_t Year;
typedef int8_t EscalationLevel;

ดูเหมือนว่ามีเหตุผลที่จะลองและตรวจสอบให้แน่ใจว่ามีการใช้งานประเภทเดียวกันเสมอสำหรับบางสิ่งเพื่อหลีกเลี่ยงการโอเวอร์โฟลว์ แต่ฉันมักจะเห็นโค้ดที่ "int" เพิ่งถูกใช้งานไปทุกหนทุกแห่งแทน typedefไอเอ็นจีมักจะนำไปสู่การรหัสที่มีลักษณะบิตเช่นนี้แม้ว่าจะเป็น:

DoSomething(EscalationLevel escalationLevel) {
    ...
}

ซึ่งทำให้ฉันสงสัยว่าโทเค็นใดที่อธิบายพารามิเตอร์จริง ๆ : ชนิดพารามิเตอร์หรือชื่อพารามิเตอร์

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

Typedefs มีประโยชน์สำหรับเทมเพลตหรือหากคุณต้องการเปลี่ยนประเภทที่ใช้สำหรับพารามิเตอร์บางตัวเช่นเมื่อย้ายจาก 32 บิตเป็นแพลตฟอร์ม 64 บิต

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

class AnalogueValue
{
public:
    // constructors, setters, getters, etc..
private:
    float m_value;
};

ไม่มีความแตกต่างด้านประสิทธิภาพระหว่าง:

typedef float AnalogueValue;
AnalogValue a = 3.0f;
CallSomeFunction (a);

และ:

AnalogValue a (3.0f); // class version
CallSomeFunction (a);

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

float amount = 10.00;
CallSomeFunction(amount);

นอกเหนือจากปัญหาการปัดเศษแล้วยังอนุญาตประเภทใด ๆ ที่สามารถแปลงเป็นทุ่น:

int amount = 10;
CallSomeFunction(amount);

ในกรณีนี้ไม่ใช่เรื่องใหญ่ แต่การแปลงโดยนัยอาจเป็นแหล่งของข้อบกพร่องที่ยากต่อการตรึง การใช้ a typedefไม่ได้ช่วยที่นี่เนื่องจากมันเป็นเพียงนามแฝงประเภท

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

class Money {
  Decimal amount;
  Currency currency;
};

Money m(Decimal("10.00"), Currency.USD);
CallSomeFunction(m);

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

การใช้ typedefs สำหรับประเภทดั้งเดิมเช่นที่ดูเหมือนรหัสสไตล์ C

ใน C ++ คุณจะได้รับข้อผิดพลาดที่น่าสนใจเร็วที่สุดเท่าที่คุณพยายามที่จะฟังก์ชั่นเกินพิกัดสำหรับการพูดและEventLevel Hourทำให้ชื่อประเภทพิเศษนั้นไร้ประโยชน์

พวกเรา (ที่ บริษัท ของเรา) ทำมันมากใน C ++ ช่วยทำความเข้าใจและรักษารหัส ซึ่งเป็นสิ่งที่ดีเมื่อมีการเคลื่อนย้ายผู้คนระหว่างทีมหรือทำการปรับโครงสร้างใหม่ ตัวอย่าง:

typedef float Price;
typedef int64_t JavaTimestmap;

void f(JavaTimestamp begin, JavaTimestamp end, Price income);

เราเชื่อว่าเป็นวิธีปฏิบัติที่ดีในการสร้าง typedef ให้กับชื่อมิติจากประเภทการเป็นตัวแทน ชื่อใหม่นี้แสดงถึงบทบาททั่วไปในซอฟต์แวร์ ชื่อของพารามิเตอร์การให้เป็นบทบาทของท้องถิ่น ชอบUser sender, User receiverค่ะ ในบางที่มันสามารถซ้ำซ้อนvoid register(User user)ได้ แต่ฉันไม่คิดว่ามันจะเป็นปัญหา

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

มันไม่ได้เป็น bullet เงินและมี caveats ของตัวเอง แต่เราคิดว่ามันดีกว่าการใช้มันมากกว่า

typedeftypeโดยทั่วไปช่วยให้คุณเพื่อให้นามแฝงสำหรับนักการ
มันจะช่วยให้คุณมีความยืดหยุ่นในการหลีกเลี่ยงการพิมพ์ยาวtype namesอีกครั้งและอีกครั้งและทำให้คุณได้ง่ายขึ้นสามารถอ่านได้นั้นชื่อนามแฝงที่บ่งชี้เจตนาหรือวัตถุประสงค์ของการtypetype

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

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

ใช้ typedefs เช่นนี้ไม่เป็นไรตราบใดที่ใครก็ตามที่ลมขึ้นใช้พวกเขาไม่จำเป็นต้องรู้อะไรเกี่ยวกับการเป็นตัวแทนของพวกเขาอยู่ภายใต้ ตัวอย่างเช่นหากคุณต้องการส่งผ่านPacketLengthวัตถุใด ๆprintfหรือscanfคุณจะต้องทราบประเภทที่แท้จริงของมันเพื่อให้คุณสามารถเลือกตัวระบุการแปลงที่ถูกต้อง ในกรณีเช่นนี้ typedef จะเพิ่มระดับของการทำให้งงงวยโดยไม่ต้องซื้ออะไรตอบแทน; คุณอาจกำหนดวัตถุเป็นเช่นint32_tกัน

หากคุณต้องการบังคับใช้ความหมายเฉพาะสำหรับแต่ละประเภท (เช่นช่วงหรือค่าที่อนุญาต) คุณควรสร้างประเภทข้อมูลนามธรรมและฟังก์ชั่นเพื่อใช้งานกับประเภทนั้นแทนที่จะสร้างประเภท typedef