lakukan {…} sementara (salah)

Saya sedang melihat beberapa kode oleh seorang individu dan melihat dia tampaknya memiliki pola dalam fungsinya:

<return-type> function(<params>)
{
 <initialization>

 do
 {
   <main code for function>
 }
 while(false);

 <tidy-up & return>
}

Tidak buruk , lebih aneh (kode sebenarnya cukup rapi dan tidak mengejutkan). Ini bukan sesuatu yang pernah saya lihat sebelumnya dan saya bertanya-tanya apakah ada yang bisa memikirkan logika di baliknya - mungkin latar belakang dalam bahasa yang berbeda?

Anda bisa breakkeluar dari do{...}while(false).

Banyak orang mengatakan bahwa istilah ini sering digunakan dengan istirahat sebagai cara canggung untuk menulis "pergi". Itu mungkin benar jika ditulis langsung di fungsinya.

Dalam makro, OTOH, do { something; } while (false)adalah cara mudah untuk MEMAKSA titik koma setelah pemanggilan makro, sama sekali tidak ada token lain yang diizinkan untuk diikuti.

Dan kemungkinan lain adalah bahwa pernah ada loop di sana atau iterasi diantisipasi untuk ditambahkan di masa depan (misalnya dalam pengembangan yang digerakkan oleh pengujian, iterasi tidak diperlukan untuk lulus pengujian, tetapi secara logis masuk akal untuk mengulang di sana jika fungsi harus lebih umum dari yang dibutuhkan saat ini)

Istirahat sebagai goto mungkin adalah jawabannya, tetapi saya akan mengemukakan satu ide lain.

Mungkin dia ingin memiliki variabel yang ditentukan secara lokal dan menggunakan konstruksi ini untuk mendapatkan cakupan baru.

Ingat, meskipun C ++ terbaru memungkinkan untuk di {...}mana saja, hal ini tidak selalu terjadi.

Saya telah melihatnya digunakan sebagai pola yang berguna ketika ada banyak titik keluar potensial untuk fungsi tersebut, tetapi kode pembersihan yang sama selalu diperlukan terlepas dari bagaimana fungsi keluar.

Ini bisa membuat pohon if / else-if yang melelahkan jauh lebih mudah dibaca, dengan hanya harus berhenti setiap kali titik keluar tercapai, dengan sisa logika inline sesudahnya.

Pola ini juga berguna dalam bahasa yang tidak memiliki pernyataan goto. Mungkin di situlah programmer asli mempelajari polanya.

Saya telah melihat kode seperti itu sehingga Anda dapat menggunakannya breaksebagai gotosemacam.

Ini hanya penyimpangan whileuntuk mendapatkan sematikagoto tidy-up tanpa menggunakan kata goto.

Ini bentuk buruk karena ketika Anda menggunakan lain loop di dalam luar whileyang breaksmenjadi ambigu kepada pembaca. "Apakah ini seharusnya keluar? Atau ini dimaksudkan hanya untuk keluar dari lingkaran dalam?"

Saya pikir lebih nyaman untuk menulis breakdaripadagoto end . Anda bahkan tidak perlu memikirkan nama untuk label yang membuat maksudnya lebih jelas: Anda tidak ingin melompat ke label dengan nama tertentu. Anda ingin keluar dari sini.

Juga kemungkinan besar Anda akan membutuhkan kawat gigi. Jadi ini do{...}while(false);versinya:

do {
   // code
   if (condition) break; // or continue
   // more code
} while(false);

Dan inilah cara Anda mengungkapkannya jika Anda ingin menggunakan goto:

{
   // code
   if (condition) goto end;
   // more code
}
end:

Saya pikir arti dari versi pertama jauh lebih mudah untuk dipahami. Juga lebih mudah untuk menulis, lebih mudah untuk diperluas, lebih mudah untuk diterjemahkan ke bahasa yang tidak mendukung goto, dll.

