Ví dụ về gotos tốt trong C hoặc C ++ [đóng]

Trong chủ đề này, chúng tôi xem xét các ví dụ về cách sử dụng tốt gototrong C hoặc C ++. Nó được lấy cảm hứng từ một câu trả lời mà mọi người đã bình chọn vì họ nghĩ rằng tôi đang nói đùa.

Tóm tắt (nhãn được thay đổi so với ban đầu để làm cho ý định rõ ràng hơn):

infinite_loop:

    // code goes here

goto infinite_loop;

Tại sao nó tốt hơn các lựa chọn thay thế:

• Nó cụ thể. gotolà cấu trúc ngôn ngữ tạo ra một nhánh không điều kiện. Các lựa chọn thay thế phụ thuộc vào việc sử dụng cấu trúc hỗ trợ các nhánh có điều kiện, với điều kiện suy biến luôn đúng.
• Nhãn ghi lại ý định mà không có chú thích thêm.
• Người đọc không cần phải quét mã can thiệp sớm break(mặc dù vẫn có thể cho một hacker chưa có kinh nghiệm mô phỏng continuesớm goto).

Quy tắc:

• Giả vờ rằng gotophobes không thắng. Người ta hiểu rằng những điều trên không thể được sử dụng trong mã thực vì nó đi ngược lại với thành ngữ đã có.
• Giả sử rằng tất cả chúng ta đã nghe nói về 'Goto bị coi là có hại' và biết rằng goto có thể được sử dụng để viết mã spaghetti.
• Nếu bạn không đồng ý với một ví dụ, hãy chỉ trích nó về mặt kỹ thuật ('Bởi vì mọi người không thích goto' không phải là lý do kỹ thuật).

Hãy xem liệu chúng ta có thể nói về điều này như những người trưởng thành không.

Biên tập

Câu hỏi này dường như đã kết thúc ngay bây giờ. Nó tạo ra một số câu trả lời chất lượng cao. Cảm ơn tất cả mọi người, đặc biệt là những người đã coi trọng ví dụ về vòng lặp nhỏ của tôi. Hầu hết những người hoài nghi đều lo lắng bởi việc thiếu phạm vi khối. Như @quinmars đã chỉ ra trong một nhận xét, bạn luôn có thể đặt các dấu ngoặc nhọn xung quanh thân vòng lặp. Tôi lưu ý khi vượt qua điều đó for(;;)và while(true)không cung cấp cho bạn niềng răng miễn phí (và việc bỏ qua chúng có thể gây ra lỗi khó chịu). Dù sao đi nữa, tôi sẽ không lãng phí thêm sức mạnh trí não của bạn vào chuyện vặt vãnh này - Tôi có thể sống với những điều vô hại và thành ngữ for(;;)và while(true)(cũng như nếu tôi muốn tiếp tục công việc của mình).

Xem xét các phản hồi khác, tôi thấy rằng nhiều người xem gotonhư một thứ mà bạn luôn phải viết lại theo cách khác. Tất nhiên bạn có thể tránh một gotobằng cách giới thiệu một vòng lặp, một cờ bổ sung, một chồng các ifs lồng nhau , hoặc bất cứ điều gì, nhưng tại sao không xem xét liệu gotocó lẽ là công cụ tốt nhất cho công việc? Nói cách khác, mọi người chuẩn bị chịu đựng sự xấu xí đến mức nào để tránh sử dụng một tính năng ngôn ngữ tích hợp cho mục đích dự định của nó? Ý kiến ​​của tôi là ngay cả việc thêm một lá cờ cũng là một cái giá quá cao. Tôi thích các biến của mình đại diện cho những thứ trong miền vấn đề hoặc giải pháp. 'Chỉ để tránh một goto' không cắt bỏ nó.

Tôi sẽ chấp nhận câu trả lời đầu tiên đưa ra mẫu C để phân nhánh cho một khối dọn dẹp. IMO, điều này là trường hợp mạnh nhất cho một gototrong số tất cả các câu trả lời đã đăng, chắc chắn nếu bạn đo lường nó bằng những thách thức mà người ghét phải trải qua để tránh nó.

Đây là một mẹo mà tôi đã nghe về những người sử dụng. Tôi chưa bao giờ nhìn thấy nó trong tự nhiên. Và nó chỉ áp dụng cho C vì C ++ có RAII để làm điều này một cách dễ hiểu hơn.

