Tại sao câu lệnh chuyển đổi được thiết kế để cần nghỉ ngơi?

Đưa ra một tuyên bố chuyển đổi đơn giản

switch (int)
{
    case 1 :
    {
        printf("1\n");
        break;
    }

    case 2 : 
    {
        printf("2\n");
    }

    case 3 : 
    {
        printf("3\n");
    }
}

Việc không có tuyên bố phá vỡ trong trường hợp 2, ngụ ý rằng việc thực thi sẽ tiếp tục bên trong mã cho trường hợp 3. Đây không phải là một tai nạn; nó được thiết kế theo cách đó Tại sao quyết định này được đưa ra? Điều này mang lại lợi ích gì so với việc có một ngữ nghĩa ngắt tự động cho các khối? Lý do là gì?

Nhiều câu trả lời dường như tập trung vào khả năng vượt qua là lý do để yêu cầu breaktuyên bố.

Tôi tin rằng đó đơn giản chỉ là một sai lầm, phần lớn là do khi C được thiết kế, gần như không có nhiều kinh nghiệm về cách các cấu trúc này sẽ được sử dụng.

Peter Van der Linden đưa ra trường hợp trong cuốn sách "Expert C Lập trình":

Chúng tôi đã phân tích các nguồn trình biên dịch Sun C để xem tần suất rơi mặc định được sử dụng. Mặt trước của trình biên dịch Sun ANSI C có 244 câu lệnh chuyển đổi, mỗi câu lệnh có trung bình bảy trường hợp. Rơi qua xảy ra chỉ trong 3% của tất cả các trường hợp này.

Nói cách khác, hành vi chuyển đổi bình thường là sai 97% thời gian. Nó không chỉ trong một trình biên dịch - ngược lại, trong đó phân tích được sử dụng trong phân tích này, nó thường dành cho các tình huống xảy ra thường xuyên hơn trong trình biên dịch so với các phần mềm khác, ví dụ, khi biên dịch các toán tử có thể có một hoặc hai toán hạng :

switch (operator->num_of_operands) {
    case 2: process_operand( operator->operand_2);
              /* FALLTHRU */

    case 1: process_operand( operator->operand_1);
    break;
}

Trường hợp rơi vào trường hợp được công nhận rộng rãi như là một khiếm khuyết mà thậm chí còn có một quy ước bình luận đặc biệt, được trình bày ở trên, nói với lint "đây thực sự là một trong 3% trường hợp rơi vào trường hợp mong muốn."

Tôi nghĩ rằng C # nên yêu cầu một câu lệnh nhảy rõ ràng ở cuối mỗi khối trường hợp (trong khi vẫn cho phép nhiều nhãn trường hợp được xếp chồng lên nhau - miễn là chỉ có một khối lệnh duy nhất). Trong C #, bạn vẫn có thể có một trường hợp rơi vào trường hợp khác - bạn chỉ cần làm cho cú ngã thông qua rõ ràng bằng cách chuyển sang trường hợp tiếp theo bằng cách sử dụng a goto.

Thật tệ khi Java không có cơ hội thoát khỏi ngữ nghĩa C.

Trong rất nhiều cách, c chỉ là một giao diện sạch cho các thành ngữ lắp ráp tiêu chuẩn. Khi viết điều khiển luồng điều khiển bảng nhảy, lập trình viên có quyền lựa chọn rơi qua hoặc nhảy ra khỏi "cấu trúc điều khiển", và nhảy ra đòi hỏi một hướng dẫn rõ ràng.

Vì vậy, c làm điều tương tự ...

Để triển khai thiết bị của Duff, rõ ràng:

dsend(to, from, count)
char *to, *from;
int count;
{
    int n = (count + 7) / 8;
    switch (count % 8) {
    case 0: do { *to = *from++;
    case 7:      *to = *from++;
    case 6:      *to = *from++;
    case 5:      *to = *from++;
    case 4:      *to = *from++;
    case 3:      *to = *from++;
    case 2:      *to = *from++;
    case 1:      *to = *from++;
               } while (--n > 0);
    }
}

Nếu các trường hợp được thiết kế để phá vỡ hoàn toàn thì bạn không thể có sự sụp đổ.

case 0:
case 1:
case 2:
    // all do the same thing.
    break;
case 3:
case 4:
    // do something different.
    break;
default:
    // something else entirely.

Nếu công tắc được thiết kế để thoát ra sau mỗi trường hợp, bạn sẽ không có lựa chọn nào về nó. Cấu trúc vỏ công tắc được thiết kế theo cách linh hoạt hơn.

Các báo cáo trường hợp trong một báo cáo chuyển đổi chỉ đơn giản là nhãn.

Khi bạn bật một giá trị, câu lệnh switch cơ bản thực hiện một goto đến nhãn với giá trị phù hợp.

Điều này có nghĩa là việc ngắt là cần thiết để tránh chuyển qua mã dưới nhãn tiếp theo.

Đối với lý do tại sao nó được thực hiện theo cách này - bản chất thông qua của một câu lệnh chuyển đổi có thể hữu ích trong một số tình huống. Ví dụ:

case optionA:
    // optionA needs to do its own thing, and also B's thing.
    // Fall-through to optionB afterwards.
    // Its behaviour is a superset of B's.
case optionB:
    // optionB needs to do its own thing
    // Its behaviour is a subset of A's.
    break;
case optionC:
    // optionC is quite independent so it does its own thing.
    break;

Để cho phép những thứ như:

switch(foo) {
case 1:
    /* stuff for case 1 only */
    if (0) {
case 2:
    /* stuff for case 2 only */
    }
    /* stuff for cases 1 and 2 */
case 3:
    /* stuff for cases 1, 2, and 3 */
}

Hãy nghĩ về casetừ khóa như một gotonhãn hiệu và nó xuất hiện tự nhiên hơn rất nhiều.

Nó loại bỏ việc sao chép mã khi một số trường hợp cần thực thi cùng một mã (hoặc cùng mã theo trình tự).

Vì ở cấp độ ngôn ngữ lắp ráp, bạn không quan tâm đến việc bạn có phá vỡ giữa mỗi ngôn ngữ hay không, không có chi phí nào để vượt qua mọi trường hợp, vậy tại sao không cho phép chúng vì chúng mang lại lợi thế đáng kể trong một số trường hợp nhất định.

Tôi tình cờ gặp phải trường hợp gán giá trị trong vectơ cho các cấu trúc: nó phải được thực hiện theo cách nếu vectơ dữ liệu ngắn hơn số lượng thành viên dữ liệu trong cấu trúc, các thành viên còn lại sẽ ở lại giá trị mặc định của chúng. Trong trường hợp đó bỏ qua breaklà khá hữu ích.

switch (nShorts)
{
case 4: frame.leadV1    = shortArray[3];
case 3: frame.leadIII   = shortArray[2];
case 2: frame.leadII    = shortArray[1];
case 1: frame.leadI     = shortArray[0]; break;
default: TS_ASSERT(false);
}

Như nhiều người ở đây đã chỉ định, nó cho phép một khối mã duy nhất hoạt động cho nhiều trường hợp. Điều này nên là một sự xuất hiện phổ biến hơn cho các câu lệnh chuyển đổi của bạn so với "khối mã cho mỗi trường hợp" mà bạn chỉ định trong ví dụ của mình.

Nếu bạn có một khối mã cho mỗi trường hợp mà không bị rơi, có lẽ bạn nên cân nhắc sử dụng khối if-otherif-other, vì điều đó có vẻ phù hợp hơn.