Привет! По заголовку темы непонятно, что требуется, попробую объяснить.
Нужно сделать функцию, которой передается довольно много параметров, часть которых задаются один раз при запуске программы, т.е. не изменяются в течение работы, а функция вызывается постоянно при работе программы — т.е. функция должна выполняться максимально быстро (работаю на микроконтроллере). Можно эти параметры определить как глобальные переменные или константы и все ОК, но хотелось бы чтобы функция не использовала глобальные переменные (нужно сделать реентрабельную функцию). Можно передать по указателю или по значению, но тогда получается, что всегда при вызове функции буду передавать постоянные значения — как-то криво. Если же запихнуть внутрь функции, то получается там буду делать присваивание при вызове, что отнимает ресурсы. Предложите, пожалуйста, решение если вообще это возможно?

Вот варианты которые не подходят
1. Глобальные преременные — плохо
int a=10;
int b=20;
int c=30;
int func(int m,n)
{
...
};

2. По значенияю или указателю — самый хороший вариант, но постоянно передаю конст. значения при вызове
int a=10;
int b=20;
int c=30;
int func(int m,n,a,b)
{
...
};

3. Как локальные — при каждом вызове функции будет тратится проц. время на присваивание
int func(int m,n)
{
int a=10;
int b=20;
int c=30;
...
};

Заранее спасибо.

Здравствуйте, alx7235, Вы писали:

A>Можно эти параметры определить как глобальные переменные или константы и все ОК, но хотелось бы чтобы функция не использовала глобальные переменные (нужно сделать реентрабельную функцию).
Если функция их не меняет -- она будет реентрабельной. Если меняет -- делайте копию внутри функции, и работайте с этой копией.
Еще иногда стоит вынести такие переменные в структуру "контекст", и передавать в функцию указатель на нее.

Здравствуйте, alx7235, Вы писали:

A>Привет! По заголовку темы непонятно, что требуется, попробую объяснить.
A>Нужно сделать функцию, которой передается довольно много параметров, часть которых задаются один раз при запуске программы, т.е. не изменяются в течение работы, а функция вызывается постоянно при работе программы — т.е. функция должна выполняться максимально быстро (работаю на микроконтроллере). Можно эти параметры определить как глобальные переменные или константы и все ОК, но хотелось бы чтобы функция не использовала глобальные переменные (нужно сделать реентрабельную функцию). Можно передать по указателю или по значению, но тогда получается, что всегда при вызове функции буду передавать постоянные значения — как-то криво. Если же запихнуть внутрь функции, то получается там буду делать присваивание при вызове, что отнимает ресурсы. Предложите, пожалуйста, решение если вообще это возможно?

A>Вот варианты которые не подходят
A>1. Глобальные преременные — плохо
A>int a=10;
A>int b=20;
A>int c=30;
A>int func(int m,n)
A>{
A>...
A>};

A>2. По значенияю или указателю — самый хороший вариант, но постоянно передаю конст. значения при вызове
A>int a=10;
A>int b=20;
A>int c=30;
A>int func(int m,n,a,b)
A>{
A>...
A>};

A>3. Как локальные — при каждом вызове функции будет тратится проц. время на присваивание
A>int func(int m,n)
A>{
A>int a=10;
A>int b=20;
A>int c=30;
A>...
A>};

A>Заранее спасибо.


Не понимаю, чем тебя смущает второй вариант? Ну и пусть константные значения, что в этом плохого??

Здравствуйте, alx7235, Вы писали:

...

A>Вот варианты которые не подходят

A>3. Как локальные — при каждом вызове функции будет тратится проц. время на присваивание
A>int func(int m,n)
A>{
A>int a=10;
A>int b=20;
A>int c=30;
A>...
A>};

A>Заранее спасибо.

Я бы посоветовал испытать данный вариант (и добавить const), а затем посмотреть сгенерированный
ассемблерный код. Компилятор в состоянии так соптимизировать операции данного типа, что
никакого присваивания на самом деле выполнятся не будет.
К тому же, вопрос реентрабельности функции закрывается, ибо каждый поток будет владеть
своей копией переменных a,b и c.

А вот использовать статические переменные в многопоточном окружении я бы не порекомендовал.

Здравствуйте, alx7235, Вы писали:

A>Привет! По заголовку темы непонятно, что требуется, попробую объяснить.
A>Нужно сделать функцию, которой передается довольно много параметров, часть которых задаются один раз при запуске программы, т.е. не изменяются в течение работы, а функция вызывается постоянно при работе программы — т.е. функция должна выполняться максимально быстро (работаю на микроконтроллере). Можно эти параметры определить как глобальные переменные или константы и все ОК, но хотелось бы чтобы функция не использовала глобальные переменные (нужно сделать реентрабельную функцию).

Ты же сказал, что они не изменяются, так что с чего бы функции стать нереентерабельной?
Так что используй глобальные переменные, либо, если так уж это не нравится, упакую их все в одну структуру и передавай везде const restrict указатель на нее.

A>3. Как локальные — при каждом вызове функции будет тратится проц. время на присваивание
A>int func(int m,n)
A>{
A>int a=10;
A>int b=20;
A>int c=30;
A>...
A>};
Ну, то, что у тебя тут написано — это константы времени компиляции, так что компилятор должен просто везде вставить соответствующие константы прямо в код.

You will always get what you always got
  If you always do  what you always did

Здравствуйте, alx7235, Вы писали:

A>Привет! По заголовку темы непонятно, что требуется, попробую объяснить.

мысли в ассемблерных терминах, остальное — syntax sugar. вариантов 2: либо у тебя при вызове функции всегда один и тот же контекст, тогда их можно запихать в globals. либо контекст разный, тогда его можно передать ссылкой (и опционально считать в локальные переменные частоиспользуемое). второй вариант можно синтаксически зашугарить, превратив функцию в метод класса-контекста