name-hiding

I am trying to do something I haven't really done before. I basically have 3 classes. Class A is an abstract class with pure virtual methods, Class B is a class on it's own that contains methods with the same name as the virtual methods in Class A. I'm trying to tie everything together in Class C. I'd like to inherit class B and A in C (multiple inheritance), and use the methods from Class B to implement those in class A. This way I create a modular approach. The example below is a very simplified version of my code. class A { virtual int methodA() = 0; virtual int methodB() = 0; virtual int

Consider following code snippet: struct S { S( const int a ) { this->a = a; // option 1 S::a = a; // option 2 } int a; }; Is option 1 is equivalent to option 2? Are there cases when one form is better than another? Which clause of standard describes these options? option 1 is equivalent to option 2, but option 1 will not work for a static data member EDITED: static data members can be accessed with this pointer. But this->member will not work in static function. but option 2 will work in static function with static member Eg: struct S { static void initialize(int a) { //this->a=a; compilation

Is there something in the C++ standard that prevents me from overloading a super class's function? Starting with this pair of classes: class A { // super class int x; public: void foo (int y) {x = y;} // original definition }; class B : public A { // derived class int x2; public: void foo (int y, int z) {x2 = y + z;} // overloaded }; I can call B::foo() easily: B b; b.foo (1, 2); // [1] But if I try to call A::foo() ... B b; b.foo (12); // [2] ... I get a compiler error: test.cpp: In function 'void bar()': test.cpp:18: error: no matching function for call to 'B::foo(int)' test.cpp:12: note:

It recently came to my attention that member functions completely shadow free functions with the same name when inside the class. And by completely i mean that every free function with the same name is not considered for overload resolution at all. I can understand why it's done with somwthing like this: void f(); struct S { void f(); void g() { f(); // calls S::f instead of ::f } }; where the functions have identical signatures, its only natural as variable scoping works the same way. But why prohibit unambigious calls where free function has different signature like this: void f(); struct S