ثابت (برمجة الحاسوب)

في بعض لغات البرمجة ، يُعدّ `const` مُحدِّدًا للنوع ( كلمة مفتاحية تُطبَّق على نوع البيانات ) يُشير إلى أن البيانات للقراءة فقط. مع أنّه يُمكن استخدامه لتعريف الثوابت ، إلا أنّه constفي عائلة لغات C يختلف عن البنى المُشابهة في اللغات الأخرى، إذ يُعدّ جزءًا من النوع ، وبالتالي يُؤدّي إلى سلوك مُعقّد عند دمجه مع المؤشرات ، والمراجع، وأنواع البيانات المُركَّبة ، والتحقّق من النوع . في لغات أخرى، لا تُخزَّن البيانات في موقع ذاكرة واحد ، بل تُنسخ في وقت الترجمة لكل استخدام. ^{[ 1 ]} تشمل اللغات التي تستخدمه: C و C++ و D و JavaScript و Julia و Rust .

عند استخدامها في تعريف كائن ، تشير ^{[ a ]} إلى أن الكائن ثابت : لا يمكن تغيير قيمته ، على عكس المتغير . هذا الاستخدام الأساسي - تعريف الثوابت - له نظائر في العديد من اللغات الأخرى.

مع ذلك، على عكس اللغات الأخرى، في عائلة لغات C، constيُعدّ `x` جزءًا من النوع ، وليس جزءًا من الكائن . على سبيل المثال، في لغة C، يُصرّح عن كائن من النوع `x`، حيث يُعدّ `x` جزءًا من النوع، كما لو تم تحليله على النحو التالي: `(const int) x`. بينما في لغة Ada ، يُصرّح عن ثابت (نوع من الكائنات) من النوع `x`: حيث يُعدّ `x` جزءًا من الكائن ، ولكنه ليس جزءًا من النوع .constintx=1;xconst intconstX:constantINTEGER:=1_XINTEGERconstant

يترتب على ذلك نتيجتان دقيقتان. أولاً، constيمكن تطبيق ذلك على أجزاء من نوع أكثر تعقيدًا - على سبيل المثال، const int* const x;يُعلن عن مؤشر ثابت إلى عدد صحيح ثابت، بينما const int* x;يُعلن عن مؤشر متغير إلى عدد صحيح ثابت، int* const x;ويُعلن عن مؤشر ثابت إلى عدد صحيح متغير. ثانيًا، نظرًا لأن constجزءًا من النوع، يجب أن يتطابق كجزء من فحص النوع. على سبيل المثال، الكود التالي غير صالح:

void f ( int & x ); // ... const int i ; f ( i );

لأن الوسيط المُمرَّر إلى الدالة fيجب أن يكون عددًا صحيحًا متغيرًا ، بينما الوسيط المُمرَّر إلى iالدالة عدد صحيح ثابت . يُعد هذا التطابق شكلًا من أشكال صحة البرنامج ، ويُعرف باسم صحة الثوابت . يسمح هذا بنوع من البرمجة التعاقدية ، حيث تُحدد الدوال، كجزء من توقيع نوعها، ما إذا كانت تُعدِّل وسائطها أم لا، وما إذا كانت قيمتها المُعادة قابلة للتعديل أم لا. يُعد فحص النوع هذا ذا أهمية بالغة في المؤشرات والمراجع - وليس في أنواع القيم الأساسية مثل الأعداد الصحيحة - ولكنه مهم أيضًا لأنواع البيانات المركبة أو الأنواع المُنمذجة مثل الحاويات . يُخفى هذا الفحص نظرًا لإمكانية constحذف الوسيط المُمرَّر في كثير من الأحيان، بسبب تحويل النوع الضمني ( تحويل النوع الضمني ) ولأن لغة C تعتمد على استدعاء القيمة (بينما تعتمد لغتا C++ وD إما على استدعاء القيمة أو استدعاء المرجع).

