Привязка функций к кнопкам на клавиатуре

[_Bers]

1. Сразу приучайся не использовать магические числа.
2. Сразу возьми себе за правило - если можно не использовать вложенные ветвления - никогда их не используй.

Пример 1:

        // где то в объявлениях:
        enum eMove { eUp = 72, eDown = 80, eRight = 77, eLeft = 75 };

        int move= _getch(); //привязка "move" к нажатию определенной далее кнопки
	if (move==eUp) // <- индекс обозначающий стрелочку "вверх"
		move_up(); //функция движения вверх
	else if (move==eRight)
		move_right(); //функция движения вправо
	else if (move==eDown)
		move_down(); //функция движения вниз
	else if (move==eLeft)
		move_left(); //функция движения влево

Если вдруг изменятся условия, и нужно будет заменить коды клавиш, то любые переделки коснутся только eMove в одном месте программы. А не во всех 100500 местах, где ты имел неосторожность хардкорно закодить магические числа.

К тому же, eMove - это тип данных, а значит можно использовать проверку типов, и перегрузку функций (такой то обработчик работает с такими то перечислениями, другой обработчик - с другими, и тп).

Пример 2:
Предположим, тебе нужно обрабатывать много разных клавиш. И если эта клавиша eLeft (как из твоего примера), то прежде чем будет запущена функция её обработки, будет последовательно проверены все предыдущие условия.

Это нерациональное падение производительности. Можно сократить время поиска функции обработчика, до некоторого минимального и фиксированного значения. Если использовать switch

// где то в объявлениях:
	enum eMove { eUp = 72, eDown = 80, eRight = 77, eLeft = 75 };

	int move= _getch(); //привязка "move" к нажатию определенной далее кнопки

	switch(move)
	{
		case eUp:    { move_up();     break; }
		case eRight: { move_right();  break; }
		case eDown:  { move_down();   break; }
		case eLeft:  { move_left();   break; }
		default:     { move_unkown(); break; }
	}

Компилятор умеет преобразовывать свитчи в хитрые структуры, и очень хорошо их оптимизировать. Поэтому, если есть возможность предпочесть свитч вложенным ифам, то лучше так и сделать.

[Kamilius]

Спасибо, но впервые стыкаюсь с enum.

[_Bers]

Сообщение от Kamilius

Спасибо, но впервые стыкаюсь с enum.

Грубо говоря, это просто целочисленные константы.

enum eMove { eUp = 72, eDown = 80, eRight = 77, eLeft = 75 };

Теперь, вместо циферки 72 в своём коде ты можешь писать eUp

Причем, eUp - это константа, имеющая заданный программистом тип: eMove

Например:

//функция может принять только значения типа eMove
void Foo(eMove arg)  
{
   //здесь делаем что хотим
}

А использовать вот так:

Foo(eUp);     //можно. eUp является eMove
Foo(eDown); //можно. eDown является eMove
Foo(eRight); //можно. eRight является eMove
Foo(eLeft);  //можно. eLeft является eMove
Foo(0);       //нельзя! Ошибка компиляции. Ноль не является eMove

Таким образом, внутри функций не обязательно выполнять проверку допустимых значений. Они будут работать только с членами заданного перечисления. И все проверки валидности аргументов будут вычисляться компилятором.

Ещё один пример:

namespace type1 { enum eType { eArg1, eArg2 }; };
namespace type2 { enum eType { eArg1, eArg2 }; };

void foo(type1::eType val){	std::cout<< "type1::eType\n"; }
void foo(type2::eType val){	std::cout<< "type2::eType\n"; }

int main()
{
	foo(type1::eArg1); //вывод: type1::eType
	foo(type2::eArg1); //вывод: type2::eType
}

Перечисление - это целочисленные константы, имеющие собственный тип данных, который указывает программист.

После чего, программист может конструировать функции, которые будут работать только с этим типом данных.

Например, ты можешь написать функцию, которая в качестве входного значения будет принимать только и только коды нажатых клавиш.

Что гарантирует тебе безопасную работу. Нельзя будет ничайно скормить обработчику клавиши какой то левый непонятный код.