name-hiding

问题 I am getting below warning . part of my code is : class Base { public: virtual void process(int x) {;}; virtual void process(int a,float b) {;}; protected: int pd; float pb; }; class derived: public Base{ public: void process(int a,float b); } void derived::process(int a,float b){ pd=a; pb=b; .... } I am getting below warning : Warning: overloaded virtual function "Base::process" is only partially overridden in class "derived" any way i have made process as virtual function so I am expecting

问题 I am getting below warning . part of my code is : class Base { public: virtual void process(int x) {;}; virtual void process(int a,float b) {;}; protected: int pd; float pb; }; class derived: public Base{ public: void process(int a,float b); } void derived::process(int a,float b){ pd=a; pb=b; .... } I am getting below warning : Warning: overloaded virtual function "Base::process" is only partially overridden in class "derived" any way i have made process as virtual function so I am expecting

问题 This question already has answers here : Why does an overridden function in the derived class hide other overloads of the base class? (4 answers) Closed 2 years ago . I know this is not the first question on this subject, but all the other related questions (and answers) I read were slightly out of the point, according to me. Take the code #include <iostream> using namespace std ; class Base { public: void methodA() { cout << "Base.methodA()" << endl ;} }; class Derived : public Base { public

问题 Consider I have two pure virtual classes, one deriving from the another and a concrete class deriving from the last mentioned: #include <iostream> #include <string> class Abstract1 { public: virtual ~Abstract1() { }; virtual void method(int a) = 0; protected: Abstract1() = default; }; class Abstract2: public Abstract1 { public: virtual ~Abstract2() { }; virtual void method(char c, std::string s) = 0; protected: Abstract2() = default; }; class Concrete : public Abstract2 { public: void method

问题 Consider I have two pure virtual classes, one deriving from the another and a concrete class deriving from the last mentioned: #include <iostream> #include <string> class Abstract1 { public: virtual ~Abstract1() { }; virtual void method(int a) = 0; protected: Abstract1() = default; }; class Abstract2: public Abstract1 { public: virtual ~Abstract2() { }; virtual void method(char c, std::string s) = 0; protected: Abstract2() = default; }; class Concrete : public Abstract2 { public: void method

问题 Starting from this question: Pointer derived from pure virtual class(A) can't access overload method from the pure class (B) And considering this simplified code: #include <string> #include <iostream> class Abstract { public: virtual void method(int a) { std::cout << __PRETTY_FUNCTION__ << "a: " << a << std::endl; } }; class Concrete : public Abstract { public: void method(char c, std::string s) { std::cout << __PRETTY_FUNCTION__ << "c: " << c << "; s: " << s << std::endl; } }; int main() {

问题 Starting from this question: Pointer derived from pure virtual class(A) can't access overload method from the pure class (B) And considering this simplified code: #include <string> #include <iostream> class Abstract { public: virtual void method(int a) { std::cout << __PRETTY_FUNCTION__ << "a: " << a << std::endl; } }; class Concrete : public Abstract { public: void method(char c, std::string s) { std::cout << __PRETTY_FUNCTION__ << "c: " << c << "; s: " << s << std::endl; } }; int main() {

问题 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 something 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

问题 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? 回答1: 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

问题 I want to modify a constructor to use an initialization list as in the following example: class Foo { public: Foo(std::wstring bar); private: std::wstring bar; }; // VERSION 1: Foo::Foo(std::wstring bar) {this->bar = bar} // VERSION 2: Foo::Foo(std::wstring bar) : this->bar(bar) {} // ERROR! Unfortunately I can't do version 2 because you can't use the this pointer for data members since (I'm guessing) they don't exist yet at that point. How then, do I deal with the name hiding issue (i.e. my