Gibt es keine integrierte Möglichkeit zur Berechnung der power bei der Kompilierung in C++?

Habe ich folgende sehr einfache Vorlage. Als ich erfuhr, dass ^ ist nicht die exponentielle operator. Jetzt bin ich auf der Suche nach einem Weg, um zu berechnen, diese macht. Es gibt viele Beispiele, die mit einem rekursiven template auf das internet. Dies ist nicht allzu schwierig.

Aber ich Frage mich: gibt es eigentlich keine "built-in" - Methode in C++ zu berechnen, diese auf die compile-Zeit?

template <int DIM>
class BinIdx : Idx
{
        static const int SIZE = 3 ^ DIM; //whoops, this is NOT an exponential operator!
}

Wenn es sich nur um eine Potenz von zwei sein, verwenden Sie 1 << DIM. Ansonsten, Nein.
für Zweierpotenzen... 1 << DIM :p
Es ist nicht notwendigerweise eine Potenz von 2 ist 😉
Nein. Es gibt auch keine eingebaute compile-time sqrt oder built-in-compile-time exp oder built-in-compile-time log ... glaubst du wirklich, es muss sein?
Sie könnten wahrscheinlich machen einige mit constexpr Funktionen...
Sie können immer darauf zurückgreifen, Vorverarbeitung und source-code-Generierung mit einigen script-Sprache. Es ist manchmal zwar für die Optionen Klassen und dergleichen. Ansonsten, die Antwort ist so kurz wie <<, die für die C++ - Programmierung, die Sie besser in der Lage sein, zu schauen dich.

InformationsquelleAutor Michael | 2014-12-03

c++compile-time-constant templates

5

Können Sie mithilfe von template-metaprogramming. Ich zeige den code.
```
template <int A, int B>
struct get_power
{
    static const int value = A * get_power<A, B - 1>::value;
};
template <int A>
struct get_power<A, 0>
{
    static const int value = 1;
};
```
Verwendung:
```
std::cout << get_power<3, 3>::value << std::endl;
```
(live-Beispiel)
- Die OP ist ausdrücklich aufgefordert, für eine built-in mehr direkte alternative zu template-metaprogramming. Also, das ist nicht ein Antwort.
- Oh, du hast Recht; ich habe nicht die Frage genau Lesen >o<
InformationsquelleAutor ikh
10

Wie bereits erwähnt können Sie << wenn der exponent eine Potenz von zwei.

Andernfalls, wenn die Exponenten sind nicht negative ganze zahlen, schreiben Sie bitte eine constexpr Funktion wie diese.
```
template<typename T, typename U>
auto constexpr pow(T base, U exponent) {
    static_assert(std::is_integral<U>(), "exponent must be integral");
    return exponent == 0 ? 1 : base * pow(base, exponent - 1);
}
```
Wird dies natürlich brechen für große Exponenten als auch die negativen, aber.

Ich bin nicht bewusst, wie gut die Compiler optimieren Sie Funktion Anrufe in Konstanten Ausdrücken. Hier ist eine manuelle Optimierung für die Fälle, in denen die Exponenten eine Potenz von zwei. Dies wird auch eine Verringerung der Menge der Rekursion getan.
```
template<typename T>
bool constexpr is_power_of_two(T x) {
    return (x != 0) && ((x & (x - 1)) == 0);
}

template<typename T, typename U>
auto constexpr pow(T base, U exponent) {
    static_assert(std::is_integral<U>(), "exponent must be integral");
    if (is_power_of_two(exponent)) {
        return base << exponent;
    }
    return exponent == 0 ? 1 : base * pow(base, exponent - 1);
}
```
Effizienter algorithmen sind ebenfalls verfügbar. Allerdings bin ich schlecht in informatik, also ich weiß nicht, wie um Sie zu implementieren.
- Ich denke, der name Ihrer Funktion geändert werden sollte - denn von std::pow >o<
- Ihre Letzte Punkt ist wichtig: es ist leicht zu machen der compiler explodieren mit compile-Zeit-Berechnungen, wenn Sie nicht vorsichtig sind. Das ist ein guter Grund nicht zu etwas wie dies in der standard-Bibliothek
- ICBW aber ich glaube, ich habe gesehen <cmath> Prototypen gekennzeichnet constexpr im GCC
- Warum sagen Sie das? Der springende Punkt bei der std namespace ermöglichen Ihnen sinnvolle Namen, um Ihre eigenen Funktionen ohne die Gefahr, in Konflikt mit der Bibliothek Namen.
- Allerdings pow() ist geerbt von C. In vielen Fällen, können wir sehen Menschen, einschließlich <math.h> statt <cmath>, die bewirken, dass Dinge kaputt zu sein.
- ist nur ein problem mit g++, weil das der compiler die Implementierung oder verwendet werden, um gebrochen zu werden. generell der .h Header sind am günstigsten, nicht den c... - Header, da die c.... Header legen könnten Namen in den globalen namespace und damit code, der nicht kompiliert, mit einigen anderen compiler (also effektiv weniger portablen code).
- oh, sorry für das nicht Lesen der Kontext, aber jetzt, dass ich: mit c.... Header, nicht die situation retten, auch wenn man steuert die ganze code-Basis. weil Sie erlaubte Bezeichner in den globalen namespace in c++11, und weil Sie haben es eh in c++03. also ja, ich Stimme mit Ihnen überein, dass die Funktion sollte besser nicht genannt werden pow. viel besser, wählen Sie eine nicht in Konflikt stehenden Namen.
- Wenn Sie optimieren möchten, eine bessere Optimierung ist die Potenzierung, die durch Quadratur: en.wikipedia.org/wiki/Exponentiation_by_squaring
InformationsquelleAutor rightfold

