Могу ли я вычислить pow(10,x) во время компиляции в c?

Вы можете использовать научное представление для значений с плавающей запятой, которое является частью языка C. Это выглядит так:

e = 1.602E-19   // == 1.602 * pow(10, -19)

Число перед E (E может быть заглавным или маленьким 1.602e-19) является дробной частью, где (со знаком) цифровая последовательность после E является экспоненциальной частью. По умолчанию число имеет тип double, но вы можете добавить суффикс с плавающей запятой (f, F, l или L), если вам нужен float или long double.

Я бы не рекомендовал упаковывать эту семантику в макрос:

1. Это не будет работать для переменных, значений с плавающей запятой и т. д.
2. Научная нотация более читабельна.

Существует очень мало возможных значений до переполнения int (или даже long). Ради ясности, сделайте это таблицей!

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

GCC сделает это на достаточно высоком уровне оптимизации (за меня это делает -O1). Например:

#include <math.h>

int test() {
        double x = pow(10, 4);
        return (int)x;
}

Компилируется в -O1 -m32 в:

        .file   "test.c"
        .text
.globl test
        .type   test, @function
test:
        pushl   %ebp
        movl    %esp, %ebp
        movl    $10000, %eax
        popl    %ebp
        ret
        .size   test, .-test
        .ident  "GCC: (Ubuntu 4.3.3-5ubuntu4) 4.3.3"
        .section        .note.GNU-stack,"",@progbits

Это работает и без приведения — конечно, вы получаете инструкцию загрузки с плавающей запятой, как в Linux ABI передает возвращаемые значения с плавающей запятой в регистры FPU.

Вы можете сделать это с помощью Boost.Preprocessor:

http://www.boost.org/doc/libs/1_39_0/libs/preprocessor/doc/index.html

Код:

#include <boost/preprocessor/repeat.hpp>

#define _TIMES_10(z, n, data) * 10
#define POW_10(n) (1 BOOST_PP_REPEAT(n, _TIMES_10, _))

int test[4] = {POW_10(0), POW_10(1), POW_10(2), POW_10(3)};

На самом деле, используя препроцессор C, вы можете заставить его вычислять C pow(10, x) для любого реального C и интегрального x. Обратите внимание, что, как отметил @quinmars, C позволяет использовать научный синтаксис для выражения числовых констант:

#define myexp 1.602E-19   // == 1.602 * pow(10, -19)

использоваться для констант. Имея это в виду и немного смекалки, мы можем создать макрос препроцессора, который принимает C и x и объединяет их в токен возведения в степень:

#define EXP2(a, b) a ## b
#define EXP(a, b) EXP2(a ## e,b)
#define CONSTPOW(C,x) EXP(C, x)

Теперь это можно использовать как постоянное числовое значение:

const int myint = CONSTPOW(3, 4); // == 30000
const double myfloat = CONSTPOW(M_PI, -2); // == 0.03141592653

На самом деле у вас есть M4, препроцессор которого намного мощнее, чем у GCC. Основное различие между ними заключается в том, что GCC не является рекурсивным, в отличие от M4. Это делает возможными такие вещи, как выполнение арифметических операций во время компиляции (и многое другое!). Приведенный ниже пример кода — это то, что вы хотели бы сделать, не так ли? Я сделал его громоздким в однофайловом исходнике; но я обычно помещаю определения макросов M4 в отдельные файлы и настраиваю свои правила Makefile. Таким образом, ваш код защищен от уродливых навязчивых определений M4 в исходный код C, который я сделал здесь.

$ cat foo.c
define(M4_POW_AUX, `ifelse($2, 1, $1, `eval($1 * M4_POW_AUX($1, decr($2)))')')dnl
define(M4_POW, `ifelse($2, 0, 1, `M4_POW_AUX($1, $2)')')dnl

#include <stdio.h>

int                     main(void)
{
  printf("2^0 = %d\n", M4_POW(2, 0));
  printf("2^1 = %d\n", M4_POW(2, 1));
  printf("2^4 = %d\n", M4_POW(2, 4));

  return 0;
}

Командная строка для компиляции этого примера кода использует возможности GCC и M4 для чтения из стандартного ввода.

$ cat foo.c | m4 - | gcc -x c -o m4_pow -
$ ./m4_pow
2^0 = 1
2^1 = 2
2^4 = 16

Надеюсь, это поможет!

В последних версиях GCC (около 4.3) добавлена ​​возможность использовать GMP и MPFR для оптимизации времени компиляции путем оценки более сложных функций, которые являются постоянными. Такой подход делает ваш код простым и переносимым, и вы можете доверить компилятору всю тяжелую работу.

Конечно, есть пределы тому, что он может сделать. Вот ссылка на описание в журнале изменений, которое включает список функций, которые поддерживаются этим. "pow" - один из них.

Если вам просто нужно использовать значение во время во время компиляции, используйте научное обозначение например 1e2 для pow(10, 2)

Если вы хотите заполнить значения во время компиляции, а затем использовать их позже во время выполнения, просто используйте таблицу поиска, потому что есть только 23 различных степени числа 10, которые точно совпадают представляемый с двойной точностью

double POW10[] = {1., 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10,
1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22};

Вы можете получить большую степень 10 во время выполнения из приведенной выше таблицы поиска, чтобы быстро получить результат без необходимости умножать на 10 снова и снова, но результатом будет просто значение, близкое к степени 10, например, когда вы используете 10eX с X > 22

double pow10(int x)
{
   if (x > 22)
      return POW10[22] * pow10(x - 22);
   else if (x >= 0)
      return POW10[x];
    else
        return 1/pow10(-x);
}

Если отрицательные показатели не нужны, то последнюю ветвь можно удалить.

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

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

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