พิมพ์ลายเซ็น

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

ในภาษา CและC++ลายเซ็นของประเภทจะถูกประกาศโดยสิ่งที่เรียกกันทั่วไปว่าต้นแบบฟังก์ชันใน C/C++ การประกาศฟังก์ชันสะท้อนถึงการใช้งานของ ฟังก์ชันนั้น ตัวอย่างเช่นตัวชี้ฟังก์ชันที่มีลายเซ็นจะถูกเรียกใช้ดังนี้: (int)(char,double)

char c ; double d ; int retVal = ( * fPtr )( c , d );

ในErlangลายเซ็นประเภทสามารถประกาศได้ตามความเหมาะสม ดังนี้: ^{[ 1 ]}

- spec function_name ( type1 (), type2 (), ...) -> out_type ().

ตัวอย่างเช่น:

- spec is_even ( number ()) -> boolean ().

โดยทั่วไปแล้ว ลายเซ็นประเภทในภาษา Haskellจะมีรูปแบบดังต่อไปนี้:

ชื่อฟังก์ชัน:: ประเภทอาร์กิวเมนต์1 -> ประเภทอาร์กิวเมนต์2 -> ... -> ประเภทอาร์กิวเมนต์n

โปรดสังเกตว่าประเภทของผลลัพธ์สามารถพิจารณาได้ว่าเป็นทุกอย่างหลังจากอาร์กิวเมนต์แรกที่ป้อนเข้ามา นี่เป็นผลมาจากการใช้ curryingซึ่งเป็นไปได้ด้วยการสนับสนุนฟังก์ชันระดับเฟิร์สคลาส ของ Haskell ฟังก์ชันนี้ต้องการอินพุตสองตัว โดยมีอาร์กิวเมนต์หนึ่งตัวที่ป้อนเข้ามา และฟังก์ชันจะถูก "curried" เพื่อสร้างฟังก์ชันสำหรับอาร์กิวเมนต์ที่ไม่ได้ป้อนเข้ามา ดังนั้น การเรียกใช้โดยที่จะได้ฟังก์ชันใหม่ที่สามารถเรียกใช้เพื่อสร้าง fxf::a->b->cf2::b->cf2bc

ข้อกำหนดประเภทที่แท้จริงอาจประกอบด้วยประเภทที่แท้จริง เช่น หรือ ตัวแปรประเภทIntegerทั่วไปที่ใช้ในฟังก์ชันโพลีมอร์ฟิกแบบพาราเมตริกเช่นหรือหรือดังนั้นเราจึงสามารถเขียนได้ดังนี้: abanyTypefunctionName::a->a->...->a

เนื่องจาก Haskell รองรับฟังก์ชันลำดับสูงจึงสามารถส่งฟังก์ชันเป็นอาร์กิวเมนต์ได้ โดยเขียนได้ดังนี้: functionName::(a->a)->a

ฟังก์ชันนี้รับฟังก์ชันที่มีรูปแบบการลงนามเป็นประเภทและส่งคืนข้อมูลประเภทเอาต์ a->aa

ในเครื่องเสมือน Java นั้นลายเซ็นประเภทภายในจะถูกใช้เพื่อระบุเมธอดและคลาสในระดับโค้ดของเครื่องเสมือน

ตัวอย่าง: เมธอดนี้แสดงในรูปแบบไบต์โค้ดเป็น. StringString.substring(int,int)Ljava/lang/String.substring(II)Ljava/lang/String;

ลายเซ็นของmainเมธอดมีลักษณะดังนี้: ^{[ 2 ]}

public static void main ( String [] args );

