Hacker News Reader

Comment by 0xFFC | Hacker News Reader

>$, as a way of getting object metadata out of a class, namespace, etc. (Using $ has been argued out of favor because it is common in legacy code, particularly in code generation and template systems which are not necessarily valid C++ but produce C++ sources.)

you have got to be kidding me, right ? "$" adding this character too to the C++ ? What left we haven't add ?

Why not use only something like "reflexpr" which is more C++ish than $ character. Why make C++ more difficult to parse and read with every release ?

TBH I genuinely don't understand why we need both ? why not only have "reflexpr".

View on HN

$ is already a valid identifier character in a clang and gcc extension. And there won't be reflexpr and $, those are two different proposal. And due to the extension, it won't be $ (most likely).

Thank you. I really hope so.

> What haven't we added yet?

There's also the @ sign and the backtic `.

I think that's it for ASCII.

And caret (^), although it is used in Microsoft's C++/CLI and C++/CX extensions.

The caret is used for bitwise xor. C-style bitwise ops in general take up a lot of the good characters, in so many languages. :(

Many characters have multiple uses depending on context; e.g. A single asterisk, or a single ampersand

Yes, right, brain-fart. (In my defense bitwise xor is probably the least common operator).

->* begs to differ

Can someone remind me what that's for? I never use it, I keep trying to look it up and then I forget it again. Maybe because I never quite understood it properly.

I'm batting 0 for 2 so far in this thread, but I'll take a stab at it now I've been reminded of those crazy beasts' existence. :)

  struct Foo {
          int i;
          int inc()
          {
                  return ++i;
          }
  };

  int Foo::*i_ptr       = &Foo::i;   // Pointer to member
  int (Foo::*inc_ptr)() = &Foo::inc; // Pointer to method

  Foo my_foo(0);

  (&my_foo)->i_ptr;  // Error: my_foo has no member "i_ptr"
  (&my_foo)->*i_ptr; // OK
  my_foo.inc_ptr();  // Error: my_foo has no member "inc_ptr"
  my_foo.*inc_ptr(); // OK

  // This is also why you can't create references
  // to methods or other class members

  int (&print)(const char *) = std::puts; // OK
  int (Foo::&inc_ref)()      = Foo::inc;  // Error

  int &my_int     = my_foo.i; // OK
  int Foo::&i_ref = Foo::i;   // Error

Ok, lovely, but why is this useful? Like, is there any problem where this is the simplest way to solve it?

It's basically a way to use the result of a pointer to a member.

Let's say you have

  class Foo
  {
    int m_bar;
    int m_baz;
  }

You want to store off which member of Foo you want to reference, but you want to do it in a way not tied to any specific instance of Foo.

  int (Foo :: * ptr) = &Foo::m_baz; // Basically offsetof() but safely typed.

Cool, but now what are you going to do with that member? What if I want to set it to 10?

  int (Foo :: * ptr) = &Foo::m_baz;
  
  std::vector<Foo*> foos;
  ... // populate foos;
  for(Foo* foo : foos)
  { // For each foo, set whatever member ptr points at to 10
    foo->*ptr = 10;
  }

I've never seen it really used in practice (usually I see offsetof() and pointer math in this situation because the object type isn't known before hand) but it's an option.

So you have seen offsetof used in practice? Can I have a pointer? (I will not confirm or deny whether that pun was intentional.)

It's a matter of taste; for me 'reflexpr' is about as disgusting as 'constexpr'.

No it is not matter of taste. I dont have anything against $ in php, perl, or most other languages. But it is not consistent with C++ syntax at all.

AKA consistent.

Reply on news.ycombinator.com