Многократное назначение в одной строке

Question

Я просто наткнулся на заявление в вложенной с (dsPIC33)

sample1 = sample2 = 0; 

это означало бы

sample1 = 0; 

sample2 = 0; 

Почему они печатают это так? Это хорошее или плохое кодирование?

Answer 1

Помните, что задание выполняется справа налево, и что они нормальные выражения. Таким образом, с точки зрения составителей линия

sample1 = sample2 = 0; 

такая же, как

sample1 = (sample2 = 0); 

, который так же, как

sample2 = 0; 
sample1 = sample2; 

То есть, sample2 присваивается ноль, то sample1 присваивается значение sample2. На практике это то же самое, что присваивать оба значения нулю, как вы догадались.

Answer 2

sample1 = sample2 = 0; 

действительно означает

sample1 = 0; 
sample2 = 0; 

тогда и только тогда, когда sample2 объявлена ​​ранее.
Вы не можете сделать так:

int sample1 = sample2 = 0; //sample1 must be declared before assigning 0 to it 

Answer 3

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

Answer 4

Что касается стиля кодирования и различные рекомендации кодирования смотрите здесь: Readability a=b=c or a=c; b=c;?

Я считаю, что с помощью

sample1 = sample2 = 0; 

некоторые компиляторы будут немного быстрее по сравнению производить сборку 2 задания:

sample1 = 0; 
sample2 = 0; 

специально, если вы инициализируете ненулевое значение. Потому что множественное назначение переводится в:

sample2 = 0; 
sample1 = sample2; 

Итак, вместо 2 инициализаций вы делаете только одну и одну копию. Ускорение (если есть) будет крошечным, но во встроенном случае каждый крошечный бит подсчитывается!

Answer 5

Вы сами можете решить, что этот способ кодирования является хорошим или плохим.

1. Просто ознакомьтесь с кодом сборки для следующих линий в вашей среде IDE.

2. Затем измените код на два отдельных назначения и увидите различия.

В дополнение к этому, вы также можете попробовать отключить/на оптимизацию (оба размера & Оптимизация скорости) в вашем компиляторе, чтобы увидеть, как это влияет на код сборки.

Answer 6

Как и другие, порядок, в котором это выполняется, является детерминированным. приоритет оператора оператора = гарантирует, что это выполняется справа налево. Другими словами, он гарантирует, что sample2 получает значение перед образцом1.

Однако, несколько присвоений в одной строке являются плохой практикой и запрещены многими стандартами кодирования (*). Прежде всего, это не особенно читаемо (или вы не задавали бы этот вопрос). Во-вторых, это опасно. Если мы имеем, например

sample1 = func() + (sample2 = func()); 

, то приоритет операторов гарантирует одинаковый порядок исполнения, как и раньше (+ имеет более высокий приоритет, чем =, поэтому скобка). sample2 получит значение перед sample1. Но в отличие от приоритета оператора, порядок оценки операторов не является детерминированным, это неуказанное поведение. Мы не можем знать, что вызов самой правой функции оценивается до самого левого.

компилятор волен переводить выше в машинный код, как это:

int tmp1 = func(); 
int tmp2 = func(); 
sample2 = tmp2; 
sample1 = tmp1 + tmp2; 

Если код зависит от FUNC() получение выполняются в определенном порядке, то мы создали неприятную ошибку. Он может работать нормально в одном месте программы, но перерыв в другой части той же программы, даже если код идентичен. Потому что компилятор может свободно оценивать подвыражения в любом порядке, который ему нравится.

---

(*) MISRA-C: 2004 12,2, MISRA-C: 2012 +13,4, CERT-C EXP10-C.

Answer 7

Формально, для двух переменных t и u типа T и U соответственно

T t; 
U u; 

присваивание

t = u = X; 

(где X имеет некоторое значение) интерпретируется как

t = (u = X); 

и эквивалентна паре независимых заданий

u = X; 
t = (U) X; 

Обратите внимание, что значение X предполагается достичь переменной t «как если бы» он прошел через переменную u первый, но нет никакого требования для того, чтобы в буквальном смысле произойдет сюда. X просто должен быть преобразован в тип u перед присвоением t. Значение не обязательно присваивается u, а затем копируется с u в t.Эти два задания фактически не упорядочены и может происходить в любом порядке, а это означает, что

t = (U) X; 
u = X; 

также действительный график выполнения этого выражения. (Обратите внимание, что эта свобода секвенирования специфична для языка C, в которой результат присваивания в r-значении. В присваивании C++ вычисляется значение lvalue, которое требует секвенсирования «цепочек».)

Невозможно скажем, является ли это хорошей или плохой практикой программирования, не видя больше контекста. В случаях, когда две переменные тесно связаны (например, x и y координата точки), установив их на некоторое общее значение, используя «прикованное» назначение, на самом деле является отличной практикой (я бы даже сказал «рекомендуемая практика»). Но когда переменные полностью не связаны друг с другом, смешение их в одном «прикованном» задании, безусловно, не очень хорошая идея. Особенно, если эти переменные имеют разные типы, что может привести к непреднамеренным последствиям.

Answer 8

Я думаю, что нет хорошего ответа на языке C без фактической сборки листинга :)

Так что для упрощенной программы:

int main() { 
     int a, b, c, d; 
     a = b = c = d = 0; 
     return a; 
} 

Я получил эту assemly (Kubuntu, GCC 4.8.2 , x86_64) с -O0 вариантами конечно;)

main: 
     pushq %rbp 
     movq %rsp, %rbp 

     movl $0, -16(%rbp)  ; d = 0 
     movl -16(%rbp), %eax  ; 

     movl %eax, -12(%rbp)  ; c = d 
     movl -12(%rbp), %eax  ; 

     movl %eax, -8(%rbp)  ; b = c 
     movl -8(%rbp), %eax  ; 

     movl %eax, -4(%rbp)  ; a = b 
     movl -4(%rbp), %eax  ; 

     popq %rbp 

     ret       ; return %eax, ie. a 

Так НКУ является фактически цепочкой всех вещей.