C ++ ne permet pas de détecter si un paramètre de fonction fourni est une expression constante ou non, vous ne pouvez donc pas différencier automatiquement les littéraux fournis et les valeurs d'exécution.

Si le paramètre doit être un paramètre de fonction, et que vous ne souhaitez pas changer la façon dont il est appelé dans les deux cas, alors le seul levier dont vous disposez ici est le type du paramètre : vos suggestions pour Constante <1> () vs Var (inc) sont plutôt bonnes à cet égard.

Si l'objectif ici est simplement d'optimiser, plutôt que d'activer l'utilisation dans un contexte de compilation, vous pouvez donner au compilateur des indications sur votre intention:

// give the compiler a hint that it can optimize `f` with knowledge of `cond`
template<typename Func>
auto optimize_for(bool cond, Func&& f) {
    if (cond) {
        return std::forward<Func>(f)();
    }
    else {
        return std::forward<Func>(f)();
    }
}

float calcLength(const float *v, int size, int inc) {
    return optimize_for(inc == 1, [&]{
        float l = 0;
        for (int i=0; i<size*inc; i += inc) {
            l += v[i]*v[i];
        }
        return sqrt(l);
    });
}

Depuis godbolt , vous pouvez voir que calcLength_inner a été instancié deux fois, avec et sans la propagation constante.

Ceci est une astuce C (et est largement utilisée dans numpy), mais vous pouvez écrire un simple wrapper pour le rendre plus facile à utiliser en c ++:

static float calcLength_inner(const float *v, int size, int inc) {
    float l = 0;

    for (int i=0; i<size*inc; i += inc) {
        l += v[i]*v[i];
    }
    return sqrt(l);
}

float calcLength(const float *v, int size, int inc) {
    if (inc == 1) {
        return calcLength_inner(v, size, inc);  // compiler knows inc == 1 here, and will optimize
    }
    else {
        return calcLength_inner(v, size, inc);
    }
}

Option 1: Faites confiance à votre compilateur (c'est-à-dire ne rien faire)

Les compilateurs peuvent-ils faire ce que vous voulez sans que vous leviez le petit doigt (eh bien, vous devez activer les compilations optimisées, mais cela va sans dire).

Les compilateurs peuvent créer ce qu'on appelle des "clones de fonction", qui font ce que vous voulez. Une fonction de clonage est une copie d'une fonction utilisée pour la propagation constante, c'est-à-dire l'assemblage résultant d'une fonction appelée avec des arguments constants. J'ai trouvé peu de documentation sur cette fonctionnalité, donc c'est à vous si vous voulez vous y fier.

Le compilateur peut totalement intégrer cette fonction, ce qui pourrait faire de votre problème un non-problème (vous pouvez l'aider en en le définissant en ligne dans un en-tête, en utilisant lto et / ou en utilisant des attributs spécifiques au compilateur comme __attribute__((always_inline)))

Maintenant, je ne prêche pas de laisser le compilateur faire son emploi. Bien que les optimisations du compilateur soient incroyables ces temps-ci et que la règle de base soit de faire confiance à l'optimiseur, il y a des situations où vous devez intervenir manuellement. Je dis juste d'en être conscient et d'en tenir compte. Oh, et comme toujours mesurer, mesurer, mesurer quand il s'agit de performances, n'utilisez pas votre instinct "Je sens ici que j'ai besoin d'optimiser".

Option 2: Deux surcharges

calcLength(v, size, inc); // ok
calcLength<1>(v, size);   // ok
calcLength(v, size, 1);   // nope

L'inconvénient ici est la duplication de code, ofc. Aussi peu de précautions doivent être prises sur le site d'appel:

float calcLength(const float *v, int size, int inc) {
    float l = 0;

    for (int i=0; i<size*inc; i += inc) {
        l += v[i]*v[i];
    }
    return sqrt(l);
}

template <int Inc>
float calcLength(const float *v, int size) {
    float l = 0;

    for (int i=0; i<size*inc; i += inc) {
        l += v[i]*v[i];
    }
    return sqrt(l);
}

Option 3: Votre version

Votre version est correcte.

h1>