overriding

I have a base class with a virtual function and I want to override that function in a derived class. Is there some way to make the compiler check if the function I declared in the derived class actually overrides a function in the base class? I would like to add some macro or something that ensures that I didn't accidentally declare a new function, instead of overriding the old one. Take this example: class parent { public: virtual void handle_event(int something) const { // boring default code } }; class child : public parent { public: virtual void handle_event(int something) { // new

Let's say you have the below code: function A() { function modify(){ x = 300; y = 400; } var c = new C(); } function B() { function modify(){ x = 3000; y = 4000; } var c = new C(); } C = function () { var x = 10; var y = 20; function modify() { x = 30; y = 40; }; modify(); alert("The sum is: " + (x+y)); } Now the question is, if there is any way in wich I can override the method modify from C with the methods that are in A and B. In Java you would use the super keyword, but how can you achieve something like this in JavaScript? Edit: It's now six years since the original answer was written and

There are quite a few questions & answers about hacking around the limitation of C# not allowing method return (and argument) types to be changed to compatible types on overrides, but why does this limitation exist, either in the C# compiler or in the CLR? As I an see, there is nothing that could break if co/contra-variance was allowed, so what is the reasoning behind it? A similar question could be asked for widening access parameters - eg overriding a protected internal method with a public method (something which Java supports, IIRC) Robert Kozak Eric Lippert already answered this way

In C++ why the pure virtual method mandates its compulsory overriding only to its immediate children (for object creation), but not to the grand children and so on ? struct B { virtual void foo () = 0; }; struct D : B { virtual void foo () { ... }; }; struct DD : D { // ok! ... if 'B::foo' is not overridden; it will use 'D::foo' implicitly }; I don't see any big deal in leaving this feature out. For example, at language design point of view, it could have been possible that, struct DD is allowed to use D::foo only if it has some explicit statement like using D::foo; . Otherwise it has to

I make a class like below: class MyList(list): def __init__(self, lst): self.list = lst I want slice functionality to be overridden in MyList You need to provide custom __getitem__() , __setitem__ and __delitem__ hooks. These are passed a slice object when slicing the list; these have start , stop and step attributes (which could be None ): def __getitem__(self, key): if isinstance(key, slice): return [self.list[i] for i in xrange(key.start, key.stop, key.step)] return self.list[key] or, for your case: def __getitem__(self, key): return self.list[key] because a list can take the slice object

When I was trying to use this code to enable preferences into my app import android.app.Activity; import android.content.SharedPreferences; import android.os.Bundle; import android.preference.Preference; import android.preference.PreferenceActivity; import android.preference.Preference.OnPreferenceClickListener; import android.widget.CheckBox; import android.widget.CompoundButton; import android.widget.RadioButton; import android.widget.Toast; import android.widget.CompoundButton.OnCheckedChangeListener; public class Preferences extends PreferenceActivity { private RadioButton btn01; @Override