virtual-functions

问题 I have the following definitions: class PartitioningMethod { public: virtual void addConstraints(ConstraintManager& cm) = 0; virtual bool hasMoreConstraints() = 0; virtual void setQuery(const Query& q) = 0; virtual ~PartitioningMethod(){ } }; class Random : public PartitioningMethod { private: vector< ref<Expr> > constraints; vector< ref<Expr> >::iterator it; vector< ref<Expr> >::iterator end; int numConstraints; RNG theRNG; public: void setQuery(const Query& q) { constraints.clear(); //Set

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

问题 I was curious about C++ and virtual inheritance - in particular, the way that vtable conflicts are resolved between bass and child classes. I won't pretend to understand the specifics on how they work, but what I've gleamed so far is that their is a small delay caused by using virtual functions due to that resolution. My question then is if the base class is blank - ie, its virtual functions are defined as: virtual void doStuff() = 0; Does this mean that the resolution is not necessary,

问题 I have a bunch of systems, lets call them A, B, C, D, E, F, G, H, I, J . They all have similar methods and properties. Some contain the exact same method and properties, some may vary slightly and some may vary a lot. Right now, I have a lot of duplicated code for each system. For example, I have a method called GetPropertyInformation() that is defined for each system. I am trying to figure out which method would be the best approach to reduce duplicate code or maybe one of the methods below

问题 I have a confusion about the inheriting the virtual property of a method. Let's suppose we have 4 classes: class A, class B, class C and class D. The classes are inherited by this way: A -> B -> C -> D, where A is the base class. By this time, I'm sure about this: Beginning the class method declaration with virtual in a base class (class A), makes the method virtual for all classes derived from the base class, including the derived ones of the derived classes. (B and C class methods

问题 Consider the following: In X.h: class X { X(); virtual ~X(); }; X.cpp: #include "X.h" X::X() {} Try to build this (I'm using a .dll target to avoid an error on the missing main, and I'm using Visual Studio 2010): Error 1 error LNK2001: unresolved external symbol "private: virtual __thiscall X::~X(void)" (??1X@@EAE@XZ) Small modifications result in a successful build, however: X.h: class X { inline X(); // Now inlined, and everything builds virtual ~X(); }; or X.h: class X { X(); ~X(); // No

问题 This is maybe a fine point, but it concerns the warning that the compiler issues if you do something like: class A { public virtual void F() { } } class B : A { public void F() { } } Then you get the warning: 'EomApp1.B.F()' hides inherited member 'EomApp1.A.F()'. To make the current member override that implementation, add the override keyword. Otherwise use the new keyword. QUESTION: What is the warning actually warning me will happen if I do nothing about it? Will my program function

问题 The sample method below is intended to detect whether or not it has been overridden in a derived class. The error I get from MSVC implies that it is simply wrong to try to get the function pointer to a "bound" member, but I see no logical reason why this should be a problem (after all, it will be in this->vtable ). Is there any non-hacky way of fixing this code? class MyClass { public: typedef void (MyClass::*MethodPtr)(); virtual void Method() { MethodPtr a = &MyClass::Method; // legal

问题 I have a pure abstract base and two derived classes: struct B { virtual void foo() = 0; }; struct D1 : B { void foo() override { cout << "D1::foo()" << endl; } }; struct D2 : B { void foo() override { cout << "D1::foo()" << endl; } }; Does calling foo in Point A cost the same as a call to a non-virtual member function? Or is it more expensive than if D1 and D2 wouldn't have derived from B? int main() { D1 d1; D2 d2; std::vector<B*> v = { &d1, &d2 }; d1.foo(); d2.foo(); // Point A

问题 Following this question, I'm wondering why a struct\class in C++ has to have a virtual method in order to be polymorphic. Forcing a virtual destructor makes sense, but if there's no destructor at all, why is it mandatory to have a virtual method? 回答1: Because the type of a polymorphic object in C++ is, basically, determined from the pointer to its vtable, which is the table of virtual functions. The vtable is, however, only created if there's at least one virtual method. Why? Because in C++,