И остров кайфовый, и в физике человек не последний...

Не забывайте проверяться!

Я уже больше 15 лет программирую, а только сегодня осознал что type casting имеет больше общего с отливкой метала, чем я бы мог подумать.

https://en.wikipedia.org/wiki/Metal_casting

https://en.wikipedia.org/wiki/Type_casting_(typography)

#деградироватьпришёл

Типичная история, когда печатаешь что-то в цикле, надо отдельно обрабатывать конец строки и конец вывода, получается есть 2 стула:

void print_lazy() {
    for(int i = 1; i <= 5; ++i) {
        for(int j = 1; j <= 5; ++j) {
            std::cout << i << j << "_"; // Допустим
        }
        std::cout << ";\n"; // Буэ
    }
}

void print_beauty() {
    for(int i = 1; i <= 5; ++i) {
        for(int j = 1; j <= 5; ++j) {
            std::cout << i << j;
            if(j < 5) {
                std::cout << "_"; // Мда
            }
        }
        std::cout << (i < 5 ? ";\n" : "."); // Ну ладно
    }
}

И соответствующий вывод:

print_lazy():
11_12_13_14_15_;
21_22_23_24_25_;
31_32_33_34_35_;
41_42_43_44_45_;
51_52_53_54_55_;
              ^- extra spaces
^- and an empty line
also the code sucks
---
print_beauty():
11_12_13_14_15;
21_22_23_24_25;
31_32_33_34_35;
41_42_43_44_45;
51_52_53_54_55.
the result looks good but not the code

Но, кажется, есть вариант получше:

void print_smart() {
    for(int i = 1; i <= 5; ++i) {
        for(int j = 1; j <= 5; ++j) {
            std::cout << i << j << (j == 5 ? (i == 5 ? "." : ";\n") : "_");
        }
    }
}

print_smart():
11_12_13_14_15;
21_22_23_24_25;
31_32_33_34_35;
41_42_43_44_45;
51_52_53_54_55.
the result and the code looks good(???)

Конструкция (j == 5 ? (i == 5 ? "." : ";\n") : "_") не самая приятная, но в целом, если её обернуть в функцию и забыть, допустим. Но что если есть вариант попроще?

static const char* separator[]{" ", "\n", ""};

const char* separator_shifted(bool last_col, bool last_row) {
    return separator[last_col << last_row];
}

«Что за херня тут происходит?», спросите вы и будете правы, но т.к. мы всё равно прячем одну когнитивно нагруженную конструкцию в функцию, может быть есть другая, не такая сложная на первый взгляд, а там глядишь и битовые операции нам пару инструкций выиграют, лучше же, чем 2 сравнения делать, правда?

Для начала, чтобы разобраться что за херня, bool кастится в int со значением 0 или 1, и происходит соответствующий сдвиг нуля или единицы на 0 или 1 бит, то есть в результате правильной операции мы можем получить числа 0, 1 или 10 (то есть 2), что является индексом в массиве separator.

// true << true == 2, последняя колонка и последняя строка - ничего не нужно
// true << false == 1, последняя колонка и не последняя строка - перенос строки
// false << true == 0, не последняя колонка и последняя строка - пробел
// false << false == 0, не последняя колонка и не последняя строка - пробел

Что касается кхм... производительности, давайте посмотрим итоговое число инструкций на уровне оптимизации -O3:

// 3 asm lines
int index_shift(bool last_col, bool last_row) {
    return last_col << last_row;
}

// 5 asm lines
int index_cond(bool last_col, bool last_row) {
    return last_col ? (last_row ? 2 : 1) : 0;
}

Получается битовый сдвиг и правда дешевле, чем 2 условия?! Ну, почти, когда доходит до дела, то есть нюансы:

// 5 asm lines
const char* separator_shifted(bool last_col, bool last_row) {
    return separator[last_col << last_row];
}

// 5 asm lines
const char* separator_cond(bool last_col, bool last_row) {
    return separator[last_col ? (last_row ? 2 : 1) : 0];
}

Но, конечно, сделать хуже всегда можно:

// 7 asm lines
const char* separator_cond_local(bool last_col, bool last_row) {
    return last_col ? (last_row ? "" : "\n") : " ";
}

Весь код можете посмотреть тут https://godbolt.org/z/YKs9vzM6o.

«Ну и какие выводы?», спросит пытливый читатель! — Не ебите мозги.

Очевидно что код separator_cond читается буквально как «Последняя колонка? Последняя строка? 2. Нет - 1. Ах и первое нет - тогда 0.»
Код вида last_col << last_row в момент озарения, когда ты всё таки понял авторскую задумку же, читается так: «Ааа, ооо, да, смешно. Долбоеб.»
Если у компилятора достаточно контекста, то он сам оптимизирует код не хуже, чем вы, изъебываясь над байтиками, а может даже и лучше. И, однозначно, он сделает это быстрее, чем вы.

Лучше бы #деградироватьпришёл.