Kekhawatiran yang paling sering disebutkan tentang penggunaan breakadalah penyamarannya yang buruk goto. Tetapi sebenarnya breakmemiliki lebih banyak kemiripan dengan return: Kedua instruksi melompat keluar dari blok kode yang cukup banyak terstruktur dibandingkan dengan goto. Namun demikian kedua instruksi tersebut memungkinkan beberapa titik keluar dalam satu blok kode yang terkadang dapat membingungkan. Bagaimanapun, saya akan mencoba mencari solusi yang paling jelas, apa pun yang ada dalam situasi spesifik.

Trik ini digunakan oleh programmer yang terlalu malu untuk menggunakan eksplisit gotodalam kode mereka. Penulis kode di atas ingin memiliki kemampuan untuk melompat langsung ke titik "pembersihan dan pengembalian" dari tengah kode. Namun mereka tidak mau menggunakan label dan eksplisit goto. Sebaliknya, mereka dapat menggunakan bagian breakdalam tubuh dari siklus "palsu" di atas untuk mencapai efek yang sama.

Ini adalah praktik yang sangat umum. Dalam C . Saya mencoba memikirkannya seolah-olah Anda ingin membohongi diri sendiri dengan cara "Saya tidak menggunakan goto". Kalau dipikir-pikir, tidak ada salahnya gotomenggunakan kata serupa. Bahkan itu juga akan mengurangi tingkat lekukan.

Meski begitu, saya perhatikan, seringkali do..whileloop ini cenderung tumbuh. Dan kemudian mereka mendapatkan ifs dan elses di dalamnya, membuat kode tersebut sebenarnya tidak terlalu mudah dibaca, apalagi dapat diuji.

Itu do..whilebiasanya dimaksudkan untuk melakukan pembersihan . Dengan segala cara yang memungkinkan, saya lebih suka menggunakan RAII dan kembali lebih awal dari fungsi singkat . Di sisi lain, C tidak memberi Anda kenyamanan sebanyak C ++ , membuat do..whilesalah satu pendekatan terbaik untuk melakukan pembersihan.

Sepertinya programmer C. Di C ++, variabel otomatis memiliki destruktor yang Anda gunakan untuk membersihkan, jadi tidak ada yang perlu dirapikan sebelum dikembalikan. Di C, Anda tidak memiliki idiom RAII ini , jadi jika Anda memiliki kode pembersihan yang sama, Anda dapat gotomenggunakannya, atau menggunakan perulangan sekali seperti di atas.

Kerugian utamanya dibandingkan dengan idiom C ++ adalah tidak akan merapikan jika ada pengecualian di tubuh. C tidak memiliki pengecualian, jadi ini bukan masalah, tetapi ini menjadikannya kebiasaan buruk di C ++.

Beberapa penjelasan. Yang pertama bersifat umum, yang kedua khusus untuk makro praprosesor C dengan parameter:

Alur kontrol

Saya telah melihat ini digunakan dalam kode C biasa. Pada dasarnya, ini adalah versi goto yang lebih aman, karena Anda dapat keluar darinya dan semua memori dibersihkan dengan benar.

Mengapa sesuatu- gotoseperti itu bagus? Nah, jika Anda memiliki kode di mana hampir setiap baris dapat mengembalikan kesalahan, tetapi Anda perlu bereaksi terhadap semuanya dengan cara yang sama (misalnya dengan menyerahkan kesalahan kepada pemanggil Anda setelah membersihkan), biasanya lebih mudah dibaca untuk menghindari if( error ) { /* cleanup and error string generation and return here */ }as itu menghindari duplikasi kode pembersihan.

Namun, di C ++ Anda memiliki pengecualian + RAII untuk tujuan ini, jadi saya akan menganggapnya gaya pengkodean yang buruk.

Pemeriksaan titik koma

Jika Anda lupa titik koma setelah pemanggilan makro mirip fungsi, argumen mungkin berkontraksi dengan cara yang tidak diinginkan dan dikompilasi menjadi sintaks yang valid. Bayangkan makro

#define PRINT_IF_DEBUGMODE_ON(msg) if( gDebugModeOn ) printf("foo");

Itu secara tidak sengaja disebut sebagai

if( foo )
    PRINT_IF_DEBUGMODE_ON("Hullo\n")
else
    doSomethingElse();