และในไบต์โค้ดที่แยกส่วนแล้ว มันจะมีรูปแบบดังนี้Lsome/package/Main/main:([Ljava/lang/String;)V

ลายเซ็นเมธอดสำหรับmain()เมธอดนี้ประกอบด้วยตัวดัดแปลงสามตัว:

• publicระบุว่าเมธอดนี้สามารถเรียกใช้ได้โดยวัตถุใดก็ได้main()
• staticระบุว่าเมธอดดังกล่าวเป็นเมธอดของคลาสmain()
• voidแสดงว่าเมธอดนี้ไม่มีค่าส่งคืนmain()

ลายเซ็นฟังก์ชันประกอบด้วยต้นแบบฟังก์ชัน ซึ่งระบุข้อมูลทั่วไปเกี่ยวกับฟังก์ชัน เช่น ชื่อ ขอบเขต และพารามิเตอร์ ภาษาโปรแกรมหลายภาษาใช้การแปลงชื่อเพื่อส่งต่อข้อมูลเชิงความหมายเพิ่มเติมจากคอมไพเลอร์ไปยังลิงเกอร์ นอกจากการแปลงชื่อแล้ว ยังมีข้อมูลส่วนเกินในลายเซ็นฟังก์ชัน (จัดเก็บไว้ภายในคอมไพเลอร์ส่วนใหญ่) ซึ่งไม่สามารถเข้าถึงได้โดยตรง แต่สามารถเข้าถึงได้^{[ 3 ]}

การเข้าใจแนวคิดเรื่องลายเซ็นฟังก์ชันเป็นแนวคิดสำคัญสำหรับการศึกษาด้านวิทยาการคอมพิวเตอร์ทุกแขนง

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

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

ใน ภาษาการ เขียน โปรแกรม Cลายเซ็นนั้นเทียบได้โดยประมาณกับคำจำกัดความต้นแบบของฟังก์ชัน นั้น

ในกลุ่มภาษาโปรแกรมMLคำว่า "signature" ถูกใช้เป็นคำหลักที่อ้างถึงโครงสร้างของระบบโมดูลซึ่งทำหน้าที่เป็นอินเทอร์เฟซ

ในการเขียนโปรแกรมคอมพิวเตอร์โดยเฉพาะการเขียนโปรแกรมเชิงวัตถุเมธอดมักจะถูกระบุด้วยลายเซ็นเมธอด ที่ไม่ซ้ำกัน ซึ่งโดยปกติ จะประกอบด้วยชื่อเมธอดและจำนวน ประเภท และลำดับของพารามิเตอร์^{[ 4 ]}ลายเซ็นเมธอดเป็นประเภทที่ เล็กที่สุด ของเมธอด

ในภาษาซี ลายเซ็นของเมธอดคือชื่อเมธอด จำนวน และชนิดของพารามิเตอร์ แต่สามารถมีพารามิเตอร์แบบแปรผัน ได้ แต่พารามิเตอร์เหล่านี้จะไม่ปลอดภัยต่อชนิดข้อมูล

int printf ( const char * fmt , ...);

การปรับเปลี่ยนพารามิเตอร์เหล่านี้สามารถทำได้โดยใช้รูทีนในไฟล์เฮดเดอร์ของไลบรารี<stdarg.h>มาตรฐาน

ในภาษา C++ นอกเหนือจากชนิดข้อมูลการส่งคืนค่าแบบ C-style ที่ปรากฏอยู่ข้างหน้าแล้ว ชนิดข้อมูลการส่งคืนค่าอาจตามหลังรายการพารามิเตอร์ ซึ่งเรียกว่า ชนิดข้อมูลการส่งคืนค่าแบบต่อท้าย (trailing return type ) ความแตกต่างเป็นเพียงด้านไวยากรณ์เท่านั้น ในทั้งสองกรณี ลายเซ็นที่ได้จะเหมือนกัน

หากใช้เทมเพลตแบบแปรผัน :

void doSomething ( auto && ... args );

หมายเหตุเทียบเท่ากับ. voiddoSomething(auto...args);template<typename...Ts>voiddoSomething(Ts...args);

เช่นเดียวกับไวยากรณ์ของ C ลายเซ็นเมธอดในC#ประกอบด้วยชื่อและจำนวนและประเภทของพารามิเตอร์ โดยพารามิเตอร์สุดท้ายอาจเป็นอาร์เรย์ของค่า: ^{[ 5 ]}

void Add ( out int sum , params int [] value ); [...] Add ( out sum , 3 , 5 , 7 , 11 , - 1 ); // sum == 25

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

ลายเซ็นของเมธอดช่วยแยกแยะเมธอดที่มีการโอเวอร์โหลด (เมธอดที่มีชื่อเดียวกัน) ในคลาส ประเภทการส่งคืนไม่รวมอยู่ในการโอเวอร์โหลด ควรใช้ลายเซ็นของเมธอดเท่านั้นเพื่อแยกแยะเมธอดที่มีการโอเวอร์โหลด^{[ 6 ]}

ตัวอย่างเช่น เมธอดสองวิธีต่อไปนี้มีรูปแบบการเขียนโค้ดที่แตกต่างกัน:

void doSomething ( String [] x ); // doSomething(String[]) void doSomething ( String x ); // doSomething(String)

สองวิธีต่อไปนี้มีรูปแบบการเรียกใช้เหมือนกัน:

int doSomething ( int x ); // doSomething(int) void doSomething ( int y ) throws Exception ; // doSomething(int)

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

void doSomething ( String ... x ); // เทียบเท่ากับ doSomething(String[])

ในภาษา Juliaรูปแบบของลายเซ็นฟังก์ชันมีดังนี้:

ค่าคอมมิชชั่น( ขาย:: Int , อัตรา:: Float64 ) :: Float64

ชนิดของข้อมูลในอาร์กิวเมนต์จะถูกใช้สำหรับการเรียกใช้ฟังก์ชันแบบหลายทาง (multiple dispatch ) ชนิดของค่าที่ส่งคืนจะถูกตรวจสอบเมื่อฟังก์ชันส่งค่ากลับ และจะเกิดข้อยกเว้นขณะรันไทม์หากชนิดของค่าที่ส่งคืนไม่ตรงกับชนิดที่ระบุไว้

อนุญาตและสนับสนุนให้ใช้ประเภทนามธรรม (Abstract types) ในการใช้งานพฤติกรรมทั่วไปที่ใช้ร่วมกันได้ในทุกประเภทย่อย ดังนั้น ฟังก์ชันข้างต้นจึงสามารถเขียนใหม่ได้ดังนี้ ในกรณีนี้ ฟังก์ชันสามารถรับประเภทย่อย Integer และ Real ใดก็ได้ตามลำดับ

ค่าคอมมิชชั่น( การขาย:: จำนวนเต็ม, อัตรา:: จำนวนจริง) :: จำนวนจริง

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

ใน ภาษาการเขียนโปรแกรม Objective-Cลายเซ็นของเมธอดสำหรับอ็อบเจ็กต์จะถูกประกาศไว้ในไฟล์เฮดเดอร์ ของอินเทอร์เฟซ ตัวอย่างเช่น

- ( id ) initWithInt: ( int ) value ;

กำหนดเมธอดinitWithIntที่ส่งคืนอ็อบเจ็กต์ทั่วไป (an id) และรับอาร์กิวเมนต์จำนวนเต็มหนึ่งตัว Objective-C กำหนดให้ระบุประเภทในลายเซ็นเฉพาะเมื่อประเภทนั้นไม่ใช่id; ลายเซ็นนี้เทียบเท่ากัน:

- initWithInt: ( int ) value ;

ในภาษา Rustรูปแบบของลายเซ็นฟังก์ชันจะเป็นดังนี้:

ค่าคอมมิชชั่นfn ( การขาย: u32 , อัตรา: f64 ) -> f64 ;

• อาร์กิวเมนต์ของฟังก์ชัน  – ค่าป้อนเข้าของฟังก์ชันทางคณิตศาสตร์