Dalam pemrograman komputer, **konstanta** atau disebut juga **tetapan** (bahasa Inggris: *constant value*) adalah pengidentifikasi yang terkait nilai yang biasanya tidak bisa diubah oleh tata olah selama pelaksanaannya (meskipun dalam beberapa kasus ini dapat dielakkan, misalnya menggunakan *self-modifying code*). Banyak bahasa pemrograman membuat perbedaan sintaksis eksplisit antara simbol tetapan dan peubah.

Meskipun nilai *constant* yang ditentukan hanya sekali, sebuah *constant* dapat dirujuk berkali-kali dalam sebuah tata olah. Menggunakan konstanta, bukan menentukan nilai beberapa kali dalam program tidak bisa hanya menyederhanakan pemeliharaan kode, tetapi juga dapat menyediakan nama yang bermakna untuk itu dan menggabungkan ikatan *constant* seperti ke lokasi kode standar (misalnya, di awal).

Perbandingan dengan literal dan macro
-------------------------------------

Ada beberapa cara utama beberapa mengekspresikan nilai data yang tidak berubah selama pelaksanaan program yang konsisten di berbagai bahasa pemrograman. Salah satu cara yang sangat dasar dengan hanya menulis literal angka, karakter, atau string ke dalam kode program, yang langsung di C, C + +, dan bahasa yang sama.

Dalam bahasa assembly, angka literal dan karakter yang dilakukan dengan menggunakan "modus langsung" petunjuk yang tersedia pada mikroprosesor kebanyakan. Nama "langsung" berasal dari nilai-nilai yang segera tersedia dari instruction stream, Sebagai lawan memuat mereka secara tidak langsung dengan melihat alamat memori  Di sisi lain, nilai-nilai lama dari panjang kata mikroprosesor, seperti string dan array, ditangani langsung dan perakit umumnya memberikan "data" pseudo-op untuk menanamkan data tersebut tabel dalam sebuah program.

Cara lain adalah dengan mendefinisikan simbolik macro. Banyak bahasa pemrograman tingkat tinggi, dan perakit (assemblers), menawarkan fasilitas makro di mana programmer dapat menentukan, umumnya pada awal sebuah file sumber atau dalam file definisi yang terpisah, nama untuk nilai yang berbeda. Sebuah preprocessor kemudian mengganti nama-nama dengan nilai-nilai yang sesuai sebelum kompilasi, sehingga sesuatu yang fungsional identik dengan menggunakan literal, dengan keunggulan kecepatan modus langsung. Karena bisa sulit untuk mempertahankan kode di mana semua nilai ditulis harfiah, jika nilai yang digunakan dengan cara apapun berulang atau tidak-jelas, hal ini sering dilakukan sebagai makro.

Cara ketiga adalah dengan menyatakan dan mendefinisikan variabel constant. Sebuah variabel global atau statis dapat dinyatakan (atau simbol didefinisikan dalam assembly) dengan kualifikasi kata kunci seperti Templat:Cpp, `constant`, or final
 yang berarti bahwa Nilai akan ditetapkan pada waktu kompilasi dan tidak boleh berubah pada saat runtime. Compiler biasanya menempatkan constant statis di bagian teks dari file objek bersama dengan kode itu sendiri, yang bertentangan dengan bagian data di mana non-const data diinisialisasi disimpan, meskipun beberapa memiliki pilihan untuk menghasilkan bagian khusus didedikasikan untuk constant, jika demikian diinginkan. Perlindungan memori dapat diterapkan ke daerah ini untuk mencegah variabel constant yang saling menimpa dengan petunjuk menyimpang.

Ini "variabel constant" berbeda dari literal dalam beberapa cara. Compiler biasanya menempatkan constant di lokasi memori tunggal yang diidentifikasi oleh simbol, daripada tersebar di seluruh executable seperti dengan makro. Sementara ini menghalangi keuntungan kecepatan dari modus langsung, ada keuntungan dalam efisiensi memori, dan pengawakutu dapat bekerja dengan constant saat runtime. Juga ketika macro dapat didefinisikan ulang sengaja oleh file header bertentangan dalam C dan C + +, constant yang bertentangan terdeteksi pada waktu kompilasi.

