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

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

การประกาศล่วงหน้า (Forward declaration) ใช้ในภาษาโปรแกรมที่ต้องการการประกาศก่อนใช้งาน ซึ่งจำเป็นสำหรับ การเรียก ซ้ำแบบร่วมกัน (mutual recursion ) ในภาษาเหล่านั้น เพราะเป็นไปไม่ได้ที่จะกำหนดฟังก์ชัน (หรือโครงสร้างข้อมูล) ดังกล่าวโดยไม่มีการอ้างอิงล่วงหน้าในคำจำกัดความหนึ่ง: ฟังก์ชัน (หรือโครงสร้างข้อมูล) อย่างใดอย่างหนึ่งจะต้องถูกประกาศก่อน นอกจากนี้ยังช่วยให้การจัดระเบียบโค้ดมีความยืดหยุ่นมากขึ้น เช่น หากต้องการวางส่วนหลักของโค้ดไว้ด้านบน และฟังก์ชันที่เรียกใช้ไว้ด้านล่าง

ในภาษาโปรแกรมอื่นๆ การประกาศล่วงหน้า (forward declaration) ไม่จำเป็น ซึ่งโดยทั่วไปแล้วจะต้อง ใช้คอมไพเลอร์ แบบหลายรอบ (multi-pass compiler)และการคอมไพล์บางส่วนจะต้องถูกเลื่อนไปใน ช่วงเวลาการเชื่อมโยง ( link time ) ในกรณีเหล่านี้ ตัวระบุจะต้องถูกกำหนด (ตัวแปรได้รับการกำหนดค่าเริ่มต้น ฟังก์ชันได้รับการกำหนด) ก่อนที่จะสามารถใช้งานได้ในระหว่างการทำงานโดยไม่จำเป็นต้องมีการกำหนดล่วงหน้าในซอร์สโค้ดสำหรับการคอมไพล์หรือการตีความ: ตัวระบุไม่จำเป็นต้องได้รับการแก้ไขทันทีให้เป็นเอนทิตีที่มีอยู่แล้ว

ตัวอย่างพื้นฐานในภาษาซีคือ:

void printThisInteger ( int );

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

void printThisInteger ( int x ) { printf ( "%d \n " , x ); }

ตัวแปรอาจมีเพียงการประกาศล่วงหน้าและไม่มีคำจำกัดความ ในระหว่างการคอมไพล์ ตัวแปรเหล่านี้จะถูกกำหนดค่าเริ่มต้นโดยกฎเฉพาะของภาษา (เช่น ค่าที่ไม่กำหนด, 0, ตัวชี้ NULL, ...) ตัวแปรที่กำหนดไว้ในไฟล์ต้นฉบับ/ออบเจ็กต์อื่นจะต้องมีการประกาศล่วงหน้าโดยระบุคำหลักextern:

int foo ; //foo อาจถูกกำหนดไว้ในไฟล์นี้แล้วextern int bar ; //bar ต้องถูกกำหนดไว้ในไฟล์อื่น

ใน ภาษา Pascalและ ภาษาโปรแกรม Wirth อื่นๆ กฎทั่วไปคือ ทุกเอนทิตีจะต้องได้รับการประกาศก่อนใช้งาน ดังนั้นการประกาศล่วงหน้าจึงจำเป็นสำหรับการเรียกซ้ำซึ่งกันและกัน ตัวอย่างเช่น ในภาษา C กฎทั่วไปเดียวกันนี้ก็ใช้ได้เช่นกัน แต่มีข้อยกเว้นสำหรับฟังก์ชันที่ไม่ได้ประกาศและประเภทที่ไม่สมบูรณ์ ดังนั้นในภาษา C จึงเป็นไปได้ (แม้จะไม่ฉลาดนัก) ที่จะใช้งาน ฟังก์ชัน ที่เรียกซ้ำซึ่งกันและกัน สอง ฟังก์ชันดังนี้:

