memory-layout

Consider this silly enum: enum Number { Rational { numerator: i32, denominator: std::num::NonZeroU32, }, FixedPoint { whole: i16, fractional: u16, }, } The data in the Rational variant takes up 8 bytes, and the data in the FixedPoint variant takes up 4 bytes. The Rational variant has a field which must be nonzero, so i would hope that the enum layout rules would use that as a discriminator, with zero indicating the presence of the FixedPoint variant. However, this: fn main() { println!("Number = {}", std::mem::size_of::<Number>(),); } Prints: Number = 12 So, the enum gets space for an explicit

I just learned about function pointers (pointers pointing at the adress where where the machine code of a function is stored). This made me think about machine code and how it is stored in memory. Is the machine code stored consecutively in memory, so that it is possible to "manually" increase the pointer until it points to the following/previous function? Is this, what a debugger does? He lets me "see" where the program counter is pointing in the machine code? Conclusion: one can program with function pointers a primitive debugger? Did I understand this right, or am I way off? BlueRaja -

So I've been reading these two articles and this answer Cannot convert []string to []interface {} says that the memory layout needs to be changed. http://jordanorelli.com/post/32665860244/how-to-use-interfaces-in-go says that understanding the underlying memory makes answering this question easy, and http://research.swtch.com/interfaces , explains what is going on under the hood. But for the life of me I can't think of a reason, in terms of the implementation of interfaces as to why []T cannot be cast to []interface. So Why? VonC The article " InterfaceSlice " try to detail: A variable with

If I have a class Base, with at least one virtual function, and a class Derived which inherits singly from this then (uintptr_t)derived - (uintptr_t)static_cast<Base*>(derived) is guaranteed (by the Itanium ABI) to be zero, even though Derived is not standard layout. However in the general case this is not necessarily true (eg. multiple inheritance). Is it possible to write a trait which can be used to detect if one class is the primary base class of another? Useful sections from the Itanium ABI: http://refspecs.linux-foundation.org/cxxabi-1.83.html Primary base class For a dynamic class, the

There is this code: #include <iostream> class Base { public: Base() { std::cout << "Base: " << this << std::endl; } int x; int y; int z; }; class Derived : Base { public: Derived() { std::cout << "Derived: " << this << std::endl; } void fun(){} }; int main() { Derived d; return 0; } The output: Base: 0xbfdb81d4 Derived: 0xbfdb81d4 However when function 'fun' is changed to virtual in Derived class: virtual void fun(){} // changed in Derived Then address of 'this' is not the same in both constructors: Base: 0xbf93d6a4 Derived: 0xbf93d6a0 The other thing is if class Base is polymorphic, for