The problem with this setup is that the operator<< you defined above is a free function, which can’t be virtual (it has no receiver object). In order to make the function virtual, it must be defined as a member of some class, which is problematic here because if you define operator<< as a member of … Read more
The problem is that you cannot mix static time polymorphism (templates) with runtime polymorphism easily. The reason for the language disallowing the particular construct in your example is that there are potentially infinite different types that could be instantiating your template member function, and that in turn means that the compiler would have to generate … Read more
virtual was never required in EF. It was needed only if you want lazy loading support. Since Lazy loading is not yet supported by EF Core, currently virtual have no special meaning. It would when (and if) they add lazy loading support (there is a plan for doing so). Update: Starting with EF Core 2.1, … Read more
You might want to consider using a tempfile.SpooledTemporaryFile which gives you the best of both worlds in the sense that it will create a temporary memory-based virtual file initially but will automatically switch to a physical disk-based file if the data held in memory exceeds a specified size. Another nice feature is that (when using … Read more
There are two ways. The first one is by specifying the interface statically for the structure of types: template <class Derived> struct base { void foo() { static_cast<Derived *>(this)->foo(); }; }; struct my_type : base<my_type> { void foo(); // required to compile. }; struct your_type : base<your_type> { void foo(); // required to compile. }; … Read more
It allows the Entity Framework to create a proxy around the virtual property so that the property can support lazy loading and more efficient change tracking. See What effect(s) can the virtual keyword have in Entity Framework 4.1 POCO Code First? for a more thorough discussion. Edit to clarify “create a proxy around”: By “create … Read more
No, there’s no way to do it, since what would happen when you called Object::GetTypeInformation()? It can’t know which derived class version to call since there’s no object associated with it. You’ll have to make it a non-static virtual function to work properly; if you also want to be able to call a specific derived … Read more
The assignment operator is not required to be made virtual. The discussion below is about operator=, but it also applies to any operator overloading that takes in the type in question, and any function that takes in the type in question. The below discussion shows that the virtual keyword does not know about a parameter’s … Read more
Because base is constructed first and hasn’t “matured” into a derived yet. It can’t call methods on an object when it can’t guarantee that the object is already properly initialized.
The object foo is a local variable with type Foo*. That variable likely gets allocated on the stack for the main function, just like any other local variable. But the value stored in foo is a null pointer. It doesn’t point anywhere. There is no instance of type Foo represented anywhere. To call a virtual … Read more