Als Ergänzung zu elyse Antwort, hier ist eine version mit Rekursionstiefe von log(n):

template<typename T>
constexpr T sqr(T a) {
    return a * a;
}

template<typename T>
constexpr T power(T a, std::size_t n) {
    return n == 0 ? 1 : sqr(power(a, n / 2)) * (n % 2 == 0 ?  1 : a);
}

InformationsquelleAutor Anton Savin

4

Nein, es gibt keine allgemein gebaut in der Weise zu berechnen, die macht der Werte. Es ist die pow - Funktion aus der standard-Bibliothek und können Sie die << shift-operator für den speziellen Fall 2^x.

Dieser arbeiten würde in deinem Fall (*):
```
static const int SIZE = (1 << DIM);
```
* = Aktualisieren Sie Ihre Frage aus 2^x zu 3^x nachdem ich schrieb meine Antwort.

Für einen weiteren Sonderfall x^y, wo x und y sind statisch, Sie können schreiben Sie einfach eine lange Multiplikation:
```
const result int = x*x*x*x*x;
```
InformationsquelleAutor Flovdis

Benannte operator-Bibliothek:

namespace named_operator {
  template<class D>struct make_operator{
    constexpr make_operator(){}
  };
  template<class T, char, class O> struct half_apply { T&& lhs; };

  template<class Lhs, class Op>
  constexpr
  half_apply<Lhs, '*', Op>
  operator*( Lhs&& lhs, make_operator<Op> ) {
    return {std::forward<Lhs>(lhs)};
  }

  template<class Lhs, class Op, class Rhs>
  constexpr auto
  times( Lhs&& lhs, Op, Rhs&& rhs, ... ) //... keeps this the worst option
  -> decltype( invoke( std::declval<Lhs>(), Op{}, std::declval<Rhs>() ) )
  {
    //pure ADL call, usually based off the type Op:
    return invoke( std::forward<Lhs>(lhs), Op{}, std::forward<Rhs>(rhs)     );
  }

  template<class Lhs, class Op, class Rhs>
  constexpr auto
  operator*( half_apply<Lhs, '*', Op>&& lhs, Rhs&& rhs )
  -> decltype(
    times( std::declval<Lhs>(), Op{}, std::declval<Rhs>() )
  )
  {
    return times( std::forward<Lhs>(lhs.lhs), Op{}, std::forward<Rhs>(rhs) );
  }
}

Es unterstützt nur operator*, aber die Verlängerung sollte klar sein. Kommissionierung Namen für times - äquivalente ist ein bisschen ein Problem.

@Anton-Lösung, ergänzt durch eine benannte Betreiber:

namespace power {
  template<typename T>
  constexpr T sqr(T a) {
    return a * a;
  }

  template<typename T>
  constexpr T power(T a, std::size_t n) {
    return n == 0 ? 1 : sqr(power(a, n / 2)) * (n % 2 == 0 ?  1 : a);
  }

  namespace details {
    struct pow_tag {};
    constexpr named_operator::make_operator<pow_tag> pow;

    template<class Scalar>
    constexpr Scalar times( Scalar lhs, pow_tag, std::size_t rhs ) {
      return power( std::forward<Scalar>(lhs), rhs );
    }
  }
  using details::pow;
}

und jetzt das funktioniert:

using power::pow;
int array[ 2 *pow* 10 ] = {0};

live-Beispiel.

InformationsquelleAutor Yakk - Adam Nevraumont

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.