    class A {
    public:
        virtual void f() = 0;
    };

    class B : public A {
    public:
        void f() final override { };
    };

    int main() {
        B* b = new B();
        b-&gt;f();
    }

In this case, is the compiler required to still do the v-table lookup for `b-&gt;f();`, or can it call `B::f()` directly because it was marked `final`?

Is final used for optimization in C++?

I have an abstract class (I know that it will not compile this way, but it&#39;s for comprehension of what I want to do) :

    class AbstractComputation {
        public:
            template &lt;class T&gt; virtual void setData(std::string id, T data);
            template &lt;class T&gt; virtual T getData(std::string id);
    };
    
    class Computation : public AbstractComputation {
        public:
            template &lt;class T&gt; void setData(std::string id, T data);
            template &lt;class T&gt; T getData(std::string id, T data);
    };

So when I call `setData&lt;double&gt;(&quot;foodouble&quot;, data)` I want the double identified by `foodouble` (internal mechanism which is not the main concern here) to be set to the double data.

So how to do that? 

I think that there may be a mean by typing something like `virtual void setData&lt;double&gt;(std::string id, double data)` but I don&#39;t know how to do it.


C++ Virtual template method

I was experimenting with C++ and found the below code as very strange. 

    class Foo{
    public:
    	virtual void say_virtual_hi(){
    		std::cout &lt;&lt; &quot;Virtual Hi&quot;;
    	}
    
    	void say_hi()
    	{
    		std::cout &lt;&lt; &quot;Hi&quot;;
    	}
    };
    
    int main(int argc, char** argv)
    {
    	Foo* foo = 0;
    	foo-&gt;say_hi(); // works well
    	foo-&gt;say_virtual_hi(); // will crash the app
    	return 0;
    }

I know that the virtual method call crashes because it requires a vtable lookup and can only work with valid objects. 

I have the following questions 

 1. How does the non virtual method `say_hi` work on a NULL pointer?
 2. Where does the object `foo` get allocated?

Any thoughts?

Accessing class members on a NULL pointer

Once before, I was certain that you couldn&#39;t do this, but the other day I was playing around with some code and it seemed to compile and work. I just want to verify that I am not just getting lucky. Can a template class have a pure virtual function - which I guess would also mean just plain virtual methods would be valid as well for the destructor?

    template &lt;typename WordType&gt; class DataSource
    {
    public:
        DataSource();
        DataSource(DataSource const&amp; other);
        virtual ~DataSource();

        virtual void Put(
            WordType const* const data,
            unsigned int const wordCount) = 0;
    }

I&#39;ve tried looking it up online and all that I&#39;ve been able to find is that you cannot have a virtual method (pure or otherwise) in a normal class such as this:

    class DataSource
    {
    public:
        DataSource();
        DataSource(DataSource const&amp; other);
        virtual ~DataSource();

        template &lt;typename WordType&gt;
        virtual void Put(
            WordType const* const data,
            unsigned int const wordCount) = 0;
    }

And that this is due to the imposibility of managing a virtual table to reference all the different types of possible types this method would be instanciated with.

However, when it came to a virtual member function of a template class, it seems to be different because the whole class itself is &quot;created&quot; via the template parameter when the template class variable is instanciated. At this point, the virtual method is just like any other virual method of a class due to the &quot;find-and-replace&quot; nature of templates.

Anyway, stating the question again in case it got lost in there:
Are virtual (pure and/or normal) virtual functions allowed within a tempate class?

Are pure virtual methods allowed within a template class?

In the following blog: http://weblogs.asp.net/scottgu/archive/2010/07/16/code-first-development-with-entity-framework-4.aspx

The blog contains the following code sample:

    public class Dinner
    {
       public int DinnerID { get; set; }
       public string Title { get; set; }
       public DateTime EventDate { get; set; }
       public string Address { get; set; }
       public string HostedBy { get; set; }
       public virtual ICollection&lt;RSVP&gt; RSVPs { get; set; }
    }
    
    public class RSVP
    {
       public int RsvpID { get; set; }
       public int DinnerID { get; set; }
       public string AttendeeEmail { get; set; }
       public virtual Dinner Dinner { get; set; }
    }

What is the purpose of using `virtual` when defining a property in a class?  What effect does it have?



Why use &#39;virtual&#39; for class properties in Entity Framework model definitions?

Is it possible to write *virtual* methods in Java, as one would do in C++?

Or, is there a proper Java approach which you can implement that produces similar behavior? Could I please have some examples?


Can you write virtual functions / methods in Java?

Is it possible in C++ to have a member function that is both `static` and `virtual`? Apparently, there isn&#39;t a straightforward way to do it (`static virtual member();` is a compile error), but is there at least a way to achieve the same effect?

I.E:

    struct Object
    {
         struct TypeInformation;

         static virtual const TypeInformation &amp;GetTypeInformation() const;
    };

    struct SomeObject : public Object
    {
         static virtual const TypeInformation &amp;GetTypeInformation() const;
    };

It makes sense to use `GetTypeInformation()` both on an instance (`object-&gt;GetTypeInformation()`) and on a class (`SomeObject::GetTypeInformation()`), which can be useful for comparisons and vital for templates.

The only ways I can think of involves writing two functions / a function and a constant, per class, or use macros.

Any other solutions?

C++ static virtual members?

As I remember in EF  [navigation property should be virtual][1]:

    public class Blog 
    {  
        public int BlogId { get; set; }  
        public string Name { get; set; }  
        public string Url { get; set; }  
        public string Tags { get; set; }  
    
        public virtual ICollection&lt;Post&gt; Posts { get; set; }  
    }

But I look at [EF Core][2] and don&#39;t see it as virtual:

    public class Student
        {
            public int ID { get; set; }
            public string LastName { get; set; }
            public string FirstMidName { get; set; }
            public DateTime EnrollmentDate { get; set; }
    
            public ICollection&lt;Enrollment&gt; Enrollments { get; set; }
        }

Is it not required anymore?

  [1]: https://stackoverflow.com/questions/25715474/why-navigation-properties-are-virtual-by-default-in-ef
  [2]: https://docs.microsoft.com/en-us/aspnet/core/data/ef-mvc/intro

navigation property should be virtual - not required in ef core?

How can I use CRTP in C++ to avoid the overhead of virtual member functions?

CRTP to avoid dynamic polymorphism

So for creating files I use the following:

    fileHandle = open(&#39;fileName&#39;, &#39;w&#39;)

then write the contents to the file, close the file.
In the next step I process the file.
At the end of the program, I end up with a &quot;physical file&quot; that I need to delete.

Is there a way to write a &quot;virtual&quot; file that behaves exactly like a &quot;physical&quot; one (allowing it to be manipulated the same way) but does not exist at the end of the run in Python?

How to do virtual file processing?

Why would you declare a method as &quot;virtual&quot;. 

What is the benefit in using virtual?

What are Virtual Methods?

clang emits a warning when compiling the following code:


    struct Base
    {
        virtual void * get(char* e);
    //    virtual void * get(char* e, int index);
    };

    struct Derived: public Base {
        virtual void * get(char* e, int index);
    };

The warning is:

    warning: &#39;Derived::get&#39; hides overloaded virtual function [-Woverloaded-virtual]

(the said warning needs to be enabled of course).

I don&#39;t understand why. Note that uncommenting the same declaration in Base shuts the warning up. My understanding is that since the two get() functions have different signatures, there can be no hiding.

Is clang right? Why?

Note this is on MacOS X, running a recent version of Xcode. 

    clang --version
    Apple LLVM version 5.0 (clang-500.1.74) (based on LLVM 3.3svn)

Update: same behavior with Xcode 4.6.3.

c++ overloaded virtual function warning by clang?

I&#39;m pretty confused between some concepts of OOP: `virtual`, `override`, `new` and `sealed override`. Can anyone explain the differences?

I am pretty clear that if the derived class method is to be used, one can use the `override` keyword so that the base class method will be overriden by derived class. But I&#39;m not sure about `new`, and `sealed override`.

The difference between virtual, override, new and sealed override

What exactly does it mean if a function is defined as virtual and is that the same as pure virtual?

Virtual/pure virtual explained

Assignment Operator in C++ can be made virtual. Why is it required? Can we make other operators virtual too?

virtual assignment operator C++

I&#39;m developing android with SDK 2.3.3 using Eclipse IDE.
As you all know to run my app, I should generate virtual device.
From &#39;create new AVD&#39; window, I can see many targets. 
There are 2 targets for API level 10 such as &#39;android 2.3.3&#39; and Google APIs(Google Inc).
Among those targets, I&#39;m uncertain which one I should choose.

My question is what&#39;s the difference between them.

Thanks in advance
Dan

Difference between target google APIs and target android

I did find some questions already on StackOverflow with similar title, but when I read the answers, they were focusing on different parts of the question, which were really specific (e.g. STL/containers).

Could someone please show me, why you must use pointers/references for implementing polymorphism? I can understand pointers may help, but surely references only differentiate between pass-by-value and pass-by-reference?

Surely so long as you allocate memory on the heap, so that you can have dynamic binding, then this would have been enough. Obviously not.

Why doesn&#39;t polymorphism work without pointers/references?

What is the meaning of &quot;virtual&quot; inheritance?

I saw the following code, and didn&#39;t understand the meaning of the keyword `virtual` in the following context: 

    class A {};
    class B : public virtual A;

virtual inheritance

Question is as stated in the title: What are the performance implications of marking methods / properties as virtual?

Note - I&#39;m assuming the virtual methods will *not* be overloaded in the common case; I&#39;ll usually be working with the base class here.

What are the performance implications of marking methods / properties as virtual?

Say we have:
&lt;pre&gt;&lt;code&gt;
Class Base
{   
    virtual void f(){g();};
    virtual void g(){//Do some Base related code;}
};

Class Derived : public Base
{   
    virtual void f(){Base::f();};
    virtual void g(){//Do some Derived related code};
};

int main()
{
    Base *pBase = new Derived;
    pBase-&gt;f();
    return 0;  
}

&lt;/code&gt;&lt;/pre&gt;

Which `g()` will be called from `Base::f()`? `Base::g()` or `Derived::g()`?

Thanks... 

virtual function call from base class

As far as I know, both abstract methods and pure virtual functions do NOT provide any functionality ... So can we say they&#39;re both the same thing ?

Also, suppose a class (not necessarily declared as abstract) contains a number of implemented methods (not abstract or virtual), but contains a pure virtual function. Is this class then abstract ?

Are abstract methods and pure virtual functions the same thing?

What are the advantages and disadvantages of each of these?

 - interface methods
 - virtual methods
 - abstract methods

When one should choose what? What are the points one should keep in mind when making this decision?

Comparison : interface methods vs virtual methods vs abstract methods

**Why the following example prints &quot;0&quot; and what must change for it to print &quot;1&quot; as I expected ?**

    #include &lt;iostream&gt;
    struct base {
       virtual const int value() const {
          return 0;
       }
       base() {
          std::cout &lt;&lt; value() &lt;&lt; std::endl;
       }
       virtual ~base() {}
    };
    
    struct derived : public base {
       virtual const int value() const {
          return 1;
       }
    };
    
    int main(void) {
       derived example;
    }


All Virtual Solutions on Gang of Coders

Total of 23 Virtual Solutions