لا تعني فكرة الثبات أن المتغير كما هو مخزن في ذاكرة الحاسوب غير قابل للكتابة. بل إن constالثبات هو بنية برمجية تُستخدم أثناء الترجمة لتحديد ما ينبغي على المبرمج فعله، وليس بالضرورة ما يمكنه فعله. مع ذلك، تجدر الإشارة إلى أنه في حالة البيانات المُعرَّفة مسبقًا (مثل const char*السلاسل النصية )، غالبًا ماconst تكون لغة C غير قابلة للكتابة.

بينما لا تتغير قيمة الثابت أثناء تشغيل البرنامج، constقد تتغير قيمة الكائن المُعلن عنه أثناء تشغيل البرنامج. ومن الأمثلة الشائعة على ذلك سجلات القراءة فقط في الأنظمة المدمجة، مثل الحالة الحالية للمدخل الرقمي. غالبًا ما تُعلن سجلات بيانات المدخلات الرقمية باسم `<data>` constو`< data> volatile`. قد يتغير محتوى هذه السجلات دون تدخل البرنامج (`<data> volatile`)، ولكن من غير الصحيح أن يحاول البرنامج الكتابة إليها (`<data> const`).

بالإضافة إلى ذلك، يمكن تعريف دالة عضو (غير ثابتة) على النحو التالي: `const` const. في هذه الحالة، يكون thisالمؤشر داخل هذه الدالة من النوع `const` const T*وليس من النوع `const` فقط T*. ^{[ 2 ]} هذا يعني أنه لا يمكن استدعاء الدوال غير الثابتة لهذا الكائن من داخل هذه الدالة، كما لا يمكن تعديل متغيرات الأعضاءmutable . في لغة C++، يمكن تعريف متغير عضو على النحو التالي : `const`، مما يشير إلى أن هذا القيد لا ينطبق عليه. في بعض الحالات، قد يكون هذا مفيدًا، على سبيل المثال مع التخزين المؤقت ، وحساب المراجع ، ومزامنة البيانات . في هذه الحالات، يظل المعنى المنطقي (الحالة) للكائن دون تغيير، لكن الكائن ليس ثابتًا فعليًا لأن تمثيله الثنائي قد يتغير.

في لغات C وC++ وD، يُمكن تعريف جميع أنواع البيانات، بما في ذلك تلك التي يُحددها المستخدم، constعلى أنها ثابتة (const-correctness)، ويُلزم مبدأ الثبات (const-correctness) بتعريف جميع المتغيرات أو الكائنات على هذا النحو ما لم تكن هناك حاجة لتعديلها. constيُسهّل هذا الاستخدام الاستباقي للثوابت فهم القيم وتتبعها وتحليلها ^{[ 3 ]} ، مما يزيد من قابلية قراءة الكود وفهمه، ويُبسّط العمل الجماعي وصيانة الكود لأنه يُوضّح الاستخدام المقصود للقيمة. يُساعد هذا المُصرّف والمطور على حدٍ سواء في تحليل الكود، كما يُتيح للمُصرّف المُحسّن توليد كود أكثر كفاءة ^{[ 4 ] .}

void foo ( int * p , const int * cp , int * const pc , const int * const cpc ) { * p = 0 ; // صحيح: يُعدّل البيانات المشار إليها p = NULL ; // صحيح: يُعدّل المؤشر* cp = 0 ; // خطأ! لا يمكن تعديل البيانات المشار إليها cp = NULL ; // صحيح: تم تعديل المؤشر* pc = 0 ; // صحيح: يتم تعديل البيانات المشار إليها pc = NULL ; // خطأ! لا يمكن تعديل المؤشر* cpc = 0 ; // خطأ! لا يمكن تعديل البيانات المشار إليها cpc = NULL ; // خطأ! لا يمكن تعديل المؤشر }

int * p ; // *p قيمة عددية صحيحة const int * cp ; // *cp عدد صحيح ثابت int * const pc ; // pc عدد صحيح ثابت int* const int * const cpc ; // cpc مؤشر ثابت ويشير إلى قيمة ثابتة

double ( ** const ( * fun ( int ))( double ))[ 10 ]

هزار

( عدد صحيح ))