Tergantung pada bahasa, constant dapat menjadi untyped atau typed. Dalam C dan C + +, macro menyediakan bekas/sisa, sedangkan Templat:CPP menyediakan yang terakhir:

```
#define PI 3.1415926535

const float pi2 = 3.1415926535;

```

while in Ada, there are universal numeric types that can be used, if desired:

```
pi: constant:= 3.1415926535;

pi2: constant float:= 3.1415926535;

```

dengan varian untyped yang implisit dikonversi ke jenis yang sesuai pada setiap penggunaan

Dinamis-nilai constant
----------------------

Selain *static constants* dijelaskan di atas, banyak prosedural bahasa seperti Ada dan C + + memperluas konsep constantness terhadap variabel global yang diciptakan pada saat inisialisasi, variabel lokal yang secara otomatis dibuat saat runtime pada stack atau di register, untuk dinamis dialokasikan memori yang diakses oleh pointer, dan daftar parameter dalam header fungsi.

constant dinamis-bernilai tidak menetapkan variabel berada di wilayah tertentu dari memori, juga merupakan nilai-nilai yang ditetapkan pada waktu kompilasi. Dalam C + + kode seperti

```
float func(const float ANYTHING) {
 const float XYZ = someGlobalVariable\*someOtherFunction(ANYTHING);
 ...
}

```

ekspresi yang constant diinisialisasi untuk tidak sendiri constant. Penggunaan constantness tidak diperlukan di sini untuk legalitas program atau kebenaran semantik, namun memiliki tiga keuntungan:

1. Hal ini jelas bagi pembaca bahwa objek tidak akan diubah lagi, sekali di set.
2. Upaya untuk mengubah nilai dari objek (oleh programmer kemudian yang tidak sepenuhnya memahami logika program) akan ditolak oleh kompilator
3. Compiler mungkin dapat melakukan optimasi kode mengetahui bahwa nilai objek tidak akan berubah setelah dibuat

constant dinamis bernilai berasal sebagai fitur bahasa dengan ALGOL 68. Studi Ada dan C + + kode telah menunjukkan bahwa constant dinamis bernilai jarang digunakan, biasanya untuk 1% atau kurang dari objek, ketika mereka bisa digunakan lebih banyak, karena beberapa 40-50% dari lokal, non-kelas objek sebenarnya invarian sekali dibuat  Di sisi lain, seperti "immutable variables/variabel yang berubah" cenderung menjadi default dalam pemrograman functional languages karena gaya pemrograman mereka mendukung tanpa efek samping (misalnya, recursion) atau membuat most declarations immutable/ML bahasa pemrograman | deklarasi yang paling berubah secara default. Beberapa bahasa fungsional bahkan [[Purely functional|forbid side-effecs]t]/ melarang efek samping seluruhnya.

Constantness sering digunakan dalam deklarasi fungsi, sebagai janji bahwa ketika sebuah benda dikirimkan dengan referensi, fungsi disebut tidak akan mengubahnya. Tergantung pada sintaks, baik pointer atau benda yang menunjuk mungkin constant, tetapi biasanya yang terakhir yang diinginkan. Terutama di C dan C + +, disiplin memastikan bahwa struktur data yang tepat adalah constant sepanjang program ini disebut const-correctness.

Parameter fungsi constant
-------------------------

Dalam C / C + +, adalah mungkin untuk menyatakan parameter dari fungsi atau metode sebagai constant. Ini adalah jaminan bahwa parameter ini tidak dapat diubah setelah tugas pertama (secara tidak sengaja). Jika parameter adalah pra-didefinisikan (built-in) jenis, itu adalah called by value/disebut oleh nilai dan tidak dapat diubah. Jika itu adalah tipe user-defined, variabel adalah alamat pointer, yang tidak dapat dimodifikasi juga. Namun, isi dari objek dapat dimodifikasi tanpa batas. Mendeklarasikan parameter sebagai constant mungkin menjadi cara untuk signalise bahwa nilai *harus* tidak diubah, tetapi programmer harus diingat bahwa pemeriksaan tentang modifikasi objek tidak dapat dilakukan oleh compiler.

