C ++和Swift：如何在C ++堆栈帧中处理结构？ 结构继承的复杂性是什么Swift不支持结构继承？

Question

At a recent developer meet up the topic of struct inheritance in Swift (or more precisely the lack of struct inheritance in Swift) was briefly discussed. I assumed that the reason why Swift does not support struct inheritance is because:

• struct s are value types
• value types are copied between stack frames
• inheritance would mean that the size of a struct could vary (eg if Lorry inherits from Vehicle and Lorry adds .weightCapacity then Lorry will require more space than Vehicle )
• Having value type parameters with a size that is not known at compile time would complicate stack frame construction for the caller and accessing the data for the callee

I assume that it is because of these complications, which presumably would add extra operations to every function call that involves a struct and thus degrade performance, that Swift does not allow struct inheritance. Is this reasoning correct?

But then I though about C++. C++ does allow struct inheritance and C++ is very performance focused. This makes me think that my reasoning for Swift not allowing struct inheritance is wrong. How does C++ achieved struct inheritance without negatively impacting performance?

Answer 1

How does C++ achieved struct inheritance without negatively impacting performance?

In C++, the compiler always knows the size of a struct . But when a base class is copied by value, the object gets "sliced": only members of the base class are copied, and the new object is not in any way related to the original object's derived class.

So if a function wants to do something with a Vehicle without slicing off its extra identity, it must use a pointer or reference to Vehicle as the function parameter type or return type. But at that point you no longer have "value types copied between stack frames".

Answer 2

Since structs are value types, you are supposed to copy them into the function and back. So you could call a non-mutating method with the derived struct, but wouldn't be able to return a derived value from it, so

struct Vehicle {
   var color: Color

   mutating func paintWhite() {
       self.color = .White
   } 
}


struct Lorry: Vehicle ...

var lorry = Lorry(color:.Blue)
lorry.paintWhite() // <- wouldn't work, as paintWhite takes inout Vehicle

Without the ability to call mutating methods structs would be much less useful and much more confusing.