base-class

class Material { public: void foo() { cout << "Class Material"; } }; class Unusual_Material : public Material { public: void foo() { cout << "Class Unusual_Material"; } }; int main() { Material strange = Unusual_Material(); strange.foo(); //outputs "Class Material" return 0; } I would like for this to result in the "Class Unusual_Material" being displayed to the console. Is there a way I can achieve this? In my program I have a class Material from which other more specific materials are derived. The method Material::foo() represents a method in Material that is adequate for most materials, but

I have a base class Person and derived classes Manager and Employee . Now, what I would like to know is the object created is Manager or the Employee . The person is given as belows: from Project.CMFCore.utils import getToolByName schema = getattr(Person, 'schema', Schema(())).copy() + Schema((TextField('FirstName', required = True, widget = StringWidget(label='First Name', i18n_domain='project')), TextField('Last Name', required = True, widget = StringWidget(label='Last Name', i18n_domain='i5', label_msgid='label_pub_city')) class Manager(BaseContent): def get_name(self): catalog =

class base{ ..... virtual void function1(); virtual void function2(); }; class derived::public base{ int function1(); int function2(); }; int main() { derived d; base *b = &d; int k = b->function1() // Why use this instead of the following line? int k = d.function1(); // With this, the need for virtual functions is gone, right? } I am not a CompSci engineer and I would like to know this. Why use virtual functions if we can avoid base class pointers? The power of polymorphism isn't really apparent in your simple example, but if you extend it a bit it might become clearer. class vehicle{ .....

This question already has an answer here: Why can't I access C# protected members except like this? 7 answers It may seems rather newbie question, but can you explain why method Der.B() cannot access protected Foo via Base class variable? This looks weird to me: public class Base { protected int Foo; } public class Der : Base { private void B(Base b) { Foo = b.Foo; } // Error: Cannot access protected member private void D(Der d) { Foo = d.Foo; } // OK } Thanks! This is a frequently asked question. To figure out why this is illegal, think about what could go wrong. Suppose you had another

Follow-up question to this one . Basically, in the following code, why does the compiler think that the B inside A<B> in C s constructor refer to the (inaccessible) constructor of the B base class? struct B{}; template <typename T> struct A : private T{}; struct C : public A<B>{ C(A<B>); // ERROR HERE }; Live example on Ideone. Output: prog.cpp:1:9: error: 'struct B B::B' is inaccessible prog.cpp:7:7: error: within this context Note that the same error pops up if you change the constructor argument to A<B*> , A<B&> or even A<const B> . Also note that three of MSVC10, GCC 4.7 and Clang 3.1 ToT