• MajinBlayze@lemmy.world
    3·
    3 months ago
    *char // I heard it from a friend
**char //who heard it from a friend
***char // who heard it from another
"You were messing around"
  • xmunk@sh.itjust.works
    3·
    3 months ago

    Once your pointer definition looks like a censored swear word you’re doing something awful.

    In my entire programming career I’ve used int ** less than a handful of times and I’ve always been borderline about refactoring when I need it.

  • RonSijm@programming.dev
    1·
    3 months ago

    Me: building a fluent interface framework…
    I already support a WrapperOf<T, T, T, T>
    User: Can I have a WrapperOf<T, T, T, T, T> because I’m doing something weird?
    Me: *sigh* god-damnit. You’re right but I still hate it.

  • SpaceNoodle@lemmy.world
    1·
    3 months ago

    I don’t think I’ve ever explicitly gone four deep. Two is common enough, and three happens on some rare occasions, but four seems like sheer madness.

    • Ephera@lemmy.ml
      0·
      3 months ago

      Dumb question, but when would you need two deep? Is it when you store a pointer as a field in a struct?

      If so, isn’t that a massive footgun, because the pointer might go invalid at any point? 🫠

      • SpaceNoodle@lemmy.world
        1·
        3 months ago

        Pointers to arrays or arrays of pointers are common examples.

        Your pointers won’t just magically become invalid. You gotta fuck 'em up first.

  • tobogganablaze@lemmus.orgEnglish
    1·
    3 months ago

    If I had a penny for every pixel … I’d have around $1088. Which I would take, but really it’s not enough.

    • renormalizer@feddit.orgDeutsch
      1·
      3 months ago

      I’ve been a four-star programmer a few times. Imagine a blocked symmetric matrix where the rows and columns are indexed by triples (u,v,w). The entries are zero whenever u != u’ or v != v’, and because of symmetry you only store entries with w <= w’. But the range of v depends on the value of u and the range of w on the value of v. So you do

      double ****mat = calloc (UMAX, sizeof(*mat));
for (int u = 0; u < UMAX; ++u) {
  mat[u] = calloc (u + 1, sizeof(**mat));
  for (int v = 0; v <= u; ++v) {
    mat[u][v] = calloc (v + 1, sizeof(***mat));
    for (int w = 0; w <= v; ++w) {
      mat[u][v][w] = calloc (w + 1, sizeof(****mat));
      for (int ww = 0; ww <= w; ++ww)
        mat[u][v][w][ww] = some_function (u, v, w, ww);
    }
  }
}

      and weep a little. In reality, this gets a bit optimized by allocating a single chunk of memory and carving that up into the pointer and data arrays, so everything is reasonably close together in memory.