void foo()
{
    if (!doA())
        goto exit;
    if (!doB())
        goto cleanupA;
    if (!doC())
        goto cleanupB;

    /* everything has succeeded */
    return;

cleanupB:
    undoB();
cleanupA:
    undoA();
exit:
    return;
}

Nhu cầu cổ điển cho GOTO trong C như sau

for ...
  for ...
    if(breakout_condition) 
      goto final;

final:

Không có cách nào đơn giản để thoát ra khỏi các vòng lồng nhau mà không có goto.

Đây là ví dụ không ngớ ngẩn của tôi, (từ Stevens APITUE) cho các cuộc gọi hệ thống Unix có thể bị gián đoạn bởi một tín hiệu.

restart:
    if (system_call() == -1) {
        if (errno == EINTR) goto restart;

        // handle real errors
    }

Thay thế là một vòng lặp suy biến. Phiên bản này đọc giống như tiếng Anh "nếu cuộc gọi hệ thống bị gián đoạn bởi một tín hiệu, hãy khởi động lại nó".

Nếu thiết bị của Duff không cần goto, thì bạn cũng không nên! ;)

void dsend(int count) {
    int n;
    if (!count) return;
    n = (count + 7) / 8;
    switch (count % 8) {
      case 0: do { puts("case 0");
      case 7:      puts("case 7");
      case 6:      puts("case 6");
      case 5:      puts("case 5");
      case 4:      puts("case 4");
      case 3:      puts("case 3");
      case 2:      puts("case 2");
      case 1:      puts("case 1");
                 } while (--n > 0);
    }
}

mã trên từ mục nhập Wikipedia .

Knuth đã viết một bài báo "Lập trình có cấu trúc với câu lệnh GOTO", bạn có thể lấy ví dụ từ đây . Bạn sẽ tìm thấy nhiều ví dụ ở đó.

Rất phổ biến.

do_stuff(thingy) {
    lock(thingy);

    foo;
    if (foo failed) {
        status = -EFOO;
        goto OUT;
    }

    bar;
    if (bar failed) {
        status = -EBAR;
        goto OUT;
    }

    do_stuff_to(thingy);

OUT:
    unlock(thingy);
    return status;
}

Trường hợp duy nhất tôi từng sử dụng gotolà nhảy về phía trước, thường là ra khỏi khối và không bao giờ vào khối. Điều này tránh lạm dụng do{}while(0)và các cấu trúc khác làm tăng việc lồng vào nhau, trong khi vẫn duy trì mã có cấu trúc, có thể đọc được.

Tôi không có gì chống lại gotos nói chung, nhưng tôi có thể nghĩ ra một số lý do tại sao bạn không muốn sử dụng chúng cho một vòng lặp như bạn đã đề cập:

• Nó không giới hạn phạm vi do đó bất kỳ biến tạm thời nào bạn sử dụng bên trong sẽ không được giải phóng cho đến sau này.
• Nó không giới hạn phạm vi do đó nó có thể dẫn đến lỗi.
• Nó không giới hạn phạm vi do đó bạn không thể sử dụng lại các tên biến tương tự sau này trong mã tương lai trong cùng phạm vi.
• Nó không giới hạn phạm vi do đó bạn có cơ hội bỏ qua khai báo biến.
• Mọi người không quen với nó và nó sẽ làm cho mã của bạn khó đọc hơn.
• Các vòng lặp lồng nhau của loại này có thể dẫn đến mã spaghetti, các vòng lặp thông thường sẽ không dẫn đến mã spaghetti.

Một điểm tốt để sử dụng goto là trong một quy trình có thể hủy bỏ tại một số điểm, mỗi điểm yêu cầu nhiều mức độ dọn dẹp khác nhau. Gotophobes luôn có thể thay thế gotos bằng mã có cấu trúc và một loạt các bài kiểm tra, nhưng tôi nghĩ điều này đơn giản hơn vì nó loại bỏ thụt lề quá mức:

if (! openDataFile ())
  goto bỏ;

if (! getDataFromFile ())
  goto closeFileAndQuit;

if (! secureSomeResources)
  goto freeResourcesAndQuit;