"Lain" akan dianggap terkait dengan gDebugModeOn , jadi bila fooada false, kebalikan dari apa yang dimaksudkan akan terjadi.

Menyediakan ruang lingkup untuk variabel sementara.

Karena do / while memiliki tanda kurung kurawal, variabel sementara memiliki ruang lingkup yang jelas dan tidak dapat mereka hindari.

Menghindari peringatan "titik koma yang mungkin tidak diinginkan"

Beberapa makro hanya diaktifkan di build debug. Anda mendefinisikannya seperti:

#if DEBUG
#define DBG_PRINT_NUM(n) printf("%d\n",n);
#else
#define DBG_PRINT_NUM(n) 
#endif

Sekarang jika Anda menggunakan ini dalam rilis, build di dalam kondisional, itu akan dikompilasi ke

if( foo )
    ;

Banyak kompiler melihat ini sama dengan

if( foo );

Yang sering ditulis secara tidak sengaja. Jadi Anda mendapat peringatan. Do {} while (false) menyembunyikan ini dari kompiler, dan diterima olehnya sebagai indikasi bahwa Anda benar-benar - ingin melakukan apa-apa di sini.

Menghindari pengambilan garis dengan persyaratan

Makro dari contoh sebelumnya:

if( foo )
    DBG_PRINT_NUM(42)
doSomething();

Sekarang, dalam build debug, karena kita juga biasa memasukkan titik koma, kompilasi ini baik-baik saja. Namun, dalam rilis build ini tiba-tiba berubah menjadi:

if( foo )

doSomething();

Atau lebih jelas diformat

if( foo )
    doSomething();

Yang sama sekali bukan yang dimaksudkan. Menambahkan do {...} while (false) di sekitar makro mengubah titik koma yang hilang menjadi kesalahan kompilasi.

Apa artinya bagi OP?

Secara umum, Anda ingin menggunakan pengecualian di C ++ untuk penanganan kesalahan, dan template, bukan makro. Namun, dalam kasus yang sangat jarang terjadi di mana Anda masih memerlukan makro (misalnya saat membuat nama kelas menggunakan penempelan token) atau dibatasi ke C biasa, ini adalah pola yang berguna.

Mungkin itu digunakan sehingga breakbisa digunakan di dalam untuk membatalkan eksekusi kode lebih lanjut kapan saja:

do {
    if (!condition1) break;
    some_code;
    if (!condition2) break;
    some_further_code;
    // …
} while(false);

Saya pikir ini dilakukan untuk menggunakan breakatau continuepernyataan. Semacam logika kode "goto".

Sederhana: Tampaknya Anda dapat keluar dari loop palsu kapan saja menggunakan breakpernyataan. Selanjutnya, doblok tersebut adalah ruang lingkup terpisah (yang juga dapat dicapai dengan{ ... } hanya ).

Dalam situasi seperti ini, mungkin ide yang lebih baik untuk menggunakan RAII (objek secara otomatis merusak dengan benar saat fungsi berakhir). Konstruksi serupa lainnya adalah penggunaan goto- ya, saya tahu itu jahat , tetapi dapat digunakan untuk memiliki kode pembersihan umum seperti:

<return-type> function(<params>)
{
 <initialization>

 <main code for function using "goto error;" if something goes wrong>

 <tidy-up in success case & return>

 error:

 <commmon tidy-up actions for error case & return error code or throw exception>
}

(Sebagai tambahan: Konstruksi do-while-false digunakan di Lua untuk memunculkan continuepernyataan yang hilang .)

Banyak penjawab memberikan alasannya do{(...)break;}while(false) . Saya ingin melengkapi gambar dengan contoh kehidupan nyata lainnya.

Pada kode berikut saya harus mengatur pencacah operationberdasarkan alamat yang ditunjukkan oleh datapointer. Karena switch-case hanya dapat digunakan pada jenis skalar, saya melakukannya dengan cara yang tidak efisien

if (data == &array[o1])
    operation = O1;
else if (data == &array[o2])
    operation = O2;
else if (data == &array[on])
    operation = ON;

Log("operation:",operation);

