Artırma ve eksiltme operatörleri - Increment and decrement operators

"++" Burada yönlendirir. Loona EP için bkz. ++ (EP) .

Artırma ve eksiltme operatörleri olan tekli operatörler eklemek veya çıkarmak için ya da gelen, biri işlenen sırasıyla. Genellikle zorunlu programlama dillerinde uygulanırlar . C benzeri diller, her operatörün biraz farklı semantiklere sahip iki versiyonunu (ön ve son) içerir.

B'den sözdizimsel olarak türetilen dillerde (C ve çeşitli türevleri dahil), artırma operatörü olarak yazılır ++ve eksiltme operatörü olarak yazılır --. Diğer bazı diller inc(x) ve dec(x) işlevlerini kullanır.

Artırma operatörü artar ve azaltma operatörü azalır, işlenenin değeri 1'dir. İşlenen bir aritmetik veya işaretçi veri türüne sahip olmalı ve değiştirilebilir bir veri nesnesine başvurmalıdır . İşaretçi değerleri, bellekte bitişik bir sonraki (veya önceki) öğeye işaret etmelerini sağlayan bir miktarda artırılır (veya azaltılır).

Operatörlerin her iki sürümünü de destekleyen dillerde:

  • Ön -increment ve ön -decrement operatörler artışı (ya da azaltma) 1 ile bunların işlenen ve ifadesinin değeri elde edilen arttırılır (ya da azaltılması) değeridir.
  • Sonrası -increment ve sonrası -decrement operatörleri (veya azalma) 1 ile bunların işlenen değerini artırmak, bir ifadenin değeri, işlenen değeri olan önceden artışı (ya da azaltma) çalışması için.

Artırma/azaltmanın bir ifade olmadığı dillerde (örneğin, Go ), yalnızca bir sürüm gereklidir (Go durumunda, yalnızca post operatörleri).

Artırma/azaltma operatörü işlenenini değiştirdiği için, böyle bir işlenenin aynı ifade içinde birden fazla kullanılması tanımsız sonuçlar üretebilir. Örneğin , gibi ifadelerde x - ++xçıkarma ve artırma işlemlerinin hangi sırayla yapılması gerektiği açık değildir. Bu tür ifadeler genellikle tanımsız davranışı çağırır ve bundan kaçınılmalıdır.

C gibi yazılan işaretçilere sahip dillerde, artırma operatörü, işaretçiyi o türden bir sonraki öğeye doğru ilerletir ve işaretçinin değerini o türün boyutuna göre artırır. Bir işaretçi (doğru türden) bir dizideki herhangi bir öğeye işaret ettiğinde, artırma (veya azaltma), işaretçiyi o dizinin "sonraki" (veya "önceki") öğesini işaret eder. Bir işaretçi bir tür işaretçiden tamsayıya sahip olduğunda, bu işaretçiyi artırmak, bir sonraki tamsayıya işaret etmesini sağlar (tipik olarak 4 bayt artırarak). Bir işaretçi, işaretçiden çalışana bir türe sahip olduğunda, bu işaretçiyi artırmak bir sonraki "çalışana" işaret etmesini sağlar -- çalışan yapısının boyutu 106 bayt ise, bu işaretçiyi artırmak onu 106 bayt artırır.

Örnekler

Aşağıdaki C kod parçası, ön ve son artırma ve eksiltme operatörleri arasındaki farkı gösterir : 

int x;
int y;

// Increment operators
// Pre-increment: x is incremented by 1, then y is assigned the value of x
x = 1;
y = ++x;    // x is now 2, y is also 2

// Post-increment: y is assigned the value of x, then x is incremented by 1
x = 1;
y = x++;    // y is 1, x is now 2

// Decrement operators
// Pre-decrement: x is decremented by 1, then y is assigned the value of x
x = 1;
y = --x;    // x is now 0, y is also 0

// Post-decrement: y is assigned the value of x, then x is decremented by 1
x = 1;
y = x--;    // y is 1, x is now 0

Bu operatörlerin bulunmadığı dillerde, eşdeğer sonuçlar için fazladan bir kod satırı gerekir: 

# Pre-increment: y = ++x
x = 1
x = x + 1  # x is now 2  (can be written as "x += 1" in Python)
y = x      # y is also 2

# Post-increment: y = x++
x = 1
y = x      # y is 1
x = x + 1  # x is now 2


Artış sonrası operatör, dizi abonelikleriyle yaygın olarak kullanılır . Örneğin: 

// Sum the elements of an array
float sum_elements(float arr[], int n)
{
    float  sum = 0.0;
    int    i =   0;

    while (i < n)
        sum += arr[i++];    // Post-increment of i, which steps
                            //  through n elements of the array
    return sum;
}

Artış sonrası işleci ayrıca işaretçilerle yaygın olarak kullanılır : 

// Copy one array to another
void copy_array(float *src, float *dst, int n)
{
    while (n-- > 0)        // Loop that counts down from n to zero
        *dst++ = *src++;   // Copies element *(src) to *(dst),
                           //  then increments both pointers
}

Bu örneklerin C++ , Java ve C# gibi diğer C benzeri dillerde de çalıştığını unutmayın .

  • Artırma operatörü bir örnekle gösterilebilir:
    #include <stdio.h>
int main()
{
    int c=2;
    printf("%d\n", c++); // this statement displays 2, then c is incremented by 1 to 3.
    printf("%d", ++c);   // this statement increments c by 1, then c is displayed.
    return 0;
}
    • Çıktı:
      2
4

Destekleyen diller

Aşağıdaki liste, tam veya her şeyi kapsamasa da , ++/ --arttırma/azaltma operatörlerini destekleyen bazı belli başlı programlama dillerini listeler .

(Apple'ın Swift'i bir zamanlar bu operatörleri destekledi, ancak sürüm 3'ten itibaren destek kaldırıldı.)

Pascal , Delphi , Modula-2 ve Oberon aynı işlevleri sağlar, ancak bunlara inc(x) ve dec(x) adı verilir.

Özellikle Python ve Rust bu operatörleri desteklemez.

Tarih

Konsept, 1969 dolaylarında Ken Thompson tarafından B programlama dilinde tanıtıldı .

Thompson, artan veya azalan ++ ve -- operatörlerini icat ederek bir adım daha ileri gitti; bunların önek veya sonek konumu, değişikliğin işlenenin değerini not etmeden önce mi yoksa sonra mı olacağını belirler. B'nin en eski versiyonlarında değillerdi, ama yol boyunca ortaya çıktılar. İnsanlar genellikle, C ve Unix'in ilk kez popüler hale geldiği DEC PDP-11 tarafından sağlanan otomatik artış ve otomatik azalan adres modlarını kullanmak için oluşturulduklarını tahmin ederler. B geliştirildiğinde PDP-11 olmadığı için bu tarihsel olarak imkansızdır. Bununla birlikte, PDP-7'nin birkaç "otomatik artışlı" bellek hücresi vardı ve bunlar aracılığıyla dolaylı bir bellek başvurusunun hücreyi artırması özelliği vardı. Bu özellik muhtemelen Thompson'a bu tür operatörleri önerdi; onları hem önek hem de sonek yapmak için yapılan genelleme kendisine aitti. Aslında, otomatik artış hücreleri doğrudan operatörlerin uygulanmasında kullanılmadı ve yenilik için daha güçlü bir motivasyon, muhtemelen ++x'in çevirisinin x=x+1'inkinden daha küçük olduğu gözlemiydi.

Ayrıca bakınız

Referanslar