3 ms·

> I know it works in some form on most implementations even though it isn't legal. it definitely does not, every time I had an ODR issue that caused actual bug

> I know it works in some form on most implementations even though it isn't legal. it definitely does not, every time I had an ODR issue that caused actual bugs. For instance, dynamic_cast not working because a typeid was defined in two shared objects, etc. What would be the behaviour you expect if you have a.cpp: int constant() { return 123; } b.cpp: int constant() { return 456; } c.cpp: int constant(); int main() { return constant(); } how could you define this meaningfully other than "hard error" ? e.g. here with gcc, if a and b are put into shared libraries, the return value depends on the order in which the libraries are passed to g++ when linking. e.g. g++ c.cpp a.so b.so calls the version in a.so, while g++ c.cpp b.so a.so calls the version in b.so

bluGill 5y ago
You can do that because the order in which libraries are passed to the linker is something you can control. Of course linkers don't have to do this, and future versions can do something different, but it works and the rules for gcc are currently "the order in which the libraries are passed to g++ when linking", which is defined. Of course gcc has the right to change those rules (I suspect the real rules are a bit more complex) Gcc also has the concept of weak symboles which if invoked (and the linker supports it) would allow you to make one of the two weaker than the others and then the whole doesn't depend on link order. Visual C++ also seems to have something like this, but I'm sure it is different. Like I said, I want to write a paper to make it defined - but the paper will be a lot longer than would fit in a response here, and depending on information that I currently don't know.