Tetapi karena Log () dan kode lainnya diulangi untuk setiap nilai operasi yang dipilih, saya mengembara bagaimana melewatkan sisa perbandingan ketika alamat telah ditemukan. Dan di sinilah do{(...)break;}while(false)berguna.

do {
    if (data == &array[o1]) {
        operation = O1;
        break;
    }
    if (data == &array[o2]) {
        operation = O2;
        break;
    }
    if (data == &array[on]) {
        operation = ON;
        break;
    }
} while (false);

Log("operation:",operation);

Orang mungkin bertanya-tanya mengapa dia tidak bisa melakukan hal yang sama breakdalam sebuah ifpernyataan, seperti:

if (data == &array[o1])
{
    operation = O1;
    break;
}
else if (...)

breakberinteraksi hanya dengan loop atau sakelar terdekat, apakah itu a for, whileatau do .. whiletipe, jadi sayangnya itu tidak akan berhasil.

Berapa umur penulisnya?

Saya bertanya karena saya pernah menemukan beberapa kode Fortran real-time yang melakukan itu, di akhir 80-an. Ternyata itu adalah cara yang sangat bagus untuk mensimulasikan utas pada OS yang tidak memilikinya. Anda cukup meletakkan seluruh program (penjadwal Anda) dalam satu putaran, dan memanggil "rangkaian" rutinitas "Anda satu per satu. Rutinitas utas itu sendiri adalah perulangan yang berulang hingga salah satu dari sejumlah kondisi terjadi (seringkali salah satunya adalah sejumlah waktu telah berlalu). Ini adalah "multitasking kooperatif", dalam hal ini tergantung pada masing-masing utas untuk melepaskan CPU sesekali sehingga yang lain tidak kelaparan. Anda dapat menumpuk panggilan subprogram perulangan untuk mensimulasikan prioritas utas band.

Selain 'contoh goto' yang telah disebutkan, idiom do ... while (0) kadang-kadang digunakan dalam definisi makro untuk memberikan tanda kurung dalam definisi dan masih memiliki kompiler yang berfungsi dengan menambahkan titik koma di akhir panggilan makro.

http://groups.google.com/group/comp.soft-sys.ace/browse_thread/thread/52f670f1292f30a4?tvc=2&q= While+(0)

Saya setuju dengan sebagian besar poster tentang penggunaan sebagai goto yang disamarkan secara tipis. Makro juga telah disebutkan sebagai motivasi potensial untuk menulis kode dalam gaya.

Saya juga telah melihat konstruksi ini digunakan dalam lingkungan C / C ++ campuran sebagai pengecualian orang miskin. The "do {} while (false)" dengan "break" bisa digunakan untuk melompat ke akhir blok kode seandainya sesuatu yang biasanya menjamin pengecualian ditemui di loop.

Saya juga telah menemukan konstruksi ini yang digunakan di toko-toko di mana ideologi "pengembalian tunggal per fungsi" diterapkan. Sekali lagi, ini adalah pengganti dari "goto" yang eksplisit - tetapi motivasinya adalah untuk menghindari beberapa poin kembali, bukan untuk "melewati" kode dan melanjutkan eksekusi aktual dalam fungsi itu.

Saya bekerja dengan Adobe InDesign SDK, dan contoh InDesign SDK memiliki hampir semua fungsi yang ditulis seperti ini. Karena faktanya fungsinya biasanya sangat panjang. Di mana Anda perlu melakukan QueryInterface (...) untuk mendapatkan apa pun dari model objek aplikasi. Jadi biasanya setiap QueryInterface diikuti iftidak berjalan dengan baik, break.

Banyak yang telah menyatakan kesamaan antara konstruksi ini dan a goto, dan menyatakan preferensi untuk kebagian tersebut. Mungkin latar belakang orang ini termasuk lingkungan di mana goto dilarang keras oleh pedoman pengkodean?

Alasan lain yang dapat saya pikirkan adalah karena dekorasi kawat gigi, sedangkan saya percaya kawat gigi telanjang standar C ++ yang lebih baru tidak baik (ISO C tidak menyukainya). Jika tidak, untuk menenangkan penganalisis statis seperti serat.

