C++ switch Deyimi: case'ler, fall-through ve break

switch Ne İşe Yarar

Bir switch, bir değeri sabit seçeneklerden oluşan bir listeyle karşılaştırır ve eşleşen dalı çalıştırır. Kendinizi aynı değişkeni farklı sabitlerle karşılaştırmayı sürdüren uzun bir if/else if zinciri yazarken bulduğunuzda, bir switch bu niyeti daha net biçimde ifade eder ve genellikle daha hızlı bir atlama tablosuna (jump table) derlenir.

Yalnızca tamsayı benzeri bir değer üzerinde, derleme zamanı sabitlerine karşı eşitlik kontrolleri yapar. Aralıkları test edemez, dizgileri karşılaştıramaz veya koşulları birleştiremez. Bunların herhangi biri için if/else ile kalın.

Temel switch

switch'e bir değer verirsiniz, ardından önemsediğiniz değerler için case etiketlerini listelersiniz. Her dal break ile biter:

#include <iostream>
using namespace std;

int main() {
    int day = 3;

    switch (day) {
        case 1:
            cout << "Monday" << endl;
            break;
        case 2:
            cout << "Tuesday" << endl;
            break;
        case 3:
            cout << "Wednesday" << endl;
            break;
        default:
            cout << "Some other day" << endl;
            break;
    }

    return 0;
}

3 değeri case 3: ile eşleşir, böylece "Wednesday" yazdırılır ve break switch'ten dışarı atlar. default dalı her şeyi yakalayan daldır; hiçbir case eşleşmediğinde çalışır. İsteğe bağlıdır, ama her değerin ele alındığından emin değilseniz onu ekleyin.

case etiketlerinin koşullar değil, iki nokta üst üste ile takip edilen yalın sabitler olduğuna dikkat edin. case 3: yazarsınız, asla case day == 3: değil.

break ve fall-through

Bu, C++'ta switch'in en önemli tuzağıdır. Bir case eşleştikten sonra, yürütme bir sonraki case'de durmaz: bir break'e ya da kapanış parantezine ulaşana kadar düz çalışmaya devam eder. break deyimleri eksik olduğunda neler olduğuna bakın:

#include <iostream>
using namespace std;

int main() {
    int level = 1;

    switch (level) {
        case 1:
            cout << "one" << endl;
        case 2:
            cout << "two" << endl;
        case 3:
            cout << "three" << endl;
        default:
            cout << "done" << endl;
    }

    return 0;
}

Yalnızca "one" bekleyebilirsiniz. Bunun yerine dört satırın hepsi yazdırılır: case 1: ile eşleşmek switch'e oradan girer ve ardından altındaki tüm etiketlerden düşerek geçer. Her dalın ardına bir break; ekleyin, istediğiniz tek satırı elde edersiniz. Bir break'i unutmak, "switch'im neden çok fazla kod çalıştırıyor?" türündeki hataların klasik kaynağıdır.

case'leri Gruplamak İçin Kasıtlı Fall-Through

Fall-through her zaman bir hata değildir: birkaç case'in tek bir gövdeyi paylaşmasını sağlamanın deyimsel yoludur. Case'leri boş bırakın (deyim yok, break yok) ve hepsi bir sonraki bloğa akar:

#include <iostream>
using namespace std;

int main() {
    char grade = 'B';

    switch (grade) {
        case 'A':
        case 'B':
        case 'C':
            cout << "Pass" << endl;
            break;
        case 'D':
        case 'F':
            cout << "Fail" << endl;
            break;
        default:
            cout << "Invalid grade" << endl;
    }

    return 0;
}

'A', 'B' ve 'C' aynı "Pass" satırına iner çünkü ilk iki case boştur ve üçüncüye düşerek geçer. Bu temiz ve kasıtlıdır. Biraz kod çalıştırdıktan sonra düşerek geçmeyi gerçekten istediğinizde, bunu bir yorumla belgeleyin; ya da C++17 ve sonrasında, derleyiciye "evet, bunu bilerek yaptım" diyen ve fall-through uyarılarını susturan [[fallthrough]]; özniteliğiyle.

enum üzerinde switch

switch, enum'larla doğal olarak uyum sağlar; çünkü bir enum tam olarak "sabit bir değer kümesinden biri"dir. Derleyiciler ayrıca numaralandırıcılardan birini ele almayı unutursanız sizi uyarabilir:

#include <iostream>
using namespace std;

enum class Direction { North, East, South, West };

int main() {
    Direction d = Direction::East;

    switch (d) {
        case Direction::North:
            cout << "Heading up" << endl;
            break;
        case Direction::East:
            cout << "Heading right" << endl;
            break;
        case Direction::South:
            cout << "Heading down" << endl;
            break;
        case Direction::West:
            cout << "Heading left" << endl;
            break;
    }

    return 0;
}

Kapsamlı bir enum class ile her etiketi nitelemeniz gerekir (Direction::East). Tüm numaralandırıcılar kapsandığı için default'a gerek yoktur ve daha sonra beşinci bir yön eklerseniz ve onun case'ini eklemeyi unutursanız birçok derleyici sizi uyarır. Bu derleyici yardımı, enum'lar için if/else zincirleri yerine switch'i tercih etmenin büyük bir nedenidir.

Bir Tuzak: case İçinde Bildirimler

Bir case içinde başlatıcılı bir değişken bildirip onu kapsam vermeden diğer case'lerde görünür yapamazsınız. Bu yaygın bir derleme hatasıdır:

switch (x) {
    case 1:
        int n = 10;   // hata: case 2'ye atlamak bu başlatmayı atlar
        cout << n;
        break;
    case 2:
        cout << "two";
        break;
}

Derleyici bunu reddeder çünkü case 2: içine düşmek, n hâlâ kapsamdayken n'nin başlatılmasının üzerinden atlardı. Çözüm, case gövdesini kendi parantezleriyle sarmak ve değişkene kendi bloğunu vermektir:

#include <iostream>
using namespace std;

int main() {
    int x = 1;

    switch (x) {
        case 1: {
            int n = 10;   // artık bu bloğa kapsamlı, sorun yok
            cout << n << endl;
            break;
        }
        case 2:
            cout << "two" << endl;
            break;
    }

    return 0;
}

Bir case kendi yerel değişkenine ihtiyaç duyduğunda ona parantez verin. Bu ayrıca değişkenin altındaki case'lere sızmasını da önler.

Sonraki: for döngüsü

switch ve if, programınızın hangi kodu bir kez çalıştıracağını seçmesini sağlar. Ancak işlerin çoğu aynı şeyi defalarca yapmayı gerektirir: saymak, bir liste üzerinde yinelemek, bir koşul değişene kadar tekrarlamak. for döngüsü bunun için iş atıdır ve bir sonraki sayfa odur.