Selain fitur ini, itu di C / C + + juga memungkinkan untuk menyatakan fungsi atau metode sebagai Templat:CPP. Hal ini mencegah fungsi atau metode dari memodifikasi apa pun kecuali variabel lokal.

Dalam C #, kata kunci Templat:C tajam ada, tetapi tidak memiliki efek yang sama untuk parameter fungsi, seperti halnya di C / C + +. Ada, bagaimanapun, suatu cara untuk "membangkitkan" compiler untuk melakukan membuat cek, meskipun itu adalah sedikit rumit.

Untuk mendapatkan efek yang sama, pertama, dua antarmuka yang didefinisikan

```
public interface IReadable
{
 IValueInterface aValue { get; }
}

public interface IWritable: IReadable
{
 IValueInterface aValue { set; }
}

public class AnObject: IWritable
{
 private ConcreteValue \_aValue;

 public IValueInterface aValue
 {
 get { return \_aValue; }
 set { \_aValue = value as ConcreteValue; }
 }
}

```

Kemudian, metode yang didefinisikan memilih antarmuka yang tepat dengan read-only atau membaca / menulis kemampuan:

```
public void DoSomething(IReadable aVariable)
{
 // Cannot modify aVariable!
}

public void DoSomethingElse(IWritable aVariable)
{
 // Can modify aVariable, so be careful!
}

```

Berorientasi objek constant
---------------------------

Sebuah struktur data constant atau objek yang disebut sebagai "immutable" dalam berorientasi objek bahasa. Sebuah benda yang berubah menganugerahkan beberapa keuntungan dalam perancangan program. Misalnya, mungkin "disalin" hanya dengan menyalin pointer atau referensi, menghindari operasi memakan waktu copy dan menghemat memori.

Bahasa berorientasi objek seperti C + + memperpanjang constantness lebih jauh. Setiap anggota dari struct atau kelas dapat dibuat const bahkan jika kelas tidak. Sebaliknya, Templat:CPP kata kunci memungkinkan anggota kelas untuk diubah bahkan jika objek yang instantiated sebagai Templat:CPP.

Bahkan fungsi dapat const di C + +. Makna di sini adalah bahwa hanya fungsi const dapat disebut untuk objek instantiated sebagai const, fungsi const tidak mengubah data non-bisa berubah.

Java memiliki kualifikasi yang disebut final
 yang mencegah perubahan referensi dan memastikan tidak akan pernah menunjuk ke objek yang berbeda. Hal ini tidak mencegah perubahan pada objek disebut sendiri. Jawa final
 pada dasarnya setara dengan Templat:CPP*pointer* di C + +. Ini tidak menyediakan fitur lain dari Templat:CPP.

C # memiliki kedua `const` dan `readonly`yang di kualifikasi, const adalah hanya untuk kompilasi-waktu constant, sementara readonly dapat digunakan dalam konstruktor dan aplikasi runtime lainnya.

Catatan kaki
------------

1. ↑  Ex. IBM Systems Information. Instruction Set - Assembler Language Reference for PowerPC.
2. ↑  Booch, Grady (1983). *Software Engineering with Ada*. Benjamin Cummings. hlm. 116–117. ISBN 0-8053-0600-5.
3. 1 2 3  Schilling, Jonathan L. (April 1995). "Dynamically-Valued Constants: An Underused Language Feature". *SIGPLAN Notices*. **30** (4): 13–20. doi:10.1145/202176.202177.
4. ↑  Perkins, J. A. *Programming Practices: Analysis of Ada Source Developed for the Air Force, Army, and Navy*. Proceedings TRI-Ada '89. hlm. 342–354. doi:10.1145/74261.74287.
5. ↑  
Timwi (2010-09-09). "Read-only ("const"-like) function parameters of C#". : Stack Overflow. Diakses tanggal 2012-05-06. [...] Then you can declare methods whose parameter type "tells" whether it plans on changing the variable or not:. [...] This mimics compile-time checks similar to constness in C++. As Eric Lippert correctly pointed out, this is not the same as immutability. But as a C++ programmer I think you know that.