int first ( int x ) { if ( x == 0 ) return 1 ; else return second ( x -1 ); // ส่งต่อการอ้างอิงไปยัง second }int second ( int x ) { if ( x == 0 ) return 0 ; else return first ( x -1 ); // อ้างอิงย้อนกลับไปยัง first }

ในภาษา Pascal การใช้งานแบบเดียวกันนี้จำเป็นต้องมีการประกาศล่วงหน้า (forward declaration) secondก่อนที่จะนำไปใช้firstหากไม่มีการประกาศล่วงหน้า คอมไพเลอร์จะแสดงข้อความแสดงข้อผิดพลาดระบุว่าตัวระบุsecondถูกนำไปใช้โดยไม่ได้ประกาศไว้ก่อน

ในภาษาโปรแกรมเชิงวัตถุบางภาษา เช่นC++และObjective-Cบางครั้งจำเป็นต้องประกาศคลาสล่วงหน้า (forward-declare) ซึ่งจะทำในกรณีที่จำเป็นต้องทราบว่าชื่อของคลาสเป็นชนิดข้อมูล แต่ไม่จำเป็นต้องทราบโครงสร้างของคลาส

ในภาษา C++ คลาสและโครงสร้างสามารถประกาศล่วงหน้าได้ดังนี้:

คลาสMyClass ; โครงสร้างMyStruct ;

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

การประกาศล่วงหน้า (Forward-declaration) ใช้เพื่อหลีกเลี่ยงการเชื่อมโยงที่ไม่จำเป็น ซึ่งช่วยลดเวลาในการคอมไพล์โดยลดจำนวนการรวมไฟล์เฮดเดอร์ วิธีนี้มีข้อดีสามประการ:

• ลดจำนวนไฟล์ที่เปิดโดยคำสั่ง #include (ซึ่งจะช่วยลดจำนวน การเรียก ใช้ระบบปฏิบัติการ )
• ลดขนาดไฟล์ที่ผ่านการประมวลผลเบื้องต้น (เนื่องจากไม่รวมส่วนหัว)
• ลดผลกระทบจากการคอมไพล์ใหม่เมื่อมีการแก้ไขคลาสที่ประกาศล่วงหน้า

การประกาศล่วงหน้าของคลาสไม่เพียงพอ หากคุณจำเป็นต้องใช้ชนิดของคลาสจริง ๆ ตัวอย่างเช่น หากคุณมีสมาชิกที่มีชนิดเป็นคลาสนั้นโดยตรง (ไม่ใช่ตัวชี้) หรือหากคุณจำเป็นต้องใช้เป็นคลาสพื้นฐาน หรือหากคุณจำเป็นต้องใช้เมธอดของคลาสในเมธอดอื่น

ในภาษา Objective-C คลาสและโปรโตคอลสามารถประกาศล่วงหน้าได้ดังนี้:

@class MyClass ; @protocol MyProtocol ; 

ใน Objective-C เราสามารถประกาศล่วงหน้า (forward-declared) คลาสและโปรโตคอลได้ หากต้องการใช้เฉพาะเป็นส่วนหนึ่งของประเภทตัวชี้ไปยังอ็อบเจ็กต์ เช่นMyClass *หรือid<MyProtocol>วิธีนี้มีประโยชน์อย่างยิ่งภายในนิยามของคลาส เช่น หากคลาสหนึ่งมีสมาชิกที่เป็นตัวชี้ไปยังอีกคลาสหนึ่ง เพื่อหลีกเลี่ยงการอ้างอิงแบบวนซ้ำ (เช่น คลาสนั้นอาจมีสมาชิกที่เป็นตัวชี้ไปยังคลาสนี้ด้วย) เราจึงประกาศล่วงหน้าคลาสเหล่านั้นแทน

การประกาศล่วงหน้าของคลาสหรือโปรโตคอลนั้นไม่เพียงพอ หากคุณต้องการสร้างคลาสย่อยจากคลาสนั้นหรือใช้งานโปรโตคอลนั้น

บางครั้ง คำว่าforward referenceถูกใช้เป็นคำพ้องความหมายของforward declaration [ ^{1 ] อย่างไรก็ตาม}บ่อยครั้งกว่านั้น คำนี้หมายถึงการใช้งาน จริง ของเอนทิตีก่อนการประกาศใดๆ กล่าวคือ การอ้างอิงแรกsecondในโค้ดข้างต้นเป็น forward reference ^{[ 2 ] [ 3 ]}ดังนั้น เราอาจกล่าวได้ว่า เนื่องจาก forward declaration เป็นสิ่งที่จำเป็นใน Pascal ดังนั้น forward referenceจึงเป็นสิ่งต้องห้าม

ตัวอย่างของการอ้างอิงไปข้างหน้า (forward reference) ที่ถูกต้องในภาษา C++ :

คลาสC { public : void mutator ( int x ) { myValue = x ; } int accessor () const { return myValue ; } private : int myValue ; };

ในตัวอย่างนี้ มีการอ้างอิงถึงสองครั้งmyValueก่อนที่จะมีการประกาศ โดยทั่วไปแล้ว C++ ห้ามการอ้างอิงล่วงหน้า แต่จะอนุญาตในกรณีพิเศษของสมาชิกคลาส เนื่องจากฟังก์ชันสมาชิกaccessorไม่สามารถคอมไพล์ได้จนกว่าคอมไพเลอร์จะทราบชนิดของตัวแปรสมาชิกmyValueดังนั้นจึงเป็นหน้าที่ของคอมไพเลอร์ที่จะต้องจดจำนิยามของaccessorจนกว่าจะเห็นmyValueการประกาศของ

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