Литейная изменчивая переменная в c

Question

Я думаю, у меня есть сложный вопрос, но я уверен, что вы сможете мне помочь. Скажем, у меня есть функция, как это:

char my_function (int example); 

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

Сценарий 1:

Прототип char my_function (int example);

int a; 
volatile int b; 

my_function (a); // Everything is fine. 
my_function ((int)b); // Avoided the warning, by casting the variable and   saying it's no longer volatile. 

Сценарий 2:

Прототип char my_function (volatile int example);

int a; 
volatile int b; 

my_function(b); // Everything is fine. 
my_function((volatile int)a); // Avoided the warning, by casting 'a' saying that now it's volatile. 

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

Answer 1

Это действительно зависит от того, что my_functionделает с его аргументом.

Помните, что volatile предотвращает определенные оптимизации - в основном это заставляет переменную перечитывать каждый раз, когда она ссылается. Таким образом, этот код

volatile int a; 
int b; 
// ... 
b = a + 1; 
b = a + 2; 

прочтет a для каждого оператора и, как a могут быть изменены значения между ними, дают правильный результат.

Когда вы передаете volatile в функцию в качестве параметра, вы получаете только одну переменную read. Это может затем использоваться несколько раз в пределах функции (эффективно теряя природу volatile).

Помните, что C является передачей по значению. При вызове функции в качестве

my_function((int)b); // b is declared volatile 

Компилятор генерирует код для чтения b один раз в коде вызова, и нажать значение прочитанную в стек (обычно), а затем вызвать my_function. Затем эта копия ссылается на my_function как example, и независимо от того, как часто вы ссылаетесь на example, вы всегда будете получать одинаковое значение (даже если переменная b с тех пор неоднократно менялась).

Это может быть именно то, что вы хотите - сделайте снимок переменной и выполните несколько вычислений по ее значению.

Если это не то, что вы хотите, вам необходимо обратиться в указатель с соответствующими квалификациями volatile.

char my_function(volatile int *example); 

И назвать это таким образом:

my_function(&a); 
my_function(&b); 

Тогда ссылка *example внутри my_function.

Answer 2

Листинг фактически ничего не делает. В вызове my_function (b); код читает volatile int b. Именно там «волатильность» имеет значение во время чтения. Результат чтения уже является int, а не изменчивым int. Нет значений volatile int. Даже если бы были измененные значения int, передача его в my_function превращала бы его в простой int, как это делает cast.

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