Const (computer programming)
કેટલીક પ્રોગ્રામિંગ ભાષાઓમાં, કોન્સ્ટ એ ક્વોલિફાયર પ્રકાર છે (ડેટા પ્રકાર પર લાગુ કરાયેલ મુખ્ય શબ્દ) જે સૂચવે છે કે ડેટા ફક્ત વાંચવા માટે છે. જ્યારે આનો ઉપયોગ સ્થિરાંકોને જાહેર કરવા માટે થઈ શકે છે, ત્યારે સી કુટુંબની ભાષાઓમાં પ્રકારનો ભાગ બનવામાં અન્ય ભાષાઓમાં સમાન રચનાઓથી અલગ છે, અને આમ પોઇન્ટર, સંદર્ભો, સંયુક્ત ડેટા પ્રકારો અને પ્રકાર-તપાસ સાથે જોડવામાં આવે ત્યારે તે જટિલ વર્તન ધરાવે છે. અન્ય ભાષાઓમાં, ડેટા એક જ મેમરી સ્થાનમાં નથી, પરંતુ દરેક ઉપયોગ પર સંકલન સમયે નકલ કરવામાં આવે છે. તેનો ઉપયોગ કરતી ભાષાઓમાં સી, સી + +, ડી, જાવાસ્ક્રિપ્ટ, જુલિયા અને રસ્ટનો સમાવેશ થાય છે. પરિચય જ્યારે ઓબ્જેક્ટ ઘોષણામાં લાગુ કરવામાં આવે છે, ત્યારે તે સૂચવે છે કે ઓબ્જેક્ટ સતત છેઃ ચલથી વિપરીત તેનું મૂલ્ય બદલાઈ શકશે નહીં. આ મૂળભૂત ઉપયોગ-અચળાંકો જાહેર કરવા માટે-અન્ય ઘણી ભાષાઓમાં સમાનતા ધરાવે છે. જો કે, અન્ય ભાષાઓથી વિપરીત, ભાષાઓના સી પરિવારમાં કોન્સ્ટ એ પ્રકારનો ભાગ છે, ઑબ્જેક્ટનો ભાગ નથી. ઉદાહરણ તરીકે, C માં, પૂર્ણાંક કોન્સ્ટ પ્રકારનો પદાર્થ x જાહેર કરે છે-સ્થિરાંક એ પ્રકારનો ભાગ છે, જાણે કે તે "(પૂર્ણાંક કોન્સ્ટ) x" નું પદચ્છેદન કરવામાં આવ્યું હોય-જ્યારે Ada માં, પૂર્ણાંક પ્રકારનો અચળાંક (એક પ્રકારનો પદાર્થ) X જાહેર કરે છેઃ અચળાંક એ પદાર્થનો ભાગ છે, પરંતુ પ્રકારનો ભાગ નથી. આના બે સૂક્ષ્મ પરિણામો છે. પ્રથમ, કોન્સ્ટને વધુ જટિલ પ્રકારનાં ભાગો પર લાગુ કરી શકાય છે-ઉદાહરણ તરીકે, પૂર્ણાંક કોન્સ્ટ * કોન્સ્ટ x; સ્થિર પૂર્ણાંક માટે સ્થિર નિર્દેશક જાહેર કરે છે, જ્યારે પૂર્ણાંક કોન્સ્ટ * x; સ્થિર પૂર્ણાંક માટે ચલ નિર્દેશક જાહેર કરે છે, અને પૂર્ણાંક * કોન્સ્ટ x; ચલ પૂર્ણાંક માટે સ્થિર નિર્દેશક જાહેર કરે છે. બીજું, કારણ કે કોન્સ્ટ એ પ્રકારનો ભાગ છે, તે પ્રકાર-તપાસના ભાગ રૂપે મેળ ખાતો હોવો જોઈએ. ઉદાહરણ તરીકે, નીચેનો કોડ અમાન્ય છેઃ રદબાતલ f (પૂર્ણાંક અને x);// પૂર્ણાંક અચળાંક i; f (i); કારણ કે f ની દલીલ ચલ પૂર્ણાંક હોવી જોઈએ, પરંતુ i એ અચળ પૂર્ણાંક છે. આ મેળ એ કાર્યક્રમની ચોકસાઈનું એક સ્વરૂપ છે, અને તેને કોન્સ્ટ-કરેક્ટનેસ તરીકે ઓળખવામાં આવે છે. આ કરાર દ્વારા પ્રોગ્રામિંગના એક સ્વરૂપને મંજૂરી આપે છે, જ્યાં કાર્યો તેમના પ્રકાર સહીના ભાગ રૂપે સ્પષ્ટ કરે છે કે શું તેઓ તેમની દલીલોમાં ફેરફાર કરે છે કે નહીં, અને તેમનું વળતર મૂલ્ય સુધારી શકાય તેવું છે કે નહીં. આ પ્રકાર-તપાસ મુખ્યત્વે નિર્દેશકો અને સંદર્ભોમાં રસ ધરાવે છે-પૂર્ણાંકો જેવા મૂળભૂત મૂલ્ય પ્રકારો માટે નહીં-પણ સંયુક્ત ડેટા પ્રકારો અથવા કન્ટેનર જેવા ટેમ્પલેટેડ પ્રકારો માટે પણ. તે એ હકીકત દ્વારા છુપાવવામાં આવે છે કે પ્રકાર બળજબરી (ગર્ભિત પ્રકારનું રૂપાંતરણ) અને C કૉલ-બાય-વેલ્યુ (C + + અને D ક્યાં તો કૉલ-બાય-વેલ્યુ અથવા કૉલ-બાય-રેફરન્સ છે) ને કારણે કોન્સ્ટને ઘણીવાર અવગણવામાં આવે છે. પરિણામ કોન્સ્ટ-નેસના વિચારનો અર્થ એ નથી કે જે ચલ કમ્પ્યુટર મેમરીમાં સંગ્રહિત છે તે અનરિથેબલ છે. તેના બદલે, કોન્સ્ટ-નેસ એ સંકલન-સમયની રચના છે જે સૂચવે છે કે પ્રોગ્રામરે શું કરવું જોઈએ, જરૂરી નથી કે તેઓ શું કરી શકે. જો કે, નોંધ લો કે પૂર્વવ્યાખ્યાયિત માહિતીના કિસ્સામાં (જેમ કે ચાર કોન્સ્ટ * શબ્દમાળા અક્ષરો), સી કોન્સ્ટ ઘણીવાર અનરિથેબલ હોય છે. જ્યારે પ્રોગ્રામ ચાલી રહ્યો હોય ત્યારે અચળાંક તેનું મૂલ્ય બદલતો નથી, જ્યારે પ્રોગ્રામ ચાલી રહ્યો હોય ત્યારે અચળાંક જાહેર કરાયેલ પદાર્થ ખરેખર તેનું મૂલ્ય બદલી શકે છે. એક સામાન્ય ઉદાહરણ ડિજિટલ ઇનપુટની વર્તમાન સ્થિતિ જેવી એમ્બેડેડ સિસ્ટમોમાં ફક્ત વાંચવા માટેના રજિસ્ટર છે. ડિજિટલ ઇનપુટ્સ માટેના ડેટા રજિસ્ટરને ઘણીવાર સ્થિર અને અસ્થિર તરીકે જાહેર કરવામાં આવે છે. આ રજિસ્ટરની સામગ્રી પ્રોગ્રામ દ્વારા કંઇ પણ કર્યા વિના (અસ્થિર) બદલાઈ શકે છે પરંતુ તમે તેમને (સ્થિર) પણ લખશો નહીં. અન્ય ઉપયોગો વધુમાં, એક (બિન-સ્થિર) સભ્ય-કાર્યને સ્થિર તરીકે જાહેર કરી શકાય છે. આ કિસ્સામાં, આવા કાર્યની અંદર આ નિર્દેશક માત્ર ઓબ્જેક્ટ ટાઇપ * ને બદલે ઓબ્જેક્ટ ટાઇપ કોન્સ્ટ * પ્રકારનો હોય છે. આનો અર્થ એ છે કે આ ઓબ્જેક્ટ માટેના નોન-કોન્સ્ટ ફંક્શન્સને આવા ફંક્શનની અંદરથી કૉલ કરી શકાતા નથી, ન તો સભ્ય ચલોમાં ફેરફાર કરી શકાય છે. સી + + માં, સભ્ય ચલને પરિવર્તનીય તરીકે જાહેર કરી શકાય છે, જે સૂચવે છે કે આ પ્રતિબંધ તેને લાગુ પડતો નથી. કેટલાક કિસ્સાઓમાં, આ ઉપયોગી થઈ શકે છે, ઉદાહરણ તરીકે કેશીંગ, સંદર્ભ ગણતરી અને ડેટા સુમેળ સાથે. આ કિસ્સાઓમાં, પદાર્થનો તાર્કિક અર્થ (સ્થિતિ) બદલાતો નથી, પરંતુ પદાર્થ ભૌતિક રીતે સ્થિર નથી કારણ કે તેની બિટવાઇઝ રજૂઆત બદલાઈ શકે છે. વાક્યરચના સી, સી + + અને ડીમાં, વપરાશકર્તા દ્વારા વ્યાખ્યાયિત ડેટા સહિત તમામ ડેટા પ્રકારોને કોન્સ્ટ જાહેર કરી શકાય છે, અને કોન્સ્ટ-કરેક્ટનેસ સૂચવે છે કે જ્યાં સુધી તેમાં ફેરફાર કરવાની જરૂર ન હોય ત્યાં સુધી તમામ ચલ અથવા પદાર્થોને આ રીતે જાહેર કરવા જોઈએ. કોન્સ્ટનો આ પ્રકારનો સક્રિય ઉપયોગ મૂલ્યોને "સમજવા, ટ્રેક કરવા અને તેના વિશે તર્ક કરવા માટે સરળ બનાવે છે", અને આમ તે કોડની વાંચનીયતા અને સમજણમાં વધારો કરે છે અને ટીમોમાં કામ કરવા અને કોડ જાળવવાનું સરળ બનાવે છે કારણ કે તે મૂલ્યના હેતુપૂર્વકના ઉપયોગ વિશેની માહિતીનો સંચાર કરે છે. કોડ વિશે તર્ક કરતી વખતે આ કમ્પાઇલર તેમજ વિકાસકર્તાને મદદ કરી શકે છે. તે વધુ કાર્યક્ષમ કોડ બનાવવા માટે ઓપ્ટિમાઇઝિંગ કમ્પાઇલરને પણ સક્ષમ કરી શકે છે. સરળ ડેટા પ્રકારો સરળ નોન-પોઇન્ટર ડેટા પ્રકારો માટે, કોન્સ્ટ ક્વોલિફાયર લાગુ કરવું સરળ છે. તે ઐતિહાસિક કારણોસર કેટલાક પ્રકારોની બંને બાજુએ જઈ શકે છે (ઉદાહરણ તરીકે, કોન્સ્ટ ચાર ફૂ = 'એ'; એ ચાર કોન્સ્ટ ફૂ = 'એ'; ની સમકક્ષ છે). કેટલાક અમલીકરણ પર, કોન્સ્ટનો બે વાર ઉપયોગ કરવો (ઉદાહરણ તરીકે, કોન્સ્ટ ચાર કોન્સ્ટ અથવા ચાર કોન્સ્ટ કોન્સ્ટ) ચેતવણી પેદા કરે છે પરંતુ ભૂલ નહીં. પોઇન્ટર અને સંદર્ભો પોઇન્ટર અને સંદર્ભ પ્રકારો માટે, કોન્સ્ટનો અર્થ વધુ જટિલ છે-ક્યાં તો પોઇન્ટર પોતે, અથવા જે મૂલ્ય તરફ નિર્દેશ કરવામાં આવે છે, અથવા બંને, કોન્સ્ટ હોઈ શકે છે. વધુમાં, વાક્યરચના ગૂંચવણભરી હોઈ શકે છે. પોઇન્ટરને લખી શકાય તેવા મૂલ્ય માટે કોન્સ્ટ પોઇન્ટર તરીકે, અથવા કોન્સ્ટ મૂલ્ય માટે લખી શકાય તેવા પોઇન્ટર તરીકે, અથવા કોન્સ્ટ મૂલ્ય માટે કોન્સ્ટ પોઇન્ટર તરીકે જાહેર કરી શકાય છે. કોન્સ્ટ પોઇન્ટરને તેને શરૂઆતમાં સોંપવામાં આવેલી વસ્તુથી અલગ વસ્તુ તરફ નિર્દેશ કરવા માટે ફરીથી સોંપી શકાતું નથી, પરંતુ તેનો ઉપયોગ તે જે મૂલ્ય તરફ નિર્દેશ કરે છે તેમાં ફેરફાર કરવા માટે થઈ શકે છે (જેને પોઇન્ટી કહેવાય છે). C + + માં સંદર્ભ ચલ એ કોન્સ્ટ પોઇન્ટર માટે વૈકલ્પિક વાક્યરચના છે. બીજી બાજુ, કોન્સ્ટ ઓબ્જેક્ટના પોઇન્ટરને અન્ય મેમરી સ્થાન (જે સમાન પ્રકારનો અથવા કન્વર્ટિબલ પ્રકારનો ઓબ્જેક્ટ હોવો જોઈએ) તરફ નિર્દેશ કરવા માટે ફરીથી સોંપવામાં આવી શકે છે, પરંતુ તેનો ઉપયોગ તે જે મેમરી તરફ નિર્દેશ કરે છે તેમાં ફેરફાર કરવા માટે કરી શકાતો નથી. કોન્સ્ટ ઓબ્જેક્ટ માટે કોન્સ્ટ પોઇન્ટર પણ જાહેર કરી શકાય છે અને તેનો ઉપયોગ એપોઇન્ટીમાં ફેરફાર કરવા માટે અથવા અન્ય ઓબ્જેક્ટ તરફ નિર્દેશ કરવા માટે ફરીથી સોંપવામાં નહીં આવે. નીચેનો કોડ આ સૂક્ષ્મતાઓને સમજાવે છેઃ શૂન્ય Foo (પૂર્ણાંક * ptr, પૂર્ણાંક કોન્સ્ટ * ptrToConst, પૂર્ણાંક * કોન્સ્ટ કોન્સ્ટપીટીઆર, પૂર્ણાંક કોન્સ્ટ * કોન્સ્ટપીટીઆરટીઓકોન્સ્ટ) {* ptr = 0;// OK: પોઇન્ટેડ ડેટા ptr = null માં ફેરફાર કરે છે;// OK: પોઇન્ટર * ptrToConst = 0 માં ફેરફાર કરે છે;// ભૂલ! પોઇન્ટેડ ટુ ડેટામાં ફેરફાર કરી શકાતો નથી ptrToConst = null;// OK: પોઇન્ટરમાં ફેરફાર કરે છે * સ્થિરાંકPtr = 0;// OK: સૂચિત ડેટામાં ફેરફાર કરે છે સ્થિરાંકPtr = null;// ભૂલ! નિર્દેશકમાં ફેરફાર કરી શકાતો નથી * સ્થિરાંકPrToConst = 0;// ભૂલ! પોઇન્ટેડ ટુ ડેટા કોન્સ્ટપીટરટૂકોન્સ્ટ = એનયુએલએલમાં ફેરફાર કરી શકાતો નથી;// ભૂલ! પોઇન્ટર} સી પરંપરામાં ફેરફાર કરી શકાતો નથી ઘોષણાઓ માટે સામાન્ય સી પરંપરાને અનુસરીને, ઘોષણા ઉપયોગને અનુસરે છે, અને પોઇન્ટરમાં * પોઇન્ટર પર લખવામાં આવે છે, જે ડીરેફરન્સિંગ સૂચવે છે. ઉદાહરણ તરીકે, ઘોષણા int * pttr માં, સંદર્ભિત સ્વરૂપ * pttr એ int છે, જ્યારે સંદર્ભ સ્વરૂપ pttr એ int નો નિર્દેશક છે. આમ કોન્સ્ટ તેની જમણી બાજુએ નામમાં ફેરફાર કરે છે. સી + + પરંપરા તેના બદલે * ને પ્રકાર સાથે સાંકળવા માટે છે, જેમ કે ઇન્ટી * પી. ટી. આર. માં, અને કોન્સ્ટને ડાબી બાજુના પ્રકારમાં ફેરફાર તરીકે વાંચો. આમ "* ptrToConst એ એક પૂર્ણાંક છે" (મૂલ્ય અચળ છે), અથવા "ptrToConst એ એક પૂર્ણાંક અચળાંક છે *" (નિર્દેશક એ અચળ પૂર્ણાંક માટેનું નિર્દેશક છે) તરીકે વાંચી શકાય છે. આમઃ પૂર્ણાંક * ptr;// * ptr એ પૂર્ણાંક મૂલ્ય છે, પૂર્ણાંક * ptrToConst;// ptrToConst એ અચળાંક (પૂર્ણાંકઃ પૂર્ણાંક મૂલ્ય) પૂર્ણાંક * સ્થિરાંક છે;// અચળાંક એ અચળાંક (પૂર્ણાંક *: પૂર્ણાંક નિર્દેશક) પૂર્ણાંક અચળાંક * અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક અચળાંક આમ, તારાની ડાબી બાજુની દરેક વસ્તુને પોઇન્ટેડ પ્રકાર તરીકે ઓળખી શકાય છે અને તારાની જમણી બાજુની દરેક વસ્તુ પોઇન્ટર ગુણધર્મો છે. દાખલા તરીકે, ઉપરના અમારા ઉદાહરણમાં, પૂર્ણાંક કોન્સ્ટ * ને લખી શકાય તેવા નિર્દેશક તરીકે વાંચી શકાય છે જે બિન-લખી શકાય તેવા પૂર્ણાંકનો સંદર્ભ આપે છે, અને પૂર્ણાંક કોન્સ્ટને બિન-લખી શકાય તેવા નિર્દેશક તરીકે વાંચી શકાય છે જે લખી શકાય તેવા પૂર્ણાંકનો સંદર્ભ આપે છે. વધુ સામાન્ય નિયમ કે જે તમને જટિલ ઘોષણાઓ અને વ્યાખ્યાઓને સમજવામાં મદદ કરે છે તે આ રીતે કામ કરે છેઃ ઓળખકર્તાને શોધો કે જેની ઘોષણાને તમે સમજવા માંગો છો, જ્યાં સુધી શક્ય હોય ત્યાં સુધી જમણી બાજુએ વાંચો (એટલે કે, ઘોષણાના અંત સુધી અથવા આગામી બંધ કૌંસમાં, જે પણ પહેલા આવે) અને જ્યાંથી તમે શરૂઆત કરી હતી ત્યાં સુધી પાછળની તરફ વાંચો (એટલે કે, ઘોષણાની શરૂઆત સુધી અથવા અગાઉના પગલામાં મળેલા બંધ કૌંસ સાથે મેળ ખાતી ખુલ્લી કૌંસમાં) જ્યારે તમે તમારી ઘોષણાની શરૂઆતમાં પહોંચી ગયા હોવ. જો નહીં, તો પગલું 2 પર ચાલુ રાખો, બંધ કૌંસની બહાર જે છેલ્લે મેળ ખાતી હતી. અહીં એક ઉદાહરણ છેઃ ડાબી બાજુએ વાંચતી વખતે, તે મહત્વનું છે કે તમે જમણી બાજુથી ડાબી બાજુએ તત્વો વાંચો. તેથી એક ઇન્ટ કોન્સ્ટ * કોન્સ્ટ ઇન્ટ માટે નિર્દેશક બને છે અને ઇન્ટ માટે કોન્સ્ટ નિર્દેશક નહીં. કેટલાક કિસ્સાઓમાં C/C + + કોન્સ્ટ મુખ્ય શબ્દને પ્રકારની ડાબી બાજુએ મૂકવાની મંજૂરી આપે છે. અહીં કેટલાક ઉદાહરણો છેઃ કોન્સ્ટ ઇન્ટ * પી. ટી. આર. ટુ કોન્સ્ટ;// સમાનઃ ઇન્ટ કોન્સ્ટ * પી. ટી. આર. ટુ કોન્સ્ટ;// સમાનઃ ઇન્ટ કોન્સ્ટ * કોન્સ્ટ કોન્સ્ટપી. ટી. આર. ટુ કોન્સ્ટ;// સમાનઃ ઇન્ટ કોન્સ્ટ * કોન્સ્ટ કૉન્સ્ટપી. ટી. આર. ટુ કોન્સ્ટ જોકે સી/સી + + આવી વ્યાખ્યાઓને મંજૂરી આપે છે (જે ડાબેથી જમણે વ્યાખ્યાઓ વાંચતી વખતે અંગ્રેજી ભાષા સાથે નજીકથી મેળ ખાય છે), કમ્પાઇલર હજી પણ ઉપરોક્ત પ્રક્રિયા અનુસાર વ્યાખ્યાઓ વાંચે છેઃ જમણેથી ડાબે. પરંતુ જે અચળ હોવું જોઈએ તે પહેલાં અચળાંક મૂકવાથી તમે જે લખવાનો ઇરાદો ધરાવો છો અને કમ્પાઇલર જે નક્કી કરે છે તે તમે લખો છો તે વચ્ચે ઝડપથી મેળ ખાતો નથી. પોઇન્ટર માટેના પોઇન્ટરને ધ્યાનમાં લોઃ int * * ptr;// એક પોઇન્ટર માટે એક પોઇન્ટર માટે એક પોઇન્ટર માટે એક પોઇન્ટર માટે એક પોઇન્ટર માટે એક પોઇન્ટર માટે સતત int મૂલ્ય// (એક પોઇન્ટર માટે એક પોઇન્ટર માટે એક પોઇન્ટર માટે એક પોઇન્ટર માટે એક પોઇન્ટર માટે એક પોઇન્ટર માટે એક પોઇન્ટર માટે એક પોઇન્ટર માટે એક પોઇન્ટર માટે એક પોઇન્ટર માટે એક પોઇન્ટર માટે એક પોઇન્ટર માટે એક પોઇન્ટર માટે એક પોઇન્ટર માટે એક પોઇન્ટર માટે એક પોઇન્ટર માટે એક પોઇન્ટર માટે એક પોઇન્ટર માટે એક પોઇન્ટર માટે એક પોઇન્ટર માટે એક પોઇન્ટર માટે એક પોઇન્ટર માટે પોઇન્ટર માટે પોઇન્ટર માટે પોઇન્ટર માટે પોઇન્ટર માટે પોઇન્ટર માટે પોઇન્ટર માટે પોઇન્ટર માટે પોઇન્ટર માટે પોઇન્ટર માટે પોઇન્ટર માટે પોઇન્ટર માટે પોઇન્ટર માટે પોઇન્ટર માટે પોઇન્ટર માટે પોઇન્ટર માટે પોઇન્ટર માટે પોઇન્ટર માટે પોઇન્ટર માટે પોઇન્ટર માટે પોઇન્ટર માટે પોઇન્ટર માટે પોઇન્ટર પોઇન્ટર પ્રતીકને પ્રકાર સાથે જોડવું મુશ્કેલ છે, કારણ કે તે ભારપૂર્વક પોઇન્ટર પ્રકાર સૂચવે છે, જે કેસ નથી. અહીં કેટલાક ઉદાહરણો છેઃ પૂર્ણાંક * a;/* લખોઃ */પૂર્ણાંક * a;// a એ પૂર્ણાંક * a, b માટે નિર્દેશક છે;// કોન્ફ્યુઝિંગ/* લખોઃ */પૂર્ણાંક * a, b;// a એ પૂર્ણાંક માટે નિર્દેશક છે,// પરંતુ b એ માત્ર પૂર્ણાંક * a, * b છે;// UGLY: a અને b બંને પૂર્ણાંક/* લખવા માટે નિર્દેશક છેઃ */પૂર્ણાંક * a, * b; બાર્ન સ્ટ્રોસ્ટ્રપના FAQ આ સમસ્યાને ટાળવા માટે, જો C + + પરંપરાનો ઉપયોગ કરવામાં આવે તો રેખા દીઠ માત્ર એક ચલ જાહેર કરવાની ભલામણ કરે છે. એ જ વિચારણાઓ સંદર્ભો અને મૂલ્ય સંદર્ભોને વ્યાખ્યાયિત કરવા માટે લાગુ પડે છેઃ પૂર્ણાંક વાર = 22; પૂર્ણાંક કોન્સ્ટ અને રિફટોકૉન્સ્ટ = વાર;// ઓકે પૂર્ણાંક કોન્સ્ટ અને રિફ 2 = વાર, રિફ 3 = વાર;// કોન્ફ્યુઝિંગઃ// રિફ 2 એ સંદર્ભ છે, પરંતુ રિફ 3 એ નથીઃ// રિફ 3 એ// વારના મૂલ્ય પૂર્ણાંક અને કન્સ્ટ્રેફ = વાર સાથે પ્રારંભ કરેલ સ્થિરાંક છે;// ઇઆરઆરઓઆરઃ કારણ કે સંદર્ભો કોઈપણ રીતે બદલી શકતા નથી. //C + +: પૂર્ણાંક & & rref = પૂર્ણાંક (5), મૂલ્ય = 10;// કન્ફ્યૂઝિંગઃ// rref એ મૂલ્ય સંદર્ભ છે, પરંતુ મૂલ્ય// માત્ર પૂર્ણાંક છે. / * લખોઃ */int & & rref = int (5), મૂલ્ય = 10; પોઇન્ટર પર બહુ-પરિમાણીય એરે અને સંદર્ભો (અથવા પોઇન્ટર) નો ઉપયોગ કરતી વખતે વધુ જટિલ ઘોષણાઓનો સામનો કરવો પડે છે. જો કે કેટલીકવાર એવી દલીલ કરવામાં આવે છે કે આવી ઘોષણાઓ ગૂંચવણભરી અને ભૂલ-સંભવિત હોય છે અને તેથી તેને ટાળવી જોઈએ અથવા ઉચ્ચ-સ્તરની રચનાઓ દ્વારા બદલવી જોઈએ, આ વિભાગની ટોચ પર વર્ણવેલ પ્રક્રિયાનો ઉપયોગ હંમેશા અસ્પષ્ટતા અથવા મૂંઝવણ રજૂ કર્યા વિના કરી શકાય છે. પરિમાણો અને ચલ કોન્સ્ટને કાર્ય પરિમાણો અને ચલ (વૈશ્વિક અથવા સ્થાનિક સહિત સ્થિર અથવા સ્વચાલિત) બંને પર જાહેર કરી શકાય છે. અર્થઘટન ઉપયોગો વચ્ચે બદલાય છે. સ્થિર સ્થિર ચલ (વૈશ્વિક ચલ અથવા સ્થિર સ્થાનિક ચલ) એ સ્થિરાંક છે, અને તેનો ઉપયોગ ગાણિતિક સ્થિરાંકો જેવા ડેટા માટે થઈ શકે છે, જેમ કે ડબલ સ્થિરાંકો PI = 3.14159-વાસ્તવિક રીતે લાંબા, અથવા એકંદર સંકલન-સમય પરિમાણો. કોન્સ્ટ ઓટોમેટિક વેરિયેબલ (નોન-સ્ટેટિક લોકલ વેરિયેબલ) નો અર્થ એ છે કે એક સોંપણી થઈ રહી છે, જો કે દરેક વખતે અલગ મૂલ્યનો ઉપયોગ કરી શકાય છે, જેમ કે ઇન્ટ કોન્સ્ટ x _ સ્ક્વેર્ડ = x * x. પાસ-બાય-રેફરન્સમાં કોન્સ્ટ પેરામીટરનો અર્થ એ છે કે સંદર્ભિત મૂલ્યમાં ફેરફાર કરવામાં આવ્યો નથી-તે કરારનો એક ભાગ છે-જ્યારે પાસ-બાય-વેલ્યુમાં કોન્સ્ટ પેરામીટર (અથવા પોતે પોઇન્ટર, પાસ-બાય-રેફરન્સમાં) ઇન્ટરફેસમાં કંઈપણ ઉમેરતું નથી (કારણ કે મૂલ્યની નકલ કરવામાં આવી છે), પરંતુ સૂચવે છે કે આંતરિક રીતે, ફંક્શન પેરામીટરની સ્થાનિક નકલમાં ફેરફાર કરતું નથી (તે એક જ સોંપણી છે). આ કારણોસર, કેટલાક લોકો માત્ર પાસ-બાય-રેફરન્સ માટે પરિમાણોમાં કોન્સ્ટનો ઉપયોગ કરવાની તરફેણ કરે છે, જ્યાં તે કરારમાં ફેરફાર કરે છે, પરંતુ પાસ-બાય-વેલ્યુ માટે નહીં, જ્યાં તે અમલીકરણનો ખુલાસો કરે છે. સી + + પદ્ધતિઓ વપરાશકર્તા-નિર્ધારિત પ્રકારો (માળખાઓ અને વર્ગો) માટે કરાર અભિગમ દ્વારા ડિઝાઇનનો લાભ લેવા માટે, જેમાં પદ્ધતિઓ તેમજ સભ્ય ડેટા હોઈ શકે છે, જો તેઓ ઑબ્જેક્ટના ડેટા સભ્યોમાં ફેરફાર ન કરે તો પ્રોગ્રામર ઇન્સ્ટન્સ પદ્ધતિઓને કોન્સ્ટ તરીકે ટેગ કરી શકે છે. દાખલા પદ્ધતિઓ માટે કોન્સ્ટ ક્વોલિફાયર લાગુ કરવું એ કોન્સ્ટ-ચોકસાઈ માટે એક આવશ્યક સુવિધા છે, અને તે જાવા અને સી #જેવી અન્ય ઘણી ઓબ્જેક્ટ-ઓરિએન્ટેડ ભાષાઓમાં અથવા માઇક્રોસોફ્ટની સી + +/સીએલઆઈ અથવા સી + + માટે મેનેજ્ડ એક્સ્ટેન્શન્સમાં ઉપલબ્ધ નથી. જ્યારે કોન્સ્ટ પદ્ધતિઓને કોન્સ્ટ અને નોન-કોન્સ્ટ ઓબ્જેક્ટ્સ દ્વારા સમાન રીતે બોલાવી શકાય છે, ત્યારે નોન-કોન્સ્ટ પદ્ધતિઓ ફક્ત નોન-કોન્સ્ટ ઓબ્જેક્ટ્સ દ્વારા જ લાગુ કરી શકાય છે. ઇન્સ્ટન્સ મેથડ પર કોન્સ્ટ મોડિફાયર "આ" પોઇન્ટર દ્વારા નિર્દેશિત ઓબ્જેક્ટને લાગુ પડે છે, જે તમામ ઇન્સ્ટન્સ મેથડ્સ પર પસાર કરાયેલ એક ગર્ભિત દલીલ છે. આમ કોન્સ્ટ પદ્ધતિઓ હોવી એ અન્ય દલીલોની જેમ જ ગર્ભિત "આ" નિર્દેશક દલીલમાં કોન્સ્ટ-ચોકસાઈ લાગુ કરવાની એક રીત છે. આ ઉદાહરણ સમજાવે છેઃ વર્ગ C {પૂર્ણાંક i; સાર્વજનિકઃ પૂર્ણાંક મેળવો () અચલાંક// નોંધ કરો "અચલાંક" ટેગ {વળતર i;} શૂન્યાંક સેટ (પૂર્ણાંક j)// નોંધ કરો "અચલાંક" {i = j;}} નો અભાવ; શૂન્યાંક ફૂ (C & બિન-અચલાંક, C અચલાંક અને અચલાંક) {પૂર્ણાંક y = nonConstC.Get ();// OK પૂર્ણાંક x = constC.Get ();// OK: મેળવો () સ્થિરાંક nonConstC.Set (10) છે;// OK: બિન-અચલાંક એ સુધારી શકાય તેવું છે constC.Set (10);// ભૂલ! સેટ () એ નોન-કોન્સ્ટ પદ્ધતિ છે અને કોન્સ્ટસી એ કોન્સ્ટ-ક્વોલિફાઇડ ઓબ્જેક્ટ છે} ઉપરોક્ત કોડમાં, "આ" પોઇન્ટરથી સેટ () માં "C * કોન્સ્ટ" પ્રકાર છે; જ્યારે "આ" પોઇન્ટરથી ગેટ () માં "C કોન્સ્ટ * કોન્સ્ટ" પ્રકાર છે, જે સૂચવે છે કે પદ્ધતિ "આ" પોઇન્ટર દ્વારા તેના ઓબ્જેક્ટમાં ફેરફાર કરી શકતી નથી. મોટેભાગે પ્રોગ્રામર બંને પ્રકારના કોલ કરનારાઓને સમાવવા માટે વર્ગમાં સમાન નામ (પરંતુ સંભવતઃ તદ્દન અલગ ઉપયોગો) સાથે કોન્સ્ટ અને નોન-કોન્સ્ટ બંને પદ્ધતિ પૂરી પાડશે. ધ્યાનમાં લોઃ વર્ગ MyArray {int ડેટા [100]; સાર્વજનિકઃ int & Get (int i) {રીટર્ન ડેટા [i];} int સ્થિરાંક & Get (int i) સ્થિરાંક {રીટર્ન ડેટા [i];}}; રદબાતલ Foo (MyArray & array, MyArray સ્થિરાંક & સ્થિરાંક) {// એરે ઘટકનો સંદર્ભ મેળવો// અને તેના સંદર્ભિત મૂલ્યમાં ફેરફાર કરો. array.Get (5) = 42;// ઠીક છે! (કૉલ્સઃ int & MyArray:: Get (int)) constArray.Get (5) = 42;// ભૂલ! (કૉલ્સઃ ઇન્ટ કોન્સ્ટ અને માયએરેઃઃ ગેટ (ઇન્ટ) કોન્સ્ટ)} કૉલિંગ ઓબ્જેક્ટનું કોન્સ્ટ-નેસ નક્કી કરે છે કે માયએરેઃઃ ગેટ () નું કયું વર્ઝન બોલાવવામાં આવશે અને આમ કોલ કરનારને એવો સંદર્ભ આપવામાં આવ્યો છે કે નહીં કે જેની સાથે તે હેરફેર કરી શકે અથવા ફક્ત ઓબ્જેક્ટમાં ખાનગી ડેટાનું નિરીક્ષણ કરી શકે. બંને પદ્ધતિઓ તકનીકી રીતે અલગ અલગ સહીઓ ધરાવે છે કારણ કે તેમના "આ" પોઇન્ટરના વિવિધ પ્રકારો હોય છે, જે કમ્પાઇલરને યોગ્ય પસંદ કરવાની મંજૂરી આપે છે. (માત્ર મૂલ્ય દ્વારા પૂર્ણાંક પરત કરવાને બદલે, પૂર્ણાંક માટે સ્થિરાંક સંદર્ભ પરત કરવો, બીજી પદ્ધતિમાં ઓવરકિલ હોઈ શકે છે, પરંતુ તે જ તકનીકનો ઉપયોગ પ્રમાણભૂત નમૂના પુસ્તકાલયની જેમ મનસ્વી પ્રકારો માટે થઈ શકે છે.) સી અને સી + + માં શુદ્ધ કોન્સ્ટ-ચોકસાઈ માટે ઘણી છટકબારીઓ છે. તેઓ મુખ્યત્વે હાલના કોડ સાથે સુસંગતતા માટે અસ્તિત્વ ધરાવે છે. પ્રથમ, જે ફક્ત સી + + ને લાગુ પડે છે, તે કોન્સ્ટ કાસ્ટનો ઉપયોગ છે, જે પ્રોગ્રામરને કોન્સ્ટ ક્વોલિફાયરને છીનવી લેવાની મંજૂરી આપે છે, જે કોઈપણ ઓબ્જેક્ટને સુધારી શકાય તેવું બનાવે છે. ક્વોલિફાયરને દૂર કરવાની જરૂરિયાત ત્યારે ઊભી થાય છે જ્યારે હાલના કોડ અને લાઈબ્રેરીઓનો ઉપયોગ કરવામાં આવે છે જેમાં ફેરફાર કરી શકાતો નથી પરંતુ જે નિશ્ચિત રીતે સાચા નથી. દાખલા તરીકે, આ કોડને ધ્યાનમાં લોઃ// પ્રોટોટાઇપ એવા કાર્ય માટે કે જેને આપણે બદલી શકતા નથી પરંતુ જે// આપણે જાણીએ છીએ તે પાસ કરેલા પોઇન્ટીમાં ફેરફાર કરતું નથી. લાયબ્રેરીફંકને રદ કરો (પૂર્ણાંક * પી. ટી. આર., પૂર્ણાંક કદ); કૉલ લાઈબ્રેરીફંકને રદ કરો (પૂર્ણાંક * પી. ટી. આર., પૂર્ણાંક કદ) {લાઈબ્રેરીફંક (પૂર્ણાંક, કદ);// ભૂલ! ડ્રોપ્સ કોન્સ્ટ ક્વોલિફાયર ઇન્ટ * નોનકોન્સ્ટપીટીઆર = કોન્સ્ટ કાસ્ટ <ઇન્ટી *> (પીટીઆર);// સ્ટ્રિપ ક્વોલિફાયર લાઇબ્રેરીફંક (નોનકોન્સ્ટપીટીઆર, કદ);// ઓકે) જો કે, કોન્સ્ટ કાસ્ટના માધ્યમથી કોન્સ્ટ જાહેર કરાયેલ ઓબ્જેક્ટને સુધારવાનો કોઈપણ પ્રયાસ આઇએસઓ સી + + સ્ટાન્ડર્ડ અનુસાર અવ્યાખ્યાયિત વર્તનમાં પરિણમે છે. ઉપરના ઉદાહરણમાં, જો પી. ટી. આર. વૈશ્વિક, સ્થાનિક અથવા સભ્ય ચલને કોન્સ્ટ તરીકે જાહેર કરે છે, અથવા નવા ઇન્ટી કોન્સ્ટ દ્વારા ઢગલા પર ફાળવેલ ઑબ્જેક્ટનો સંદર્ભ આપે છે, તો કોડ ત્યારે જ સાચો છે જ્યારે લાઇબ્રેરીફંક ખરેખર પી. ટી. આર. દ્વારા નિર્દેશિત મૂલ્યમાં ફેરફાર કરતું નથી. સી ભાષામાં છટકબારીની જરૂર છે કારણ કે ચોક્કસ પરિસ્થિતિ અસ્તિત્વમાં છે. સ્થિર સંગ્રહ સમયગાળો ધરાવતા ચલને પ્રારંભિક મૂલ્ય સાથે વ્યાખ્યાયિત કરવાની મંજૂરી છે. જો કે, આરંભકર્તા માત્ર શબ્દમાળા અચળાંકો અને અન્ય અક્ષરો જેવા અચળાંકોનો ઉપયોગ કરી શકે છે, અને તેને ચલ નામો જેવા બિન-અચળાં તત્વોનો ઉપયોગ કરવાની મંજૂરી નથી, પછી ભલે તે આરંભકર્તા તત્વોને અચળાં જાહેર કરવામાં આવે કે નહીં, અથવા સ્થિર અવધિ ચલને અચળાં જાહેર કરવામાં આવી રહ્યું છે કે નહીં. સ્થિર સંગ્રહ સમયગાળો ધરાવતા કોન્સ્ટ ચલને શરૂ કરવાની બિન-પોર્ટેબલ રીત છે. પછીની સોંપણીની ડાબી બાજુએ કાળજીપૂર્વક ટાઇપકાસ્ટ બનાવીને, કોન્સ્ટ ચલને લખી શકાય છે, જે કોન્સ્ટ લક્ષણને અસરકારક રીતે દૂર કરે છે અને તેને અન્ય કોન્સ્ટ ચલ જેવા બિન-સ્થિર ઘટકો સાથે 'પ્રારંભ' કરે છે. કોન્સ્ટ ચલમાં આ રીતે લખવું ઈરાદાપૂર્વક કામ કરી શકે છે, પરંતુ તે અવ્યાખ્યાયિત વર્તનનું કારણ બને છે અને કોન્સ્ટ-ચોકસાઈને ગંભીરતાપૂર્વક વિરોધાભાસી બનાવે છેઃ સાઈઝ _ ટી કોન્સ્ટ બફરસાઇઝ = 8 * 1024; સાઈઝ _ ટી કોન્સ્ટ યુઝરટેક્સ્ટબફરસાઇઝ;// પ્રારંભિક મૂલ્ય કોન્સ્ટ બફરસાઇઝ પર આધાર રાખે છે, અહીં પ્રારંભ કરી શકાતો નથી. int સેટઅપયુઝરટેક્સ્ટબોક્સ (ટેક્સ્ટબોક્સ _ ટી * ડિફોલ્ટટેક્સ્ટબોક્સટાઇપ, રેક્ટ _ ટી * ડિફોલ્ટટેક્સ્ટબોક્સલોકેશન) {* (સાઈઝ _ ટી *) અને યુઝરટેક્સ્ટબફરસાઇઝ = બફરસાઇઝ-સાઈઝ ઓફ સ્ટ્રક્ટ (ટેક્સ્ટબોક્સકન્ટ્રોલ્સ);// ચેતવણીઃ કામ કરી શકે છે, પરંતુ સી દ્વારા બાંયધરી આપવામાં આવતી નથી. ખાસ કરીને, ભાષાઓ સૂચવે છે કે સભ્યના નિર્દેશો અને સંદર્ભો તેમના માલિકોની સ્થિરતાના સંદર્ભમાં "છીછરા" છે-એટલે કે, જે પદાર્થ સ્થિર છે તેમાં તમામ સ્થિર સભ્યો છે સિવાય કે સભ્યના નિર્દેશો (અને રેફરી) હજુ પણ પરિવર્તનશીલ છે. ઉદાહરણ તરીકે, આ સી + + કોડને ધ્યાનમાં લોઃ સ્ટ્રક્ટ એસ {ઇન્ટ વેલ; ઇન્ટ * પીટીઆર;}; વોઈડ ફૂ (એસ કોન્સ્ટ એન્ડ એસ) {ઇન્ટ આઇ = 42; <આઇ. ડી. 1> = આઇ;// ભૂલઃ એસ કોન્સ્ટ છે, તેથી વેલ એ કોન્સ્ટ છે <આઇ. ડી. 2> = & આઇ;// ભૂલઃ એસ કોન્સ્ટ છે, તેથી પી. ટી. આર એ * <આઇ. ડી. 2> = આઇ;// ઓ. કે. માટે કોન્સ્ટ પોઇન્ટર છેઃ પી. ટી. આર. દ્વારા નિર્દેશિત ડેટા હંમેશા પરિવર્તનશીલ હોય છે,// જો કે આ ક્યારેક ઇચ્છનીય નથી] જો કે ઑબ્જેક્ટ એસ. એ તેના તમામ સભ્યોને સ્થિર કરે છે, જે તેના તમામ સભ્યોને સ્થિર બનાવે છે, તો <આઇ. ડી. 2> દ્વારા સુલભ પોઇન્ટી હજી પણ સુધારી શકાય છે. આ કારણોસર, મેયર્સ દલીલ કરે છે કે સભ્ય પોઇન્ટર અને સંદર્ભો માટે ડિફોલ્ટ "ડીપ" કોન્સ્ટ-નેસ હોવું જોઈએ, જેને પરિવર્તનીય ક્વોલિફાયર દ્વારા ઓવરરાઇડ કરી શકાય છે જ્યારે પોઇન્ટી કન્ટેનરની માલિકીની નથી, પરંતુ આ વ્યૂહરચના હાલના કોડ સાથે સુસંગતતાના મુદ્દાઓ બનાવશે. આમ, ઐતિહાસિક કારણોસર, આ ખામી સી અને સી + + માં ખુલ્લી રહે છે. પછીની છટકબારીને કોન્સ્ટ-કરેક્ટ ઇન્ટરફેસ પાછળ નિર્દેશકને છુપાવવા માટે વર્ગનો ઉપયોગ કરીને બંધ કરી શકાય છે, પરંતુ આવા વર્ગો કાં તો કોન્સ્ટ ઓબ્જેક્ટમાંથી સામાન્ય નકલ સિમેન્ટિક્સને સમર્થન આપતા નથી (જે સૂચવે છે કે સમાવિષ્ટ વર્ગને સામાન્ય સિમેન્ટિક્સ દ્વારા નકલ કરી શકાતો નથી) અથવા અજાણતા અથવા ઇરાદાપૂર્વકની નકલ દ્વારા કોન્સ્ટ-નેસને દૂર કરવાની મંજૂરી આપીને અન્ય છટકબારીઓને મંજૂરી આપે છે. છેવટે, સી સ્ટાન્ડર્ડ લાઈબ્રેરીમાં કેટલાક કાર્યો C23 પહેલાં કોન્સ્ટ-ચોકસાઈનું ઉલ્લંઘન કરે છે, કારણ કે તેઓ અક્ષરની સ્ટ્રિંગમાં કોન્સ્ટ પોઇન્ટરને સ્વીકારે છે અને તે જ સ્ટ્રિંગના એક ભાગમાં નોન-કોન્સ્ટ પોઇન્ટરને પરત કરે છે. આ કાર્યોમાં એ. એસ. આર. એસ. ટી. આર. અને એ. એસ. આર. સી. આર. નો સમાવેશ થાય છે. સી + + સ્ટાન્ડર્ડ લાઈબ્રેરીના કેટલાક અમલીકરણ, જેમ કે માઇક્રોસોફ્ટે કેટલાક કાર્યોની બે ઓવરલોડ કરેલી આવૃત્તિઓ પ્રદાન કરીને આ ખામીને બંધ કરવાનો પ્રયાસ કર્યો છેઃ "કોન્સ્ટ" સંસ્કરણ અને "નોન-કોન્સ્ટ" સંસ્કરણ. સમસ્યાઓ સ્થિરતા વ્યક્ત કરવા માટે પ્રકાર પ્રણાલીનો ઉપયોગ વિવિધ જટિલતાઓ અને સમસ્યાઓ તરફ દોરી જાય છે, અને તે મુજબ C, C + +, અને D. જાવા અને C #ના સાંકડા C કુટુંબની બહાર તેની ટીકા કરવામાં આવી છે અને તેને અપનાવવામાં આવ્યું નથી, જે C અને C + + દ્વારા ભારે પ્રભાવિત છે, બંને સ્પષ્ટપણે કોન્સ્ટ-સ્ટાઇલ પ્રકાર ક્વોલિફાયરને નકારી કાઢે છે, તેના બદલે ઓળખકર્તા (જાવામાં અંતિમ, કોન્સ્ટ અને C #માં ફક્ત વાંચવા માટે) ને લાગુ પડતા કીવર્ડ્સ દ્વારા સ્થિરતા વ્યક્ત કરે છે. C અને C + + માં પણ, કોન્સ્ટનો ઉપયોગ નોંધપાત્ર રીતે બદલાય છે, કેટલાક પ્રોજેક્ટ અને સંસ્થાઓ તેનો સતત ઉપયોગ કરે છે, અને અન્ય લોકો તેને ટાળે છે. એસ. આર. સી. આર. સમસ્યા કોન્સ્ટ પ્રકાર ક્વોલિફાયર મુશ્કેલીઓનું કારણ બને છે જ્યારે ફંક્શનનું તર્ક તેના ઇનપુટ સ્થિર છે કે નહીં તે અંગે અજ્ઞેયવાદી હોય છે, પરંતુ તે મૂલ્ય આપે છે જે ઇનપુટ તરીકે સમાન લાયક પ્રકારનું હોવું જોઈએ. બીજા શબ્દોમાં કહીએ તો, આ કાર્યો માટે, જો ઇનપુટ અચળ હોય (અચલ-લાયક), તો વળતર મૂલ્ય પણ હોવું જોઈએ, પરંતુ જો ઇનપુટ ચલ હોય (અચલ-લાયક ન હોય), તો વળતર મૂલ્ય પણ હોવું જોઈએ. કારણ કે આ વિધેયોની સહીનો પ્રકાર અલગ છે, તેને સમાન તર્ક સાથે બે વિધેયો (અથવા સંભવિત રીતે વધુ, બહુવિધ ઇનપુટ્સના કિસ્સામાં) ની જરૂર છે-સામાન્ય પ્રોગ્રામિંગનું એક સ્વરૂપ. આ સમસ્યા સી સ્ટાન્ડર્ડ લાઈબ્રેરીમાં સરળ કાર્યો માટે પણ ઊભી થાય છે, ખાસ કરીને એસ. ટી. આર. સી. આર.; આ અવલોકનનો શ્રેય રિચી દ્વારા 1980ના દાયકાના મધ્યમાં ટોમ પ્લમને આપવામાં આવે છે. સ્ટ્રચર કાર્ય શબ્દમાળામાં અક્ષરને શોધે છે; ઔપચારિક રીતે, તે શબ્દમાળા s માં અક્ષર c ની પ્રથમ ઘટના માટે નિર્દેશકને પરત કરે છે, અને ક્લાસિક C (K & R C) માં તેનો પ્રોટોટાઇપ છેઃ ચાર * સ્ટ્રચર (ચાર * s, પૂર્ણાંક c); સ્ટ્રચર કાર્ય ઇનપુટ સ્ટ્રિંગમાં ફેરફાર કરતું નથી, પરંતુ વળતર મૂલ્યનો ઉપયોગ ઘણીવાર કોલ કરનાર દ્વારા સ્ટ્રિંગમાં ફેરફાર કરવા માટે કરવામાં આવે છે, જેમ કેઃ જો (p = સ્ટ્રચર (q, '/')) * p = '; આમ એક તરફ ઇનપુટ સ્ટ્રિંગ સ્થિર હોઈ શકે છે (કારણ કે તે કાર્ય દ્વારા સંશોધિત નથી), અને જો ઇનપુટ સ્ટ્રિંગ સ્થિર હોય તો વળતર મૂલ્ય પણ હોવું જોઈએ-સૌથી સરળ કારણ કે તે બરાબર પરત આવી શકે છે. C + + માં આ ફંક્શન ઓવરલોડિંગ દ્વારા કરવામાં આવે છે, જે સામાન્ય રીતે નમૂના દ્વારા અમલમાં મૂકવામાં આવે છે, પરિણામે બે કાર્યો થાય છે, જેથી વળતર મૂલ્ય ઇનપુટ તરીકે સમાન સ્થિર-લાયક પ્રકાર ધરાવે છેઃ ચાર * સ્ટ્રચર (ચાર * એસ, ઇન્ટ સી); ચાર કોન્સ્ટ * સ્ટ્રચર (ચાર કોન્સ્ટ * એસ, ઇન્ટ સી); આ બદલામાં નમૂના દ્વારા વ્યાખ્યાયિત કરી શકાય છેઃ ટેમ્પલેટ <T> T * સ્ટ્રચર (ટી * એસ, ઇન્ટ સી) {.} D માં આ ઇનઆઉટ કીવર્ડ દ્વારા નિયંત્રિત થાય છે, જે કોન્સ્ટ, અપરિવર્તનીય, અથવા અયોગ્ય (ચલ) માટે વાઇલ્ડકાર્ડ તરીકે કાર્ય કરે છે, જે યીલ્ડિંગઃ ઇનઆઉટ (ચાર) * સ્ટ્રચર (ઇનઆઉટ (ચાર) * એસ, ઇન્ટ આ ઉકેલ રિચી દ્વારા પ્રસ્તાવિત કરવામાં આવ્યો હતો અને ત્યારબાદ તેને અપનાવવામાં આવ્યો હતો. આ તફાવત સી અને સી + + ની સુસંગતતાની નિષ્ફળતાઓમાંની એક છે. C23 થી, આ સમસ્યા સામાન્ય કાર્યોના ઉપયોગથી હલ થાય છે. જો તેમને કોઈ અયોગ્ય નિર્દેશક આપવામાં આવ્યું હોય તો એસ. આર. સી. એચ. આર. અને મુદ્દાથી અસરગ્રસ્ત અન્ય કાર્યો કોન્સ્ટ નિર્દેશક પરત કરશે અને જો તેમને અયોગ્ય નિર્દેશક આપવામાં આવ્યું હોય તો અયોગ્ય નિર્દેશક પરત કરશે. ડી ની આવૃત્તિ 2 માં, કોન્સ્ટને લગતા બે મુખ્ય શબ્દો અસ્તિત્વમાં છે. અપરિવર્તનીય મુખ્ય શબ્દ એવા ડેટાને સૂચવે છે જેને કોઈ પણ સંદર્ભ દ્વારા સુધારી શકાતો નથી. કોન્સ્ટ મુખ્ય શબ્દ પરિવર્તનીય ડેટાના બિન-પરિવર્તનશીલ દૃશ્યને સૂચવે છે. C + + સ્થિરાંકથી વિપરીત, D સ્થિરાંક અને અપરિવર્તનીય "ઊંડા" અથવા છે, અને સ્થિરાંક અથવા અપરિવર્તનીય પદાર્થ દ્વારા પહોંચી શકાય તેવી કોઈપણ વસ્તુ અનુક્રમે સ્થિરાંક અથવા અપરિવર્તનીય છે. કોન્સ્ટ વિ. નું ઉદાહરણ ડી ઇન્ટીટ [] ફૂ = ન્યૂ ઇન્ટીટ [5] માં અપરિવર્તનીય છે;// ફૂ પરિવર્તનીય છે. કોન્સ્ટ ઇન્ટ [] બાર = ફૂ;// બાર એ પરિવર્તનીય ડેટાનું કોન્સ્ટ દૃશ્ય છે. અપરિવર્તનીય પૂર્ણાંક [] બાઝ = ફૂ;// ભૂલઃ અપરિવર્તનીય માહિતીના તમામ દૃશ્યો અપરિવર્તનીય હોવા જોઈએ. અપરિવર્તનીય int [] nums = નવા અપરિવર્તનીય (int) [5];// nums માટે કોઈ પરિવર્તનીય સંદર્ભ બનાવી શકાતો નથી. સ્થિરાંક [] સ્થિરાંક સંખ્યાઓ = સંખ્યાઓ;// કામ કરે છે. અપરિવર્તનીય એ ગર્ભિત રીતે સ્થિરતામાં પરિવર્તનીય છે. int [] મ્યુટેબલ નંબર્સ = nums;// ભૂલઃ અપરિવર્તનીય ડેટાનું મ્યુટેબલ દૃશ્ય બનાવી શકાતું નથી. ડી વર્ગમાં સંક્રમક અથવા ઊંડા કોન્સ્ટનું ઉદાહરણ ફૂ {ફૂ આગામી; પૂર્ણાંક સંખ્યા;} અપરિવર્તનીય ફૂ ફૂ = નવું અપરિવર્તનીય (ફૂ); foo.next.num = 5;// સંકલન નહીં કરે. foo.next અપરિવર્તનીય (Foo) પ્રકારનો છે. //foo.next.num અપરિવર્તનીય (int) પ્રકારનો છે. હિસ્ટ્રી કોન્સ્ટને 1981માં C + + ના પુરોગામી, ક્લાસીસ સાથે Cમાં બાર્ન સ્ટ્રોસ્ટ્રપ દ્વારા રજૂ કરવામાં આવ્યો હતો અને તેને મૂળ રીતે રીડ ઓનલી કહેવામાં આવતો હતો. પ્રેરણા વિશે સ્ટ્રોસ્ટ્રપ લખે છેઃ "તે બે કાર્યો કરે છેઃ એક પ્રતીકાત્મક અચળાંકને વ્યાખ્યાયિત કરવાની રીત તરીકે જે અવકાશ અને પ્રકાર નિયમોનું પાલન કરે છે (એટલે કે, મેક્રોનો ઉપયોગ કર્યા વિના) અને મેમરીમાં ઑબ્જેક્ટને અપરિવર્તનીય ગણવાની રીત તરીકે". પ્રથમ ઉપયોગ, મેક્રોઝના અવકાશ અને ટાઇપ કરેલા વિકલ્પ તરીકે, ઇનલાઇન મુખ્ય શબ્દ દ્વારા કાર્ય જેવા મેક્રો માટે સમાન રીતે પૂર્ણ કરવામાં આવ્યો હતો. સતત સંકેતો અને * કોન્સ્ટ નોટેશન, ડેનિસ રિચી દ્વારા સૂચવવામાં આવ્યા હતા અને તેથી અપનાવવામાં આવ્યા હતા. કોન્સ્ટ પછી માનકીકરણના ભાગ રૂપે સીમાં અપનાવવામાં આવ્યું હતું, અને અન્ય પ્રકારનાં ક્વોલિફાયર, અસ્થિર સાથે C89 (અને અનુગામી આવૃત્તિઓ) માં દેખાય છે. ડિસેમ્બર 1987માં X3J11 સમિતિની બેઠકમાં વધુ ક્વોલિફાયર, નોએલિયાસ સૂચવવામાં આવ્યું હતું, પરંતુ તેને નકારી કાઢવામાં આવ્યું હતું; તેનું લક્ષ્ય આખરે C99માં પ્રતિબંધિત મુખ્ય શબ્દ દ્વારા પૂર્ણ થયું હતું. રિચી આ ઉમેરાઓને બહુ ટેકો આપતા ન હતા, એવી દલીલ કરતા કે તેઓ "તેમનું વજન વહન કરતા નથી", પરંતુ આખરે તેમને ધોરણમાંથી દૂર કરવા માટે દલીલ કરી ન હતી. ડી પછીથી સી + + માંથી વારસામાં કન્સ્ટ્રક્ટર મળ્યું, જ્યાં તેને ટાઇપ કન્સ્ટ્રક્ટર (ક્વોલિફાયર પ્રકાર નહીં) તરીકે ઓળખવામાં આવે છે અને સંબંધિત ઉપયોગના કેસોને સંભાળવા માટે વધુ બે પ્રકારનાં કન્સ્ટ્રક્ટર્સ, અપરિવર્તનીય અને ઈનઆઉટ ઉમેર્યા. અન્ય ભાષાઓ અન્ય ભાષાઓ આ પ્રકારનો સ્થિરતા ભાગ હોવા માટે C/C + + ને અનુસરતી નથી, જો કે તેઓ ઘણીવાર ઉપરછલ્લી રીતે સમાન રચનાઓ ધરાવે છે અને કોન્સ્ટ મુખ્ય શબ્દનો ઉપયોગ કરી શકે છે. સામાન્ય રીતે આનો ઉપયોગ માત્ર અચળાંકો (અચળાં પદાર્થો) માટે થાય છે. સી #માં કોન્સ્ટ મુખ્ય શબ્દ છે, પરંતુ ધરમૂળથી અલગ અને સરળ શબ્દાર્થ સાથેઃ તેનો અર્થ સંકલન-સમય અચળાંક છે, અને તે પ્રકારનો ભાગ નથી. નિમમાં C #જેવો જ કોન્સ્ટ મુખ્ય શબ્દ છેઃ તે પ્રકારનો ભાગ બનાવવાને બદલે સંકલન-સમય અચળાંક પણ જાહેર કરે છે. જો કે, નિમમાં, સંકલન સમયે મૂલ્યાંકન કરી શકાય તેવી કોઈપણ અભિવ્યક્તિમાંથી અચળાંક જાહેર કરી શકાય છે. સી #માં, ફક્ત સી #બિલ્ટ-ઇન પ્રકારોને કોન્સ્ટ તરીકે જાહેર કરી શકાય છે; વર્ગો, રચનાઓ અને એરે સહિત વપરાશકર્તા-નિર્ધારિત પ્રકારો કોન્સ્ટ ન હોઈ શકે. જાવામાં કોન્સ્ટ નથી-તેના બદલે તેમાં ફાઇનલ છે, જે સ્થાનિક "ચલ" ઘોષણાઓ પર લાગુ કરી શકાય છે અને ઓળખકર્તા પર લાગુ થાય છે, પ્રકાર પર નહીં. તે ઓબ્જેક્ટ સભ્યો માટે એક અલગ ઓબ્જેક્ટ-ઓરિએન્ટેડ ઉપયોગ ધરાવે છે, જે નામની ઉત્પત્તિ છે. જાવા ભાષા સ્પષ્ટીકરણ કોન્સ્ટને આરક્ષિત મુખ્ય શબ્દ તરીકે માને છે-એટલે કે, જેનો ઉપયોગ ચલ ઓળખકર્તા તરીકે કરી શકાતો નથી-પરંતુ તેને કોઈ શબ્દાર્થ સોંપતો નથીઃ તે એક આરક્ષિત શબ્દ છે (તેનો ઉપયોગ ઓળખકર્તાઓમાં કરી શકાતો નથી) પરંતુ મુખ્ય શબ્દ નથી (તેનો કોઈ વિશેષ અર્થ નથી). એવું માનવામાં આવે છે કે સી + +-શૈલી કોન્સ્ટ પદ્ધતિઓ અને પોઇન્ટરથી કોન્સ્ટ પ્રકારનો સમાવેશ કરવા માટે જાવા ભાષાના વિસ્તરણને મંજૂરી આપવા માટે કીવર્ડની આરક્ષણ થયું હતું. કોન્સ્ટન્ટ ચોકસાઈના અમલીકરણ માટે એક વૃદ્ધિ વિનંતી ટિકિટ જાવા કોમ્યુનિટી પ્રોસેસમાં અસ્તિત્વમાં છે, પરંતુ પછાત-સુસંગત ફેશનમાં અમલ કરવો અશક્ય હોવાના આધારે 2005 માં બંધ કરવામાં આવી હતી. સમકાલીન એ. ડી. એ. 83 સ્વતંત્ર રીતે સતત પદાર્થ અને સતત મુખ્ય શબ્દની કલ્પના ધરાવતું હતું, જેમાં ઇનપુટ પરિમાણો અને લૂપ પરિમાણો સ્પષ્ટ રીતે સ્થિર હતા. અહીં અચળાંક એ પદાર્થનો ગુણધર્મ છે, પ્રકારનો નહીં. જાવાસ્ક્રિપ્ટમાં કોન્સ્ટ ઘોષણા છે જે બ્લોક-સ્કોપ્ડ ચલને વ્યાખ્યાયિત કરે છે જેને ફરીથી સોંપી શકાતી નથી કે ફરીથી જાહેર કરી શકાતી નથી. તે ચલ માટે ફક્ત વાંચવા માટેના સંદર્ભને વ્યાખ્યાયિત કરે છે જેને ફરીથી વ્યાખ્યાયિત કરી શકાતો નથી, પરંતુ કેટલીક પરિસ્થિતિઓમાં ચલનું મૂલ્ય પોતે સંભવિત રીતે બદલાઈ શકે છે, જેમ કે જો ચલ કોઈ પદાર્થનો સંદર્ભ આપે છે અને તેની મિલકતમાં ફેરફાર કરવામાં આવે છે. આ પણ જુઓ સિંગલ અસાઇનમેન્ટ રિસ્ટ્રિક્ટ પોઇન્ટર અલિયાસિંગ નોટ્સ રેફરન્સ બાહ્ય કડીઓ હર્બ સુટર દ્વારા "કોન્સ્ટન્ટ-કરેક્ટનેસ" "કોન્સ્ટન્ટ ઓપ્ટિમાઇઝેશન?" હર્બ સુટર દ્વારા ધ સી + + એફએક્યુ લાઇટઃ માર્શલ ક્લાઇન દ્વારા કોન્સ્ટ કરેક્ટનેસ વિભાગ બ્રુસ એકેલ દ્વારા મફત ઇલેક્ટ્રોનિક પુસ્તક થિંકિંગ ઇન સી + + માંથી "વેલ્યુ સબસ્ટિટ્યુશન" વોલ્ટર બ્રાઇટ દ્વારા "હિયર એ કોન્સ્ટ, દેયર એ કોન્સ્ટ" ડી પ્રોગ્રામિંગ લેંગ્વેજ સ્પષ્ટીકરણમાંથી "કોન્સ્ટ અને ઇનવેરિયન્ટ", સંસ્કરણ 2 (પ્રાયોગિક) સી પ્રોગ્રામિંગ લેંગ્વેજ ફેમિલી ડેટા પ્રકારો ઉદાહરણ તરીકે સી કોડ સાથે લેખો C + + કોડ પ્રોગ્રામિંગ લેંગ્વેજ વિષયો સાથે લેખો