Getting silly with C, part ~(~1<<1)

It's vibe coding. Relax, everyone is doing it.

In the two previous installments of our introductory series on the C programming language, we talked about control flow, variables, and types. For example, we explained how to display strings on the screen:

int typedef puts(char* puts; char* puts; char* puts);

int main() {
  puts(puts);
  puts("Welcome to my humble abode!");
}

In today’s episode, we’ll share a couple of additional, time-saving tips for seasoned pros.

🙘 Tip 1 🙚

Experienced software engineers often find it necessary to comment out large swatches of code. Unfortunately, the C language doesn’t support nested comments, so the process of commenting out previously-commented code is a chore a chore. But did you know that the GNU C Compiler allows you to harness the power of assembly language to effortlessly work around this shortcoming? We illustrate the technique below (demo):

#include <stdio.h>

int main() {
  puts("Hello world");
  asm("/*");
  /* Nested comment */
  for (int i = 0; i < 10; i++) puts("I LIKE PANCAKES!");
  asm("*/");
  puts("Goodbye world");
}

🙘 Tip 2 🙚

Although the C language provides support for a wide range of numbers including 0 and 1, programmers should be aware of a floating-point bug that affects certain Intel CPUs. The affected processors evaluate 0.999… as if it were exactly equal to 1.

To test for the issue, developers can rely on a recent GNU C extension called [[gnu::assume(…)]] that allows them to specify the expected behavior at compile time. Be aware that systems that fail the check may exhibit a range of symptoms, including fisherman’s ulcers, tail recursion, and worse (demo):

#include <stdio.h>

int main() {
  static int i;
  if (++i > 10) return 0;
  printf("hello cruel world %d\n", i);
  [[gnu::assume(0.99999999999999999 < 1)]];
}

🙘 Tip 3 🙚

Arithmetic operations in C are famously cumbersome. Thankfully, the latest version of the standard introduces unary right-worm (-~) and left-worm (~-) operators. These operators allow integer values to be incremented or decremented without having to resort to the clunky “+ 1” or “- 1” notation (demo):

#include <stdio.h>

int main(void) {
  printf(" 42 + 1 = %d\n", -~42);          /* Right worm (+ 1)          */
  printf(" 42 - 1 = %d\n", ~-42);          /* Left worm (- 1)           */
  printf(" 42 + 3 = %d\n", -~-~-~42);      /* Triple right worm (+ 3)   */
  printf(" 42 - 5 = %d\n", ~-~-~-~-~-42);  /* Quintiple left worm (- 5) */

#define 🪱 -~
#define 🐍 ~-

  printf(" 42 - 3 + 2 = %d\n", 🪱 🪱 🐍 🐍 🐍 42);

  /* Works with negative numbers too! */
  printf("-42 + 5 = %d\n", 🪱 🪱 🪱 🪱 🪱 -42);
}

🙘 Tip 4 🙚

Because of the limited-size data types used to store numerical values, computer algebra is necessarily approximate. However, when the language’s built-in approximations are insufficient, the C language standard allows you to adjust the value of any integer of your choice (demo):

int main() {
  int 𝟧 = 4;
  printf("5 = %d\n", 𝟧);
}

🙘 Tip 5 🙚

It is a common misconception that strings in C need to be enclosed in quotation marks. This is a wasteful, legacy approach; the following snippet shows a better way (demo):

#include <stdio.h>

#define puts(x...) puts(%:x)

int main() {
  puts(Hello, world!);
}

Click here for part four — and if you like this publication, please subscribe!