Hello #cpp / #cplusplus Fediverse,

[riley@toot.cat]

@lesley Also, I'd have to explicitly cast; the cast would not be invoked implicitly by the language.

@oblomov

[ananas@scicomm.xyz]

@riley

A pointer conversion is not a reference conversion, you can't do what you want without relying on undefined behaviour in the first place (well, at least, not in current C++). The best you can do is `reinterpret_cast` or `std::bit_cast` the pointer, but there's a reason ripcast is a code smell.

Telling that your pointer to one type is a pointer to other type is not very kosher, you are trying to build a pretty hefty footgun there. I hope you know what you are doing.

[riley@toot.cat]

@lesley If foo virtually inherited from struct bar, it might possibly work, but foo would then have to be class rather than struct, and begin with the vtable pointer, which C++ doesn't let me make static or place it somewhere away from the class's beginning where it implicitly goes.

[ananas@scicomm.xyz]

@riley Though I guess you could overload the function where you are trying to pass the pointer into, and do the conversion there, but I'd imagine most sane code reviewers would stop that.

```cpp
int func(bar* bar) {
// do the bar stuff
}

int func(foo* foo) {
return func(reinterpret_cast<bar*>(foo));
}
```

For educational purposes only, please don't do this in code that somebody else has to touch.

[oblomov@sociale.network]

@riley @lesley the only way to avoid explicit casts is inheritance. Can you make foo inherit from both whatever you want it to inherit from AND bar? Or is multiple inheritance a no-no in your project?

[riley@toot.cat]

@ananas You're thinking about something weird.

I want to do something like this, which, as you can see, is so perfectly cromulent than it compiles and runs:

#include <stdio.h>
#include <stdlib.h>

struct bar {
  int paydirt;
};

struct foo {
  int some_field_here;
  struct bar cheap_dirt;

  operator bar &() {
    return cheap_dirt;
  }
};

void work_on_paydirt (struct bar &object) {
  printf("Teh paydirt is %i\n", object.paydirt);
}

struct foo the_foo;
struct bar the_bar;

int main () {
  work_on_paydirt(the_foo);
  work_on_paydirt(the_bar);
  return EXIT_SUCCESS;
}

I just want work_on_paydirt, for historic compatibility reasons, to take struct bar * rather than struct bar & as its argument. Logic-wise, maintenance-wise, there's no difference. Even the generated code is exactly the same (modulo the mangled names). But C++ syntax is only happy to let me define an explicit conversion operator for a struct-to-struct-reference, and not for the same struct's pointer to a struct pointer. I'm not trying to do anything exotic here, or type punning or obfuscatory stuff; I just want the translator to implicitly invoke my type converter for a pointer-to-struct type, just like it can for a referenced-struct type.

[riley@toot.cat]

@oblomov Having foo be a class and not a struct would make some things a lot more complicated. If there's no other way, I'd probably prefer to generate automatically the procedures that take struct bar *, invoke the converter explicitly, and then call the hand-written procedures, over doing multiple inheritance.

@lesley

[oblomov@sociale.network]

@riley @lesley you can have (multiple) inheritance even with a struct

[riley@toot.cat]

@ananas That's my fall-back approach, except it's not reinterpret_cast<bar*>(foo), it's foo->gimme_bar(). And foo::gimme_bar() will be inline, and so will be the couple hundred procedures that take struct foo *, so in the end, very little binary code will come out of it, only the source code will be awfully bulky. Not ideal.

[riley@toot.cat]

@oblomov Can you show me some code?

@lesley

[riley@toot.cat]

@oblomov Never mind:

#include <stdio.h>                                           

struct par1 {                                                
  int par1a;                                                 
  par1() : par1a(1) {}                                       
};                                                           

struct par2 {                                                
  int par2a;                                                 
  par2() : par2a(2) {}                                       
};                                                           

struct child : par1, par2 {                                  
  int chfield3;                                              
  child() : chfield3(3) {}                                   
};                                                           

int main () {                                                
  child ch;                                                  
  printf("ch.par1a = %i, ch.par2a = %i, ch.chfield3 = %i\n", 
      ch.par1a, ch.par2a, ch.chfield3);                      
  printf("&ch = %p, (par1 *)&ch = %p, (par2 *)&ch = %p\n",   
      &ch, (par1 *)&ch, (par2 *)&ch);                        
  return 0;                                                  
}                           

I might be able to make this work. Pondering.

@lesley

[oblomov@sociale.network]

@riley

sure: https://godbolt.org/z/YvYa9b7jb

You do lose the POD property on foo though. Depending on your needs this may or may not be important.

@lesley

[riley@toot.cat]

@ananas Well, if I have to autogenerate, I could do this instead:

template <class T>
void work_on_paydirt (T *ambi_object) {
  struct bar *object = ambi_object->gimme_bar();
  printf("Teh paydirt is %i\n", object->paydirt);
}

Slightly less bulky, but it looks ugly.

[riley@toot.cat]

@oblomov Where does the PODness go?

@lesley

[oblomov@sociale.network]

@riley @lesley well, you can't share a type with inheritance (multiple or not) with C, so it's Plain Old Data (although you CAN design an aliasing C type for that if you need it)