3 ms·

hard no - goto is a feature for code generators, not anything meant for human use

by kiitos 2y ago

greenavocado 2y ago
I never understood this argument. Without RAII you can easily get screwed by resource leaks without goto when returning early. In this regard, using goto is expedient. How do C programmers avoid this problem without goto? bool function_with_cleanup(void) { int *buffer1 = NULL; int *buffer2 = NULL; FILE *file = NULL; bool success = false; // Allocate first resource buffer1 = malloc(sizeof(int) * 100); if (!buffer1) { goto cleanup; // Error, jump to cleanup } // Allocate second resource buffer2 = malloc(sizeof(int) * 200); if (!buffer2) { goto cleanup; // Error, jump to cleanup } // Open a file file = fopen("data.txt", "r"); if (!file) { goto cleanup; // Error, jump to cleanup } // Do work with all resources... success = true; // Only set to true if everything succeeded cleanup: // Free resources in reverse order of acquisition if (file) fclose(file); free(buffer2); // free() is safe on NULL pointers free(buffer1); return success; }
- dwattttt 2y ago
  Open a scope when you check resource acquisition passed, rather than the opposite (jump to the end of the function if it failed). It can get quite hilly, which doesn't look great. It does have the advantage that each resource is explicitly only valid in a visible scope, and there's a marker at the end to denote the valid region of the resource is ending. EDIT: you mentioned early return, this style forbids early return (at least, any early return after the first resource acquisition)
- gigatexal 2y ago
  In this example couldn’t the go to cleanup instead be return cleanup_func where the same cleanup code was executed?
- pjmlp 2y ago
  Maybe that is exactly the problem, stop using a language designed in 1970's that ignored on purpose the ecosystem outside Bell Labs, unless where it is unavoidable. And in such case, the C compiler doesn't have a limit to write functions and better modularize their implementations. bool function_with_cleanup(void) { int *buffer1 = NULL; int *buffer2 = NULL; FILE *file = NULL; // Allocate first resource buffer1 = malloc(sizeof(int) * 100); if (!buffer1) { return false; } // Allocate second resource buffer2 = malloc(sizeof(int) * 200); if (!buffer2) { free(buffer1); return false; } // Open a file file = fopen("data.txt", "r"); if (!file) { free(buffer1); free(buffer1); return false; } // Do work with all resources... fclose(file); free(buffer1); free(buffer1); return true; } Ah, but all those free() calls get tedious can be forgotten and mistyped bool function_with_cleanup(void) { int *buffer1 = NULL; int *buffer2 = NULL; FILE *file = NULL; // Allocate first resource buffer1 = arena_alloc(&current_arena, sizeof(int) * 100); if (!buffer1) { return false; } // Allocate second resource buffer2 = arena_alloc(&current_arena, sizeof(int) * 200); if (!buffer2) { arena_reset(&current_arena); return false; } // Open a file file = fopen("data.txt", "r"); if (!file) { arena_reset(&current_arena); return false; } // Do work with all resources... fclose(file); arena_reset(&current_arena); return true; } Can still be improved with a mix of macros and varargs functions. Or if using language extensions is a thing, the various ways to do defer in C.
  - LtWorf 2y ago
    You understand go doesn't have exceptions right?
    - pjmlp 2y ago
      You understand that I wrote C code, and in what concerns Go, panic/recover are exceptions that don't want to assume themselves as such?
- shakna 2y ago
  Attributes, mostly. Which have become so common that defer is very likely to be in the next C standard. [0] bool function_with_cleanup(void) { // Allocate first resource int* buffer1 __attribute__((__cleanup__(free))) = malloc(sizeof(int) * 100); if(!buffer1) { return false; } // Allocate second resource int* buffer2 __attribute__((__cleanup__(free))) = malloc(sizeof(int) * 200); if(!buffer2) { return false; } // Open a file FILE* file __attribute__((__cleanup__(fclose))) = fopen("data.txt", "r"); if (!file) { return false; } return true; } [0] https://thephd.dev/c2y-the-defer-technical-specification-its-time-go-go-go https://thephd.dev/c2y-the-defer-technical-specification-its...
- mkl 2y ago
  Nested ifs are my preference: bool function_with_cleanup(void) { int *buffer1 = NULL; int *buffer2 = NULL; FILE *file = NULL; bool success = false; // Allocate first resource buffer1 = malloc(sizeof(int) * 100); if (buffer1) { // Allocate second resource buffer2 = malloc(sizeof(int) * 200); if (buffer2) { // Open a file file = fopen("data.txt", "r"); if (file) { // Do work with all resources... fclose(file); success = true; // Only set to true if everything succeeded } free(buffer2); } free(buffer1); } return success; } Much shorter and more straightforward. One-time loops with break also work if you're not doing the resource allocation in another loop: bool function_with_cleanup(void) { int *buffer1 = NULL; int *buffer2 = NULL; FILE *file = NULL; bool success = false; do { // One-time loop to break out of on error // Allocate first resource buffer1 = malloc(sizeof(int) * 100); if (!buffer1) { break; // Error, jump to cleanup } // Allocate second resource buffer2 = malloc(sizeof(int) * 200); if (!buffer2) { break; // Error, jump to cleanup } // Open a file file = fopen("data.txt", "r"); if (!file) { break; // Error, jump to cleanup } // Do work with all resources... success = true; // Only set to true if everything succeeded } while(false); // Free resources in reverse order of acquisition if (file) fclose(file); free(buffer2); // free() is safe on NULL pointers free(buffer1); return success; } Still simpler to follow than goto IMHO. Both these patterns work in other languages without goto too, e.g. Python.
  - gpderetta 2y ago
    Nested if, aside from being awful, doesn't scale. And break is extremely thin sugar on top of go-to.
jandrewrogers 2y ago
There are situations in practical code where goto is the only reasonable choice if you want to avoid spaghetti code. Absolutes have no place in software, you can find scenarios where almost every typically bad idea is actually a good idea. It is a tool, not a religion.
- 9rx 2y ago
  Even Dijkstra was clear that he was only referring to unbridled gotos.

hard no - goto is a feature for code generators, not anything meant for human use

by kiitos 2y ago

hard no - goto is a feature for code generators, not anything meant for human use

I never understood this argument. Without RAII you can easily get screwed by resource leaks without goto when returning early. In this regard, using goto is expedient. How do C programmers avoid this problem without goto? bool function_with_cleanup(void) { int *buffer1 = NULL; int *buffer2 = NULL; FILE *file = NULL; bool success = false; // Allocate first resource buffer1 = malloc(sizeof(int) * 100); if (!buffer1) { goto cleanup; // Error, jump to cleanup } // Allocate second resource buffer2 = malloc(sizeof(int) * 200); if (!buffer2) { goto cleanup; // Error, jump to cleanup } // Open a file file = fopen("data.txt", "r"); if (!file) { goto cleanup; // Error, jump to cleanup } // Do work with all resources... success = true; // Only set to true if everything succeeded cleanup: // Free resources in reverse order of acquisition if (file) fclose(file); free(buffer2); // free() is safe on NULL pointers free(buffer1); return success; }

dwattttt 2y ago
Open a scope when you check resource acquisition passed, rather than the opposite (jump to the end of the function if it failed). It can get quite hilly, which doesn't look great. It does have the advantage that each resource is explicitly only valid in a visible scope, and there's a marker at the end to denote the valid region of the resource is ending. EDIT: you mentioned early return, this style forbids early return (at least, any early return after the first resource acquisition)
gigatexal 2y ago
In this example couldn’t the go to cleanup instead be return cleanup_func where the same cleanup code was executed?
pjmlp 2y ago
Maybe that is exactly the problem, stop using a language designed in 1970's that ignored on purpose the ecosystem outside Bell Labs, unless where it is unavoidable. And in such case, the C compiler doesn't have a limit to write functions and better modularize their implementations. bool function_with_cleanup(void) { int *buffer1 = NULL; int *buffer2 = NULL; FILE *file = NULL; // Allocate first resource buffer1 = malloc(sizeof(int) * 100); if (!buffer1) { return false; } // Allocate second resource buffer2 = malloc(sizeof(int) * 200); if (!buffer2) { free(buffer1); return false; } // Open a file file = fopen("data.txt", "r"); if (!file) { free(buffer1); free(buffer1); return false; } // Do work with all resources... fclose(file); free(buffer1); free(buffer1); return true; } Ah, but all those free() calls get tedious can be forgotten and mistyped bool function_with_cleanup(void) { int *buffer1 = NULL; int *buffer2 = NULL; FILE *file = NULL; // Allocate first resource buffer1 = arena_alloc(&current_arena, sizeof(int) * 100); if (!buffer1) { return false; } // Allocate second resource buffer2 = arena_alloc(&current_arena, sizeof(int) * 200); if (!buffer2) { arena_reset(&current_arena); return false; } // Open a file file = fopen("data.txt", "r"); if (!file) { arena_reset(&current_arena); return false; } // Do work with all resources... fclose(file); arena_reset(&current_arena); return true; } Can still be improved with a mix of macros and varargs functions. Or if using language extensions is a thing, the various ways to do defer in C.
- LtWorf 2y ago
  You understand go doesn't have exceptions right?
  - pjmlp 2y ago
    You understand that I wrote C code, and in what concerns Go, panic/recover are exceptions that don't want to assume themselves as such?
shakna 2y ago
Attributes, mostly. Which have become so common that defer is very likely to be in the next C standard. [0] bool function_with_cleanup(void) { // Allocate first resource int* buffer1 __attribute__((__cleanup__(free))) = malloc(sizeof(int) * 100); if(!buffer1) { return false; } // Allocate second resource int* buffer2 __attribute__((__cleanup__(free))) = malloc(sizeof(int) * 200); if(!buffer2) { return false; } // Open a file FILE* file __attribute__((__cleanup__(fclose))) = fopen("data.txt", "r"); if (!file) { return false; } return true; } [0] https://thephd.dev/c2y-the-defer-technical-specification-its-time-go-go-go https://thephd.dev/c2y-the-defer-technical-specification-its...
mkl 2y ago
Nested ifs are my preference: bool function_with_cleanup(void) { int *buffer1 = NULL; int *buffer2 = NULL; FILE *file = NULL; bool success = false; // Allocate first resource buffer1 = malloc(sizeof(int) * 100); if (buffer1) { // Allocate second resource buffer2 = malloc(sizeof(int) * 200); if (buffer2) { // Open a file file = fopen("data.txt", "r"); if (file) { // Do work with all resources... fclose(file); success = true; // Only set to true if everything succeeded } free(buffer2); } free(buffer1); } return success; } Much shorter and more straightforward. One-time loops with break also work if you're not doing the resource allocation in another loop: bool function_with_cleanup(void) { int *buffer1 = NULL; int *buffer2 = NULL; FILE *file = NULL; bool success = false; do { // One-time loop to break out of on error // Allocate first resource buffer1 = malloc(sizeof(int) * 100); if (!buffer1) { break; // Error, jump to cleanup } // Allocate second resource buffer2 = malloc(sizeof(int) * 200); if (!buffer2) { break; // Error, jump to cleanup } // Open a file file = fopen("data.txt", "r"); if (!file) { break; // Error, jump to cleanup } // Do work with all resources... success = true; // Only set to true if everything succeeded } while(false); // Free resources in reverse order of acquisition if (file) fclose(file); free(buffer2); // free() is safe on NULL pointers free(buffer1); return success; } Still simpler to follow than goto IMHO. Both these patterns work in other languages without goto too, e.g. Python.
- gpderetta 2y ago
  Nested if, aside from being awful, doesn't scale. And break is extremely thin sugar on top of go-to.

jandrewrogers 2y ago

There are situations in practical code where goto is the only reasonable choice if you want to avoid spaghetti code. Absolutes have no place in software, you can find scenarios where almost every typically bad idea is actually a good idea. It is a tool, not a religion.

9rx 2y ago
Even Dijkstra was clear that he was only referring to unbridled gotos.