разворачивание циклов в функции особого случая

Однако для эффективности я хочу сделать чехлы с петлями 1, 2 и 3 размера, специальные случаи, которые полностью развернуты.

Вы измерили, что это на самом деле быстрее? Я сомневаюсь, что это будет (или что компилятор не развернет цикл автоматически).

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

const здесь ничего не значит. Это не повлияет на способность компилятора разворачивать цикл. Это просто означает, что a нельзя изменить внутри тела функции, но он по-прежнему является аргументом времени выполнения.

Если вы хотите обеспечить развертывание, то сделайте это принудительно. Это довольно просто с С++ 17.

template <typename F, std::size_t... Is>
void repeat_unrolled_impl(F&& f, std::index_sequence<Is...>)
{
    (f(std::integral_constant<std::size_t, Is>{}), ...);
}

template <std::size_t Iterations, typename F>
void repeat_unrolled(F&& f)
{
    repeat_unrolled_impl(std::forward<F>(f), 
                         std::make_index_sequence<Iterations>{});
}

живой пример на godbolt

Если вы не любите шаблоны и не доверяете своему компилятору, всегда есть этот метод, вдохновленный устаревшим методом ручного развертывания циклов, который называется «устройство даффа»:

void do_something(int i);

void do_something_n_times(int n)
{
    int i = 0;
    switch(n)
    {
        default:
            while(n > 3) {
                do_something(i++);
                --n;
            }
        case 3: do_something(i++);
        case 2: do_something(i++);
        case 1: do_something(i++);
    }
}

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

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

Он был изобретен Томом Даффом в 1983 году.

https://en.wikipedia.org/wiki/Duff%27s_device

Его использование с современными компиляторами сомнительно.

Я бы предпочел пойти по этому пути, если вы хотите использовать встроенную (нестандартную) функцию всех популярных компиляторов:

__attribute__((always_inline))
void bodyOfLoop(int i) {
  // put code here
}

void specialCase() {
    bodyOfLoop(0);
    bodyOfLoop(1);
    bodyOfLoop(2);
}

void generalCase(int a) {
    for (int i=0; i<a; i++) {
        bodyOfLoop(i);
    }
}

Примечание: это решение GCC/Clang. Используйте __forceinline для MSVC.