Tidak yakin mengapa Anda menginginkannya, mungkin cakupan variabel, atau keuntungan dengan debugger.

Lihat Trivial Do While loop , dan Braces is Good dari C2.

Untuk memperjelas terminologi saya (yang menurut saya mengikuti penggunaan standar):

Kawat gigi telanjang :

init();
...
{
c = NULL;
mkwidget(&c);
finishwidget(&c);
}
shutdown();

Kawat gigi kosong (NOP):

{}

misalnya

while (1)
   {}  /* Do nothing, endless loop */

Blokir :

if (finished)
{
     closewindows(&windows);
     freememory(&cache);
}

yang akan menjadi

if (finished)
     closewindows(&windows);
freememory(&cache);

jika kawat gigi dilepas, sehingga mengubah aliran eksekusi, bukan hanya cakupan variabel lokal. Jadi tidak 'berdiri bebas' atau 'telanjang'.

Tanda kurung kurawal atau blok dapat digunakan untuk menandai bagian mana pun dari kode yang mungkin berpotensi untuk fungsi (sebaris) yang ingin Anda tandai, tetapi bukan pemfaktor ulang pada saat itu.

Ini adalah cara yang dibuat-buat untuk meniru a GOTOkarena keduanya secara praktis identik:

// NOTE: This is discouraged!
do {
    if (someCondition) break;
    // some code be here
} while (false);
// more code be here

dan:

// NOTE: This is discouraged, too!
if (someCondition) goto marker;
// some code be here
marker:
// more code be here

Di sisi lain, keduanya harus benar-benar dilakukan dengan ifs:

if (!someCondition) {
    // some code be here
}
// more code be here

Meskipun penumpukan bisa menjadi sedikit jelek jika Anda hanya mengubah string panjang ke depan GOTOmenjadi ifs bersarang . Jawaban sebenarnya adalah refactoring yang tepat, meskipun, tidak meniru konstruksi bahasa kuno.

Jika Anda mati-matian mencoba mentransliterasi algoritme dengan GOTOs di dalamnya, Anda mungkin bisa melakukannya dengan idiom ini. Ini tentu saja non-standar dan indikator yang baik bahwa Anda tidak mengikuti idiom bahasa yang diharapkan.

Saya tidak mengetahui bahasa seperti C di mana do / while adalah solusi idiomatik untuk apa pun.

Anda mungkin bisa mengubah seluruh kekacauan menjadi sesuatu yang lebih masuk akal untuk membuatnya lebih idiomatis dan lebih mudah dibaca.

Beberapa pembuat kode lebih memilih untuk hanya memiliki satu jalan keluar / kembali dari fungsinya. Penggunaan dummy do {....} while (false); memungkinkan Anda untuk "keluar" dari loop palsu setelah Anda selesai dan masih memiliki satu pengembalian.

Saya seorang pembuat kode java, jadi contoh saya akan seperti ini

import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class p45
{
    static List<String> cakeNames = Arrays.asList("schwarzwald torte", "princess", "icecream");
    static Set<Integer> forbidden = Stream.of(0, 2).collect(Collectors.toSet());

    public static  void main(String[] argv)
    {
        for (int i = 0; i < 4; i++)
        {
            System.out.println(String.format("cake(%d)=\"%s\"", i, describeCake(i)));
        }
    }


    static String describeCake(int typeOfCake)
    {
        String result = "unknown";
        do {
            // ensure type of cake is valid
            if (typeOfCake < 0 || typeOfCake >= cakeNames.size()) break;

            if (forbidden.contains(typeOfCake)) {
                result = "not for you!!";
                break;
            }

            result = cakeNames.get(typeOfCake);
        } while (false);
        return result;
    }
}

Dalam kasus seperti itu saya gunakan

switch(true) {
   case condution1:
      ...
      break;
   case condution2:
      ...
      break;
}

Ini lucu. Mungkin ada jeda di dalam loop seperti yang dikatakan orang lain. Saya akan melakukannya dengan cara ini:

while(true)
{
   <main code for function>
   break; // at the end.
}