Assuming you intended B to derive from A: f(int) and f() are different signatures, hence different functions. You can override a virtual function with a function that has a compatible signature, which means either an identical signature, or one in which the return type is “more specific” (this is covariance). Otherwise, your derived class function … Read more
The return type is permissible since derived inherits from base, but the function parameter can’t work – not all base instances will be a derived also. What’s supposed to happen in the cases where func is called on a pointer to base with a parameter that’s not a derived? The most derived implementation isn’t callable.
You could down cast the base class pointer to the derived class and call the function. Base* obj = new Derived; Derived* d = static_cast<Derived*>( obj ); d->doSomething(); Since doSomething() is not declared virtual, you should get the derived implementation.
I am not sure what causes the problem in your case, but code below works for me without any issues (OS X, the same version of Conda as yours). Creation of the environment conda create -n test_env python=3.6.3 anaconda Some explanation of the documentation of conda create is not clear: -n test_env sets name of the … Read more
This is probably best handled as an instance method you add to teamSchema so that the caller can provide a callback to receive the async result: teamSchema.methods.getSquad = function(callback) { Players.find({ team_id: this._id }, callback); });
The v-table is per class and not per object. Each object contains just a pointer to its v-table. So the overhead per instance is sizeof(pointer) (usually 4 or 8 bytes). It doesn’t matter how many virtual functions you have for the sizeof the class object. Considering this, I think you shouldn’t worry too much about … Read more
Yes, it’s OK even without inline. It works the same for ordinary member functions and static variables: // everything in the header: template <class T> class A { static int i; }; template <class T> int A<T>::i=0; Standard quote: (3.2/5) There can be more than one definition of a class type (Clause 9), enumeration type … Read more
The issue that you are experiencing is related to how name lookup works in C++. In particular, when resolving a member, the compiler will look into the static type of the object on which the member is being accessed. If the identifier is found in that class, then lookup completes and (in the case of … Read more
The code you’ve posted should work the way you want. Calling doSomething on an instance of derived will call the overridden start and stop functions defined in derived. There’s an exception to that, though. If you call doSomething in the constructor or destructor of base (whether directly or indirectly), then the versions of start and … Read more
I note that there are two questions here. In the future you might consider posting two questions instead of combining two questions in one. When you combine questions like this often what happens is only the first one gets answered. The first question is “why are private virtual methods illegal in C#?” Here are the … Read more