( *

( مزدوج ))

( ** ثابت

[ 10 ]

مزدوج

const int * cp ; // مكافئ لـ int const* cp, const int * const cpc ; // مكافئ لـ int const* const cpc

int ** pp ; // مؤشر إلى مؤشر إلى أعداد صحيحة const int ** cpp ; // مؤشر إلى مؤشر إلى قيمة عددية صحيحة ثابتة (ليس مؤشرًا إلى مؤشر ثابت إلى أعداد صحيحة) int * const * pcp ; // مؤشر إلى مؤشر ثابت إلى قيم عددية صحيحة (ليس مؤشرًا ثابتًا إلى مؤشر إلى أعداد صحيحة) int ** const ppc ; // مؤشر ثابت إلى مؤشرات إلى أعداد صحيحة (كون ppc، المعرّف، ثابتًا لا معنى له) const int ** const cppc ; // مؤشر ثابت إلى مؤشرات إلى قيم عددية صحيحة ثابتة

// طريقتان: int * a ; // علامة النجمة محاذية لليسار int * a ; // علامة النجمة محاذية لليمينint * a , b ; // مُربك (a مؤشر إلى عدد صحيح بينما b عدد صحيح فقط) int * a , b ; // a مؤشر إلى عدد صحيح و b عدد صحيحint * a , * b ; // طريقة كتابة غير أنيقة (كلاهما مؤشران إلى أعداد صحيحة، لكن هذه طريقة غير مريحة للكتابة) int * a , * b ;

int * a , * b ; // غير مسموح به في لغة C# int * a , b ; // يُعلن عن متغيرين من نوع int*

int i = 22 ; const int & cr = i ; const int & cr2 = i , cr3 = i ; // مُربك: // cr2 مرجع، لكن cr3 ليس كذلك: // cr3 عدد صحيح ثابت مُهيأ بقيمة i// خطأ: لا يمكن تغيير المراجع على أي حال. int & const rc = myInt ;// C++: int && rref = int ( 5 ), value = 10 ; // مُربك: rref هو مرجع قيمة يمين، لكن value هو عدد صحيح فقط. int && rref = int ( 5 ), value = 10 ;

في لغة C++، هناك أربعة أنواع مختلفة من const:

• constالثابت الزمني التقليدي
• constexpr، ثابت أو تعبير يمكن تقييمه في وقت الترجمة (انظر constexpr )
• consteval، والذي ينص على أن أي استدعاء لدالة يجب أن ينتج قيمة عبارة عن تعبير وقت الترجمة
• constinit، مما يُعلن أن التعبير له تهيئة ثابتة (ثابتة)

class Integer { private : int i ; public : // لاحظ علامة const [[ nodiscard ]] int get () const noexcept { return i ; }// لاحظ عدم وجود "const" void set ( int j ) noexcept { i = j ; } };void foo ( Integer & nonConstInteger , const Integer & constInteger ) { int y = nonConstInteger . get (); // صحيح int x = constInteger . get (); // صحيح: get() ثابتnonConstInteger.set ( 10 ); // صحيح : nonConstInteger قابل للتعديل constInteger.set ( 10 ) ; // خطأ! set ( ) دالة غير ثابتة و constInteger كائن مؤهل بـ const }

استيراد std ؛باستخدام std :: array ;class IntegerArray { private : array < int , 100 > data ; public : [[ nodiscard ]] int & get ( int i ) noexcept { return data [ i ]; }[[ nodiscard ]] int const & get ( int i ) const noexcept { return data [ i ]; } };void foo ( IntegerArray & a , const IntegerArray & ca ) { // الحصول على مرجع لعنصر مصفوفة // وتعديل قيمته المشار إليها.a.get ( 5 ) = 42 ; // صحيح! (استدعاءات: int& IntegerArray::get(int)) ca.get ( 5 ) = 42 ; // خطأ! (استدعاءات: int const& IntegerArray::get( int ) const ) }

توجد عدة ثغرات في مبدأ صحة الثوابت المطلقة في لغتي C و C++. وهي موجودة أساسًا لتحقيق التوافق مع التعليمات البرمجية الموجودة.

الأولى، والتي تنطبق فقط على لغة C++، هي استخدام `const` const_cast، الذي يسمح للمبرمج بإزالة constالمُحدِّد، مما يجعل أي كائن قابلاً للتعديل. تبرز ضرورة إزالة المُحدِّد عند استخدام أكواد ومكتبات موجودة لا يمكن تعديلها ولكنها غير متوافقة مع `const`. على سبيل المثال، انظر إلى هذا الكود:

// نموذج أولي لدالة لا يمكننا تغييرها ولكننا نعلم أنها لا تُعدّل المؤشر المُمرَّر إليها. void myLibFunc ( int * p , int size );void callLibFunc ( const int * p , int size ) { myLibFunc ( p , size ); // خطأ! تم حذف مُحدِّد constint * nonConstPtr = const_cast < int *> ( p ); // إزالة المحدد myLibFunc ( nonConstPtr , size ); // صحيح }

مع ذلك، فإن أي محاولة لتعديل كائن مُعرَّف constباستخدام تحويل ثابت (const cast) تُؤدي إلى سلوك غير مُعرَّف وفقًا لمعيار ISO C++. في المثال أعلاه، إذا كان `const ptrcast` يُشير إلى متغير عام أو محلي أو عضو مُعرَّف كـ `const constcast`، أو كائن مُخصَّص في الذاكرة الديناميكية (heap) باستخدام `const cast` new int const، فإن الكود يكون صحيحًا فقط إذا LibraryFuncلم يُعدِّل `const cast` القيمة التي يُشير إليها `const cast` ptr.

تحتاج لغة C إلى ثغرة قانونية بسبب وجود حالة معينة. يُسمح بتعريف المتغيرات ذات مدة التخزين الثابتة بقيمة ابتدائية. مع ذلك، لا يمكن للمُهيئ استخدام سوى الثوابت، مثل ثوابت السلاسل النصية والقيم الحرفية الأخرى، ولا يُسمح له باستخدام عناصر غير ثابتة، مثل أسماء المتغيرات، سواءً أُعلنت عناصر المُهيئ constأم لا، أو أُعلن عن متغير مدة التخزين الثابتة نفسه constأم لا. توجد طريقة غير قابلة للنقل لتهيئة constمتغير ذي مدة تخزين ثابتة. من خلال إنشاء تحويل نوع دقيق على الجانب الأيسر من عملية إسناد لاحقة، constيمكن الكتابة إلى المتغير، مما يؤدي فعليًا إلى إزالة constالخاصية و"تهيئته" بعناصر غير ثابتة، مثل constمتغيرات أخرى وما شابه. constقد تعمل الكتابة إلى متغير بهذه الطريقة كما هو مُتوقع، لكنها تُسبب سلوكًا غير مُحدد وتُخالف بشكلٍ خطير مبدأ صحة الثوابت.

constexpr size_t BUFFER_SIZE = 8 * 1024 ; const size_t userTextBufferSize ; // تعتمد القيمة الأولية على const BUFFER_SIZE، ولا يمكن تهيئتها هنا...int setupUserTextBox ( TextBox * defaultTextBoxType , Rectangle * defaultTextBoxLocation ) { * ( size_t * ) & userTextBufferSize = BUFFER_SIZE - sizeof ( TextBoxControls ); // تحذير: قد يعمل، لكن ليس مضمونًا من قِبل لغة C ... }

توجد ثغرة أخرى ^{[ 12 ]} تنطبق على كلٍ من لغتي C وC++. تحديدًا، تنص اللغتان على أن مؤشرات الأعضاء والمراجع "سطحية" فيما يتعلق بخصائص constمالكيها - أي أن الكائن الحاوي الذي constيحتوي على جميع constالأعضاء باستثناء الأعضاء التي تشير إليها (والمراجع) لا يزال قابلاً للتغيير. للتوضيح، انظر إلى كود C++ التالي:

struct MyStruct { int val ; int * ptr ; };void foo ( const MyStruct & s ) { int i = 42 ; s . val = i ; // خطأ: s ثابت، لذا فإن val عدد صحيح ثابت int s . ptr = & i ; // خطأ: s ثابت، لذا فإن ptr مؤشر ثابت إلى int * s . ptr = i ; // صحيح: البيانات التي يشير إليها ptr قابلة للتغيير دائمًا، على الرغم من أن هذا غير مرغوب فيه أحيانًا }

على الرغم من أن الكائن sالمُمرَّر foo()ثابت، مما يجعل جميع عناصره ثابتة، إلا أن الكائن المُشار إليه (الذي يمكن الوصول إليه عبر هذا الكائن) s.ptrيظل قابلاً للتعديل، مع أن هذا قد لا يكون مرغوبًا من منظور constصحة الكود، لأن sالكائن قد يمتلك الكائن المُشار إليه حصريًا. لهذا السبب، يرى مايرز أن الوضع الافتراضي لمؤشرات العناصر والمراجع يجب أن يكون "عميقًا" const، والذي يمكن تجاوزه باستخدام mutableمُحدِّد عندما لا يكون الكائن المُشار إليه مملوكًا للحاوية، لكن هذه الاستراتيجية ستُسبب مشاكل توافق مع التعليمات البرمجية الموجودة. لذا، ولأسباب تاريخية ، تبقى هذه الثغرة مفتوحة في لغتي C وC++.

يمكن سد الثغرة الأخيرة باستخدام فئة لإخفاء المؤشر خلف constواجهة صحيحة، ولكن هذه الفئات إما لا تدعم دلالات النسخ المعتادة من constكائن (مما يعني أنه لا يمكن نسخ الفئة الحاوية بالدلالات المعتادة أيضًا) أو تسمح بثغرات أخرى من خلال السماح بإزالة خاصية const-ness من خلال النسخ غير المقصود أو المتعمد.

أخيرًا، تنتهك العديد من الدوال في مكتبة C القياسية مبدأ صحة الثوابت قبل إصدار C23 ، حيث تقبل constمؤشرًا إلى سلسلة نصية وتعيد قيمة غير constمؤشرية إلى جزء من السلسلة نفسها. strstrومن strchrبين هذه الدوال، تُعدّ `const` و`const` من بين الدوال التي تنتهك هذا المبدأ. تحاول بعض تطبيقات مكتبة C++ القياسية، مثل تطبيق مايكروسوفت ^{[ 13 ]} ، سدّ هذه الثغرة بتوفير نسختين مُحمّلتين بشكل زائد من بعض الدوال: constنسخة "const" ونسخة "const const".

يؤدي استخدام نظام الأنواع للتعبير عن الثبات إلى تعقيدات ومشاكل عديدة، ولذلك تعرض لانتقادات ولم يُعتمد خارج نطاق عائلة لغات C الضيقة، C وC++ وD. أما لغتا Java وC#، المتأثرتان بشدة بـ C وC++، فقد رفضتا صراحةً constمُحدِّدات الأنواع من النمط -، واستبدلتاها بالتعبير عن الثبات باستخدام كلمات مفتاحية تُطبَّق على المُعرِّف ( finalفي Java، constو readonlyفي C#). حتى داخل لغتي C وC++، يختلف استخدام - constبشكل كبير، فبعض المشاريع والمؤسسات تستخدمه باستمرار، بينما تتجنبه أخرى.

char * strchr ( char * s , int c );

إذا كان ( p = strchr ( q , '/' )) { * p = ' ' ; }

char * strchr ( char * s , int c ); const char * strchr ( const char * s , int c );

template < T > T * strchr ( T * s , int c ) { ... }

inout ( char )* strchr ( inout ( char )* s , int c );

char * strchr ( const char * s , int c );

في الإصدار الثاني من لغة البرمجة D ، توجد كلمتان مفتاحيتان تتعلقان بالثوابت (const). ^{[ 17 ]} تشير الكلمة immutableالمفتاحية الأولى إلى بيانات لا يمكن تعديلها من خلال أي مرجع. constوتشير الكلمة المفتاحية الثانية إلى عرض غير قابل للتغيير لبيانات قابلة للتغيير. على عكس لغة C++ const، فإن الثوابت في D constو immutableهما "عميقة" أو متعدية ، وأي شيء يمكن الوصول إليه من خلال كائن `const` constأو ` immutableconst` هو const`const` أو `const` immutableعلى التوالي.

مثال على الفرق بين الثابت وغير القابل للتغيير في لغة D

int [] foo = new int [ 5 ]; // foo قابلة للتغيير. const int [] bar = foo ; // bar عبارة عن عرض ثابت لبيانات قابلة للتغيير. immutable int [] baz = foo ; // خطأ: يجب أن تكون جميع عروض البيانات غير القابلة للتغيير غير قابلة للتغيير.immutable int [] nums = new immutable ( int )[ 5 ]; // لا يمكن إنشاء مرجع قابل للتغيير إلى nums. const int [] constNums = nums ; // يعمل. immutable قابل للتحويل ضمنيًا إلى const. int [] mutableNums = nums ; // خطأ: لا يمكن إنشاء عرض قابل للتغيير لبيانات غير قابلة للتغيير.

مثال على الثابت المتعدي أو الثابت العميق في لغة D

class LinkedList { int value ; LinkedList next ; }`immutable LinkedList ll = new immutable ( LinkedList ); ll.next.value = 5 ; ` // لن يتم تجميع الكود. `ll.next` من النوع `immutable(LinkedList)`. // ` ll.next.value` من النوع `immutable(int)` .

constتم تقديمها بواسطة بيارن ستروستروب في لغة C مع الفئات ، وهي اللغة السابقة للغة C++ ، في عام 1981، وكان اسمها الأصلي readonly. ^{[ 18 ] [ 19 ]} أما عن الدافع، فقد كتب ستروستروب: ^{[ 19 ]}

"لقد خدمت وظيفتين: كوسيلة لتعريف ثابت رمزي يلتزم بقواعد النطاق والنوع (أي بدون استخدام ماكرو) وكطريقة لاعتبار كائن في الذاكرة غير قابل للتغيير."

كان الاستخدام الأول، كبديل محدد النطاق والنوع للوحدات البرمجية، قد تم تحقيقه بشكل مماثل للوحدات البرمجية الشبيهة بالدوال عبر الكلمة المفتاحية. وقد اقترح دينيس ريتشي inlineالمؤشرات الثابتة والترميز وتم اعتمادهما. ^{[ 19 ]}* const

constثم اعتُمدت هذه الخاصية في لغة C كجزء من عملية التوحيد القياسي، وتظهر في C89 (والإصدارات اللاحقة) إلى جانب مُحدِّد النوع الآخر volatile. ^{[ 20 ]} واقتُرح مُحدِّد آخر، ، noaliasفي اجتماع لجنة X3J11 في ديسمبر 1987، لكنه رُفض؛ وتحقق هدفه في نهاية المطاف من خلال الكلمة restrictالمفتاحية في C99 . لم يكن ريتشي مؤيدًا بشدة لهذه الإضافات، بحجة أنها لا تُحقق الغرض منها، لكنه في النهاية لم يُطالب بإزالتها من المعيار. ^{[ 21 ]}

ورثت لغة D لاحقًا constمن لغة C++، حيث تُعرف باسم مُنشئ النوع (وليس مُؤهِّل النوع )، وأضافت مُنشئَي نوع آخرين، immutableو inout، للتعامل مع حالات الاستخدام ذات الصلة. ^{[ d ]}

لا تتبع لغات البرمجة الأخرى لغة C/C++ في اعتبار الثبات جزءًا من النوع، على الرغم من أنها غالبًا ما تمتلك بنى متشابهة ظاهريًا وقد تستخدم الكلمة constالمفتاحية. وعادةً ما يُستخدم هذا فقط للثوابت (الكائنات الثابتة).

تحتوي لغة C#const على كلمة مفتاحية، ولكن بدلالات مختلفة تمامًا وأبسط: فهي تعني ثابتًا وقت الترجمة، وليست جزءًا من النوع. وهي مكافئة بشكل أساسي لـ constexprفي لغتي C و C++.

تحتوي لغة Nimconst على كلمة مفتاحية مشابهة لتلك الموجودة في لغة C#: فهي تُعلن عن ثابت وقت الترجمة بدلاً من أن يكون جزءًا من النوع. مع ذلك، في Nim، يمكن الإعلان عن ثابت من أي تعبير يمكن تقييمه وقت الترجمة. ^{[ 22 ]} في C#، لا يمكن الإعلان عن أنواع C# المضمنة إلا كـ `static` const؛ أما الأنواع المعرفة من قِبل المستخدم، بما في ذلك الفئات والهياكل والمصفوفات، فلا يمكن تعريفها كـ `static` const. ^{[ 23 ]}

تحتوي لغة Rustconst على كلمة مفتاحية مشابهة لتلك الموجودة في لغة C#، والتي تُعلن عن الثوابت والدوال والرموز الأخرى في وقت الترجمة. ^{[ 24 ]} وبالتالي فهي تُعادل بشكل أساسي ما هو constexprموجود في لغتي C و C++.

لا تستخدم لغة جافاconst `<C++>`، بل تستخدم `<C++>` final، والتي يمكن تطبيقها على تعريفات "المتغيرات" المحلية، وتُطبق على المعرّف وليس النوع. ولها استخدام مختلف في البرمجة الكائنية لأعضاء الكائن، وهو أصل التسمية. تعتبر مواصفات لغة جافا `<C++>` constكلمة محجوزة - أي لا يمكن استخدامها كمعرّف متغير - لكنها لا تُسند إليها أي دلالات: فهي كلمة محجوزة (لا يمكن استخدامها في المعرّفات) ولكنها ليست كلمة مفتاحية (ليس لها معنى خاص). أُدرجت الكلمة المفتاحية `<C++>` كوسيلة لمترجمات جافا لاكتشاف الاستخدام غير الصحيح لكلمات C++ المفتاحية والتحذير منه. ^{[ 25 ]} يوجد طلب تحسين لتنفيذ constهذه الخاصية في عملية مجتمع جافا ، ولكن تم إغلاقه في عام 2005 على أساس أنه من المستحيل تنفيذه بطريقة متوافقة مع الإصدارات السابقة. ^{[ 26 ]}

كان للغة Ada 83 المعاصرة مفهوم الكائن الثابت والكلمة constantالمفتاحية، ^{[ 27 ] [ e ]} حيث كانت معلمات الإدخال ومعلمات الحلقة ثابتة ضمنيًا. هنا، constantتُعدّ خاصية الكائن، وليست خاصية النوع.

تحتوي لغة جافا سكريبتconst على تعريف يُحدد متغيرًا بنطاق كتلة لا يمكن إعادة تعيينه أو إعادة تعريفه. يُحدد هذا التعريف مرجعًا للقراءة فقط لمتغير لا يمكن إعادة تعريفه، ولكن في بعض الحالات قد تتغير قيمة المتغير نفسه، كما لو كان المتغير يُشير إلى كائن وتم تغيير إحدى خصائصه. ^{[ 28 ]}

• constexpr
• مهمة واحدة
• يقيد
• تسمية المؤشرات

• "الدقة الثابتة" بقلم هيرب سوتر
• "التحسين المستمر؟" بقلم هيرب سوتر
• الأسئلة الشائعة المختصرة حول لغة C++: صحة الثوابت بقلم مارشال كلاين
• القسم " استبدال القيم " من الكتاب الإلكتروني المجاني " التفكير بلغة C++" للمؤلف بروس إيكل
• "هنا شرطي، وهناك شرطي" بقلم والتر برايت
• "الثوابت والثوابت" من مواصفات لغة البرمجة D، الإصدار 2 (تجريبي)