Hello #cpp / #cplusplus Fediverse,

[oblomov@sociale.network]

@riley what do you mean by a conversion between pointer types?

[tromo@kafeneio.social]

@riley
```
struct foo f;
struct bar b;
void *p = (void *) &f;
b = *((struct bar *) p);
```
whatever happens the previous have to pass, C rules

[riley@toot.cat]

@oblomov Defining a function/operator that would be implicitly invoked when struct foo * is passed to a function declared to accept a struct bar * that would ideally amount to adding a small constant to the pointer; effectively, there's a struct bar inside a struct foo, and I'd like a struct bar * to be converted to struct foo * by implicitly referring to that inner struct when a pointer to the outer struct is being passed to a function taking a pointer to the inner struct.

[lesley@mastodon.gamedev.place]

@riley Tricky question. In both C and C++, punning between pointers to unrelated types is undefined behaviour. It may "work" when you test it, but the compiler optimiser may also break it at any point. E.g.

```cpp
// It doesn't matter that foo and bar are layout-compatible
struct foo { int x; };
struct bar { int x; };

struct foo a = {42};
struct foo* a_ptr = &a;

struct B* b_ptr = a_ptr;
std::cout << b_prt->x; // undefined behaviour
```

[lesley@mastodon.gamedev.place]

@riley @oblomov I think in this particular case (one object has the type of the first member of another object), you are allowed to cast? I've done this trick in C, but I am not entirely sure about C++, though. The standard seems to imply so

https://timsong-cpp.github.io/cppwp/basic.compound#5.3

[riley@toot.cat]

@lesley I don't actually want punning; I want to avoid having to declare an extra procedure that would take struct foo * if I've already written one that takes struct bar *. I've got a bunch of these procedures, and while I could autogenerate the extra procedures as inline procedures, I'd rather not do it if I can have the translator do the work for me, and keep the code less bulky and more readable.

[lesley@mastodon.gamedev.place]

@riley Ahh. Then I don't think I have an answer

[oblomov@sociale.network]

@lesley yes, but in the case of @riley that's not the same issue: if foo has-a bar, there's no way to do the casting _implicitly_, as far as a I know. It would be possible with references by defining an implicit constructor of bar from foo, but this won't be applied to pointers.

The only work around I can think of is to define an overloaded function

bar * get_bar(bar * o) { return o; }
bar * get_bar(foo * o) { return &o->bar_element; }

and wrap pointer arguments with that function.

[riley@toot.cat]

@lesley Unfortunately, it's cumbersome to put struct bar first inside the struct foo; for reasons, I'd prefer struct foo to inherit from a third structure that puts some fields in its beginning, and struct bar can not inherit from it.

@oblomov

[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