-----> json-bignum https://www.npmjs.com/package/json-bignum & lt; ------ JSON parser!
GMP (многократная точность GNU) с javascript https://github.com/jtobey/javascript-bignum/blob/master/src/gmp-example.html
Вы можете сделать следующее: Предположим, у вас есть A, B & amp; C функционирует следующим образом:
bool A()
{
.....
}
bool B()
{
.....
}
bool C()
{
.....
}
Теперь о какой-то другой функции, скажем в основном:
int main()
{
bool (*choice) ();
// now if there is if-else statement for making "choice" to
// point at a particular function then proceed as following
if ( x == 1 )
choice = A;
else if ( x == 2 )
choice = B;
else
choice = C;
if(choice())
printf("Success\n");
else
printf("Failure\n");
.........
.........
}
Помните, что это один пример для указателя на функцию. Есть несколько других методов, для которых вам нужно четко изучить указатель на функцию.
Вызов функции через указатель функции
float add(int , float),result;
int main()
{
float (*fp)(int,float);
float result;
fp=add;
result=add(5,10.9); // Normal calling
printf("%f\n\n",result);
result=(*fp)(5,10.9); //calling via function Pointer
printf("%f\n\n",result);
result=(fp)(5,10.9); //calling via function Pointer,Indirection Operator can Be
omitted
printf("%f",result);
getch();
}
float add(int a,float b)
{
return a+b;
}
Выход
15.90000
15.90000
15.90000
На этот вопрос более чем адекватно ответили, но вы можете найти это полезным: Учебники по указателям на функции . Это по-настоящему всеобъемлющее изложение предмета в пяти главах!
Если вам нужна помощь со сложными определениями, например:
double (*(*pf)())[3][4];
Взгляните на мое Правило слева направо здесь .
//Declare the pointer and asign it to the function
bool (*pFunc)() = A;
//Call the function A
pFunc();
//Call function B
pFunc = B;
pFunc();
//Call function C
pFunc = C;
pFunc();
Немного другой подход:
bool A() {...}
bool B() {...}
bool C() {...}
int main(void)
{
/**
* Declare an array of pointers to functions returning bool
* and initialize with A, B, and C
*/
bool (*farr[])() = {A, B, C};
...
/**
* Call A, B, or C based on the value of i
* (assumes i is in range of array)
*/
if (farr[i]()) // or (*farr[i])()
{
...
}
...
}
Я обычно использую typedef, чтобы сделать это, но это может быть излишним, если вам не нужно использовать указатель на функцию слишком часто ..
//assuming bool is available (where I come from it is an enum)
typedef bool (*pmyfun_t)();
pmyfun_t pMyFun;
pMyFun=A; //pMyFun=&A is actually same
pMyFun();
Лучший способ прочитать это «Правило по часовой стрелке / спираль»
Дэвид Андерсон
bool (*FuncPtr)()
FuncPtr = A;
FuncPtr();
Если вы хотите вызвать одну из этих функций условно, вам следует рассмотреть возможность использования массива указателей на функции . В этом случае у вас будет 3 элемента, указывающих на A, B и C, и вы вызовете один из них в зависимости от индекса массива, например funcArray0 для A.
Вы объявляете переменную указателя функции для заданной сигнатуры ваших функций следующим образом:
bool (* fnptr)();
вы можете назначить ей одну из ваших функций:
fnptr = A;
и вы можете вызвать it:
bool result = fnptr();
Вы можете рассмотреть возможность использования typedefs для определения типа для каждой отдельной сигнатуры функции, которая вам нужна. Это облегчит чтение и обслуживание кода. то есть для сигнатуры функций, возвращающих bool без аргументов, это может быть:
typdef bool (* BoolFn)();
, и затем вы можете использовать вот так, чтобы объявить переменную-указатель функции для этого типа:
BoolFn fnptr;
Вы можете объявить указатель функции следующим образом:
bool (funptr*)();
Что говорит о том, что мы объявляем указатель функции на функцию, которая ничего не берет и возвращает bool.
Следующее назначение:
funptr = A;
Чтобы вызвать функцию с помощью указателя функции:
funptr();
первоначально определяют массив указателей на функции, который принимает пустоту и возвращает пустоту. предполагая, что ваша функция - взять пустоту и вернуть пустоту.
typedef void (*func_ptr)(void);
Теперь вы можете использовать это для создания переменных указателя на функцию таких функций. как показано ниже:
func_ptr array_of_fun_ptr[3];
теперь сохраняют адрес ваших функций в трех переменных.
array_of_fun_ptr[0]= &A;
array_of_fun_ptr[1]= &B;
array_of_fun_ptr[2]= &C;
теперь вы можете вызывать эти функции, используя указатели функций, как показано ниже:
some_a=(*(array_of_fun_ptr[0]))();
some_b=(*(array_of_fun_ptr[1]))();
some_c=(*(array_of_fun_ptr[2]))();
Обратите внимание, что когда вы говорите:
bool (*a)();
вы объявляете a
типа «указатель на функцию, возвращающую bool
и принимающую неопределенное количество параметров». Предполагая, что bool
определено (возможно, вы используете C99 и включили stdbool.h
, или это может быть typedef), это может или не может быть тем, что вы хотите.
Проблема здесь в том, что у компилятора нет способа проверить, присвоено ли a
правильное значение. Та же проблема существует с вашими объявлениями функций. A()
, B()
и C()
все объявлены как функции, «возвращающие bool
и принимающие неопределенное количество параметров».
Чтобы увидеть, какие проблемы могут возникнуть, давайте напишем программу:
#include <stdio.h>
int test_zero(void)
{
return 42;
}
static int test_one(char *data)
{
return printf("%s\n", data);
}
int main(void)
{
/* a is of type "pointer to function returning int
and taking unspecified number of parameters */
int (*a)();
/* b is of type "pointer to function returning int
and taking no parameters */
int (*b)(void);
/* This is OK */
a = test_zero;
printf("a: %d\n", a());
a = test_one; /* OK, since compiler doesn't check the parameters */
printf("a: %d\n", a()); /* oops, wrong number of args */
/* This is OK too */
b = test_zero;
printf("b: %d\n", b());
/* The compiler now does type checking, and sees that the
assignment is wrong, so it can warn us */
b = test_one;
printf("b: %d\n", b()); /* Wrong again */
return 0;
}
Когда я компилирую вышеизложенное с помощью gcc, он говорит:
предупреждение: назначение из несовместимого типа указателя
для строки b = test_one;
, что хорошо. Нет предупреждения для соответствующего присвоения a
.
Итак, вы должны объявить свои функции как:
bool A(void);
bool B(void);
bool C(void);
И тогда переменная для хранения функции должна быть объявлена как:
bool (*choice)(void);
bool (*fptr)();
int main(void)
{
...
...
printf("Enter your choice");
scanf("%d",&a);
switch(a)
{
case 0:
fptr = A;
break;
case 1:
fptr = B;
break;
case 2:
fptr = C;
break;
case 3:
break;
}
(*fptr)();
return 0;
}
ваш выбор сохраняется в; Затем, соответственно, функции назначаются в указателе функции. Наконец, в зависимости от вашего выбора вызывается та же самая функция, чтобы вернуть желаемый результат.
Объявите указатель вашей функции следующим образом:
bool (*f)();
f = A;
f();
Я думаю, что на ваш вопрос уже был дан более чем адекватный ответ, но, возможно, было бы полезно явно указать, что при наличии указателя на функцию
void (*pf)(int foo, int bar);
два вызова
pf(1, 0);
(*pf)(1, 0);
абсолютно эквивалентны во всех отношениях по определению. Выбор, который использовать, зависит от вас, хотя это хорошая идея, чтобы быть последовательным. В течение долгого времени я предпочитал (*pf)(1, 0)
, потому что мне казалось, что он лучше отражает тип pf
, однако в последние несколько лет я перешел на pf(1, 0)
.