// Làm thêm ở đây ....

freeResourcesAndQuit:
   // tài nguyên miễn phí
closeFileAndQuit:
   // Đóng tập tin
bỏ:
   // bỏ đi!

@ fizzer.myopenid.com: đoạn mã đã đăng của bạn tương đương với đoạn mã sau:

    while (system_call() == -1)
    {
        if (errno != EINTR)
        {
            // handle real errors

            break;
        }
    }

Tôi chắc chắn thích hình thức này hơn.

Mặc dù tôi ngày càng ghét mô hình này theo thời gian, nhưng nó đã đi sâu vào lập trình COM.

#define IfFailGo(x) {hr = (x); if (FAILED(hr)) goto Error}
...
HRESULT SomeMethod(IFoo* pFoo) {
  HRESULT hr = S_OK;
  IfFailGo( pFoo->PerformAction() );
  IfFailGo( pFoo->SomeOtherAction() );
Error:
  return hr;
}

Đây là một ví dụ về goto tốt:

// No Code

Tôi đã thấy goto được sử dụng đúng cách nhưng các tình huống bình thường rất xấu. Nó chỉ là khi việc sử dụng của gotochính nó kém hơn rất nhiều so với ban đầu. @Johnathon Holland vấn đề là phiên bản của bạn kém rõ ràng hơn. mọi người dường như sợ hãi các biến cục bộ:

void foo()
{
    bool doAsuccess = doA();
    bool doBsuccess = doAsuccess && doB();
    bool doCsuccess = doBsuccess && doC();

    if (!doCsuccess)
    {
        if (doBsuccess)
            undoB();
        if (doAsuccess)
            undoA();
    }
}

Và tôi thích các vòng lặp như thế này nhưng một số người thích hơn while(true).

for (;;)
{
    //code goes here
}

Mối quan tâm của tôi về điều này là bạn mất phạm vi khối; bất kỳ biến cục bộ nào được khai báo giữa các gotos vẫn còn hiệu lực nếu vòng lặp bị phá vỡ. (Có thể bạn đang giả định rằng vòng lặp chạy mãi mãi; tôi không nghĩ đó là điều mà người viết câu hỏi ban đầu đã hỏi.)

Vấn đề về phạm vi là một vấn đề với C ++, vì một số đối tượng có thể phụ thuộc vào dtor của chúng được gọi vào những thời điểm thích hợp.

Đối với tôi, lý do tốt nhất để sử dụng goto là trong quá trình khởi tạo nhiều bước trong đó điều quan trọng là tất cả các inits đều được sao lưu nếu một lỗi không thành công, đó là:

if(!foo_init())
  goto bye;

if(!bar_init())
  goto foo_bye;

if(!xyzzy_init())
  goto bar_bye;

return TRUE;

bar_bye:
 bar_terminate();

foo_bye:
  foo_terminate();

bye:
  return FALSE;

Bản thân tôi không sử dụng goto, tuy nhiên tôi đã từng làm việc với một người sẽ sử dụng chúng trong các trường hợp cụ thể. Nếu tôi nhớ không lầm, cơ sở lý luận của anh ấy là xung quanh các vấn đề về hiệu suất - anh ấy cũng có các quy tắc cụ thể về cách thức . Luôn có cùng một hàm và nhãn luôn ở DƯỚI ĐÂY của câu lệnh goto.

#include <stdio.h>
#include <string.h>

int main()
{
    char name[64];
    char url[80]; /*The final url name with http://www..com*/
    char *pName;
    int x;

    pName = name;

    INPUT:
    printf("\nWrite the name of a web page (Without www, http, .com) ");
    gets(name);

    for(x=0;x<=(strlen(name));x++)
        if(*(pName+0) == '\0' || *(pName+x) == ' ')
        {
            printf("Name blank or with spaces!");
            getch();
            system("cls");
            goto INPUT;
        }

    strcpy(url,"http://www.");
    strcat(url,name);
    strcat(url,".com");

    printf("%s",url);
    return(0);
}

@Greg:

Tại sao không làm ví dụ của bạn như thế này:

void foo()
{
    if (doA())
    {    
        if (doB())
        {
          if (!doC())
          {
             UndoA();
             UndoB();
          }
        }
        else
        {
          UndoA();
        }
    }
    return;
}